modtulip.c

#include <stdio.h>
#include <string.h>
#include "polyfills.h"

#include "py/runtime.h"
#include "py/mperrno.h"
#include "py/mphal.h"
#include "extmod/vfs.h"
#include "py/stream.h"
#ifndef __EMSCRIPTEN__
#include "amy.h"
#endif
#ifndef __EMSCRIPTEN__
#include "amy_midi.h"
#endif
#include "amy_connector.h"
#include "tsequencer.h"
#if !defined(AMYBOARD) && !defined(AMYBOARD_WEB)
#include "ui.h"
#include "keyscan.h"
#include "display.h"
#include "bresenham.h"
#endif
#include "genhdr/mpversion.h"

#ifdef ESP_PLATFORM
#include "tasks.h"
#include "driver/rtc_io.h"
#endif



#ifndef __EMSCRIPTEN__
// on web this will get shim in with js 
STATIC mp_obj_t tulip_amy_ticks_ms(size_t n_args, const mp_obj_t *args) {
    return mp_obj_new_int(amy_sysclock());
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_amy_ticks_ms_obj, 0, 0, tulip_amy_ticks_ms);

// Smoothed fraction of real time AMY spends rendering (0..1); ~1.0 means overloaded.
STATIC mp_obj_t tulip_amy_render_load(size_t n_args, const mp_obj_t *args) {
    return mp_obj_new_float(amy_get_render_load());
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_amy_render_load_obj, 0, 0, tulip_amy_render_load);

STATIC mp_obj_t tulip_amy_set_render_load_threshold(size_t n_args, const mp_obj_t *args) {
    // MicroPython version of amy/src/pyamy.c:set_render_load_threshold
    amy_set_render_load_threshold(mp_obj_get_float(args[0]));
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_amy_set_render_load_threshold_obj, 1, 1, tulip_amy_set_render_load_threshold);

#endif

STATIC mp_obj_t tulip_ticks_ms(size_t n_args, const mp_obj_t *args) {
    return mp_obj_new_int(get_ticks_ms());
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_ticks_ms_obj, 0, 0, tulip_ticks_ms);

STATIC mp_obj_t tulip_stderr_write(size_t n_args, const mp_obj_t *args) {
    const char *msg = mp_obj_str_get_str(args[0]);
    fprintf(stderr, "%s\n", msg);
    fflush(stderr);
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_stderr_write_obj, 1, 1, tulip_stderr_write);




STATIC mp_obj_t tulip_board(size_t n_args, const mp_obj_t *args) {
#ifdef TULIP4_R11
    return mp_obj_new_str("TULIP4_R11", strlen("TULIP4_R11"));
#elif defined MATOUCH7
    return mp_obj_new_str("MATOUCH7", strlen("MATOUCH7"));
#elif defined TDECK
    return mp_obj_new_str("TDECK", strlen("TDECK"));
#elif defined N16R8
    return mp_obj_new_str("N16R8", strlen("N16R8"));
#elif defined N32R8
    return mp_obj_new_str("N32R8", strlen("N32R8"));
#elif defined TULIP_DESKTOP
    return mp_obj_new_str("DESKTOP", strlen("DESKTOP"));    
#elif defined TULIP_WEB
    return mp_obj_new_str("WEB", strlen("WEB"));    
#elif defined AMYBOARD_WEB
    return mp_obj_new_str("AMYBOARD_WEB", strlen("AMYBOARD_WEB"));    
#elif defined AMYBOARD
    return mp_obj_new_str("AMYBOARD", strlen("AMYBOARD"));    
#else    
    return mp_obj_new_str("OTHER", strlen("OTHER"));
#endif
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_board_obj, 0, 0, tulip_board);


mp_obj_t midi_callback = NULL;

STATIC mp_obj_t tulip_midi_callback(size_t n_args, const mp_obj_t *args) {
    midi_callback = args[0];
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_midi_callback_obj, 1, 1, tulip_midi_callback);

// Called (via mp_sched_schedule from the AMY render task) when AMY's CPU
// overload failsafe trips, with the render load percent as a small int.
mp_obj_t amy_overload_callback = NULL;

STATIC mp_obj_t tulip_amy_overload_callback(size_t n_args, const mp_obj_t *args) {
    amy_overload_callback = (args[0] == mp_const_none) ? NULL : args[0];
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_amy_overload_callback_obj, 1, 1, tulip_amy_overload_callback);

// tulip.external_midi_sync() is defined in tulip.py: it sends the AMY wire
// command (external_midi_sync / zC) so it also works on the web builds, where
// AMY is a separate WASM module reachable only via the wire protocol.

#ifndef __EMSCRIPTEN__
extern int amy_get_output_buffer(int16_t *samples);
extern int amy_get_input_buffer(int16_t *samples);
extern void amy_set_external_input_buffer(int16_t * samples);

mp_obj_t amy_block_done_callback = NULL;

STATIC mp_obj_t tulip_amy_block_done_callback(size_t n_args, const mp_obj_t *args) {
    if(n_args==0) {
        amy_block_done_callback = NULL;
    } else {
        amy_block_done_callback = args[0];
    }
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_amy_block_done_callback_obj, 0, 1, tulip_amy_block_done_callback);


STATIC mp_obj_t tulip_amy_get_output_buffer(size_t n_args, const mp_obj_t *args) {
    uint8_t buf[1024];
    int n = amy_get_output_buffer((int16_t*)buf);
    if (n == 0) return mp_const_none;
    mp_obj_t output_bytes = mp_obj_new_bytes(buf, n);
    return output_bytes;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_amy_get_output_buffer_obj, 0, 0, tulip_amy_get_output_buffer);

STATIC mp_obj_t tulip_amy_get_input_buffer(size_t n_args, const mp_obj_t *args) {
    uint8_t buf[1024];
    int n = amy_get_input_buffer((int16_t*)buf);
    if (n == 0) return mp_const_none;
    mp_obj_t input_bytes = mp_obj_new_bytes(buf, n);
    return input_bytes;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_amy_get_input_buffer_obj, 0, 0, tulip_amy_get_input_buffer);

STATIC mp_obj_t tulip_amy_set_external_input_buffer(size_t n_args, const mp_obj_t *args) {
    mp_buffer_info_t bufinfo;
    mp_get_buffer(args[0], &bufinfo, MP_BUFFER_READ);
    if(bufinfo.len!=1024) {  mp_raise_ValueError(MP_ERROR_TEXT("bytes len must be 1024")); }
    amy_set_external_input_buffer((int16_t*)bufinfo.buf);
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_amy_set_external_input_buffer_obj, 1, 1, tulip_amy_set_external_input_buffer);

STATIC mp_obj_t tulip_amy_get_synth_commands(size_t n_args, const mp_obj_t *args) {
    // MicroPython version of amy/src/pyamy.c:get_synth_commands, to retrieve synth config from MP.
    // We know we have exactlu one arg from the MP_DEFINE_CONST_FUN declaration below.
    char s[MAX_MESSAGE_LEN];
    void *state = NULL;
    int synth = mp_obj_get_int(args[0]);
    bool include_fx = true;
    if (n_args > 1)  include_fx = mp_obj_get_int(args[1]);
    // Make a new list object, append the retrieved (and converted) strings to it.
    mp_obj_t list = mp_obj_new_list(0, NULL);
    do {
        state = yield_synth_commands(synth, s, MAX_MESSAGE_LEN, include_fx, state);
        int slen = strlen(s);
        if (slen)
            mp_obj_list_append(list, mp_obj_new_str(s, slen));
    } while (state != NULL);
    return list;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_amy_get_synth_commands_obj, 1, 2, tulip_amy_get_synth_commands);

STATIC mp_obj_t tulip_sequencer_start(void) {
    extern void sequencer_midi_start(void);
    sequencer_midi_start();
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(tulip_sequencer_start_obj, tulip_sequencer_start);

STATIC mp_obj_t tulip_amy_dump_state(void) {
    int len = 0;
    char *buf = amy_dump_state_to_string(&len);
    if (!buf || len <= 0) {
        return mp_obj_new_str("", 0);
    }
    mp_obj_t result = mp_obj_new_str(buf, len);
    free(buf);
    return result;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(tulip_amy_dump_state_obj, tulip_amy_dump_state);

#endif

#ifdef ESP_PLATFORM
extern uint8_t * external_map;
STATIC mp_obj_t tulip_amy_set_external_channel(size_t n_args, const mp_obj_t *args) {
    uint16_t osc = mp_obj_get_int(args[0]);
    uint8_t ch = mp_obj_get_int(args[1]);
    external_map[osc] = ch;
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_amy_set_external_channel_obj, 2, 2, tulip_amy_set_external_channel);

// Map a synth number to a CV output channel (1-based, 0 = clear)
#define MAX_CV_SYNTHS 32
extern uint8_t cv_synth_map[MAX_CV_SYNTHS];
STATIC mp_obj_t tulip_set_cv_synth(size_t n_args, const mp_obj_t *args) {
    uint8_t synth = mp_obj_get_int(args[0]);
    uint8_t cv_channel = mp_obj_get_int(args[1]);  // 1 = CV1, 2 = CV2, 0 = clear
    if (synth < MAX_CV_SYNTHS) {
        cv_synth_map[synth] = cv_channel;
    }
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_set_cv_synth_obj, 2, 2, tulip_set_cv_synth);
#endif

STATIC mp_obj_t tulip_defer(size_t n_args, const mp_obj_t *args) {
    int8_t index = -1;
    for(uint8_t slot=0;slot<DEFER_SLOTS;slot++) {
        if(defer_callbacks[slot]==NULL) {
            index = slot; slot = DEFER_SLOTS+1;
        }
    }
    if(index>=0) {
        defer_callbacks[index] = args[0];
        defer_args[index] = args[1];
        defer_sysclock[index] = get_ticks_ms() + mp_obj_get_int(args[2]);

    } else {
        mp_raise_ValueError(MP_ERROR_TEXT("No more defer slots available"));
    }
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_defer_obj, 3, 3, tulip_defer);



STATIC mp_obj_t tulip_seq_add_callback(size_t n_args, const mp_obj_t *args) {
    int8_t index = -1;
    for(uint8_t slot=0;slot<SEQUENCER_SLOTS;slot++) {
        if(sequencer_callbacks[slot]==NULL) {
            index = slot; slot = SEQUENCER_SLOTS+1;
        }
    }
    if(index>=0) {
        sequencer_callbacks[index] = args[0];
        sequencer_tick[index] = mp_obj_get_int(args[1]);
        sequencer_period[index] = mp_obj_get_int(args[2]);
    } else {
        index = -1;
    }
    return mp_obj_new_int(index);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_seq_add_callback_obj, 3, 3, tulip_seq_add_callback);

STATIC mp_obj_t tulip_seq_remove_callback(size_t n_args, const mp_obj_t *args) {
    int8_t index = mp_obj_get_int(args[0]);
    if(index>=0 && index <SEQUENCER_SLOTS) {
        sequencer_callbacks[index] = NULL;
        sequencer_period[index] = 0;
        sequencer_tick[index] = 0;
    }
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_seq_remove_callback_obj, 1, 1, tulip_seq_remove_callback);

STATIC mp_obj_t tulip_seq_remove_callbacks(size_t n_args, const mp_obj_t *args) {
    for(uint8_t i=0;i<SEQUENCER_SLOTS;i++) {
        sequencer_callbacks[i] = NULL;
        sequencer_period[i] = 0;
        sequencer_tick[i] = 0;
    }
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_seq_remove_callbacks_obj, 0, 0, tulip_seq_remove_callbacks);



STATIC mp_obj_t tulip_seq_ticks(size_t n_args, const mp_obj_t *args) {
#ifdef AMY_IS_EXTERNAL
    return mp_obj_new_int(sequencer_tick_count);
#else
    return mp_obj_new_int(amy_global.sequencer_tick_count);
#endif
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_seq_ticks_obj, 0, 0, tulip_seq_ticks);

extern uint8_t last_midi[MIDI_QUEUE_DEPTH][MAX_MIDI_BYTES_PER_MESSAGE];
extern uint8_t last_midi_len[MIDI_QUEUE_DEPTH];

extern int16_t midi_queue_head;
extern int16_t midi_queue_tail ;

STATIC mp_obj_t tulip_midi_in(size_t n_args, const mp_obj_t *args) {

    if(midi_queue_head != midi_queue_tail) {
        int16_t prev_head = midi_queue_head;
        // Step on the head, hope no-one notices before we pop it.
        midi_queue_head = (midi_queue_head + 1) % MIDI_QUEUE_DEPTH;
        return mp_obj_new_bytes(last_midi[prev_head],
                                last_midi_len[prev_head]);
    } 
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_midi_in_obj, 0, 0, tulip_midi_in);

extern uint16_t sysex_len;
STATIC mp_obj_t tulip_sysex_in(size_t n_args, const mp_obj_t *args) {
    if(sysex_len) {
        mp_obj_t sysex_bytes = mp_obj_new_bytes(sysex_buffer, sysex_len);
        sysex_len = 0; // consumed, move on
        return sysex_bytes;
    } 
    return mp_const_none;
}


STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_sysex_in_obj, 0, 0, tulip_sysex_in);

extern void tulip_send_midi_out(uint8_t *, uint16_t);

STATIC mp_obj_t tulip_midi_out(size_t n_args, const mp_obj_t *args) {
    if(mp_obj_get_type(args[0]) == &mp_type_bytes) {
        mp_buffer_info_t bufinfo;
        mp_get_buffer(args[0], &bufinfo, MP_BUFFER_READ);
        tulip_send_midi_out((uint8_t*)bufinfo.buf, bufinfo.len);
    } else {
        mp_obj_t *items;
        size_t len;
        mp_obj_get_array(args[0], &len, &items);
        uint8_t *b = malloc_caps(len, MALLOC_CAP_INTERNAL);
        for(uint16_t i=0;i<(uint16_t)len;i++) {
            b[i] = mp_obj_get_int(items[i]);
        }
        tulip_send_midi_out(b, len);
        free_caps(b);
    }
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_midi_out_obj, 1, 1, tulip_midi_out);


// Send a message on the "local bus", as if it was received from physical midi in
STATIC mp_obj_t tulip_midi_local(size_t n_args, const mp_obj_t *args) {
    if(mp_obj_get_type(args[0]) == &mp_type_bytes) {
        mp_buffer_info_t bufinfo;
        mp_get_buffer(args[0], &bufinfo, MP_BUFFER_READ);
        midi_local((uint8_t*)bufinfo.buf, bufinfo.len);
    } else {
        mp_obj_t *items;
        size_t len;
        mp_obj_get_array(args[0], &len, &items);
        uint8_t *b = malloc_caps(len, MALLOC_CAP_INTERNAL);
        for(uint16_t i=0;i<(uint16_t)len;i++) {
            b[i] = mp_obj_get_int(items[i]);
        }
        midi_local(b, len);
        free_caps(b);
    }
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_midi_local_obj, 1, 1, tulip_midi_local);


#ifndef __EMSCRIPTEN__
STATIC mp_obj_t tulip_amy_send(size_t n_args, const mp_obj_t *args) {
    amy_add_message((char*)mp_obj_str_get_str(args[0]));
    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_amy_send_obj, 1, 1, tulip_amy_send);

STATIC mp_obj_t tulip_amy_send_sysex(size_t n_args, const mp_obj_t *args) {
#if SYSEX_COPY_SLOTS > 0
    // Read from the next slot in the sysex ring buffer. parse_sysex() writes
    // to sequential slots so that a fast-arriving next sysex doesn't overwrite
    // an unprocessed message (which happens when loop() is CPU-heavy and the
    // mp_sched callback is delayed).
    char *slot = sysex_message_copies[sysex_copy_read_idx];
    sysex_copy_read_idx = (sysex_copy_read_idx + 1) % SYSEX_COPY_SLOTS;
#else
    // No sysex copy ring on this platform: amy (parse_sysex) gates the ring to
    // TULIP/AMYBOARD and dispatches sysex synchronously otherwise, so this
    // scheduled callback is never armed here. Guard avoids a `% 0` (desktop build).
    char *slot = NULL;
#endif
    if (slot) {
        // Use _from_sysex variant so that during a file transfer,
        // this data is routed to parse_transfer_message. Internal
        // amy.send() calls (from sketch loop) use amy_add_message
        // directly and bypass the transfer routing.
        amy_add_message_from_sysex(slot);
    }
    // ACK the message AFTER processing. The sender (web) waits for this
    // ACK before sending the next message, ensuring only one message is
    // in flight at a time and the ring buffer can't overflow.
    {
        extern void midi_out(uint8_t *bytes, uint16_t len);
        uint8_t ack[] = { 0xF0, 0x00, 0x03, 0x45, 'A', 'K', 0xF7 };
        midi_out(ack, sizeof(ack));
    }
    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_amy_send_sysex_obj, 0, 1, tulip_amy_send_sysex);

STATIC mp_obj_t tulip_pcm_load_file(size_t n_args, const mp_obj_t *args) {
    int result = pcm_load_file();
    return mp_obj_new_int(result);
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_pcm_load_file_obj, 0, 1, tulip_pcm_load_file);
#endif

#ifdef TULIP_USER_C_DSP
#include "user_c_dsp.h"

// install_c_process(name, src): compile a C effect —
// void process(int *buf, int frames, int chans) — AMY S8.23 samples
// (1.0 == 1<<23; helpers cos_lut/fxmul/to_int16/from_int16 are available) —
// and install it under name. src may be a full program or just the function
// body (the wrapper and helper prototypes are added for you).
STATIC mp_obj_t tulip_install_c_process(mp_obj_t name_obj, mp_obj_t src_obj) {
    char err[512];
    int slot = user_c_dsp_install(mp_obj_str_get_str(name_obj), mp_obj_str_get_str(src_obj), USER_C_DSP_KIND_EFFECT, err, sizeof(err));
    if (slot < 0) mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("install_c_process: %s"), err);
    return mp_obj_new_int(slot);
}
MP_DEFINE_CONST_FUN_OBJ_2(tulip_install_c_process_obj, tulip_install_c_process);

// install_c_osc(name, src): compile a C oscillator —
// void render(int *buf, int frames, int osc, int phase_inc_q16, int amp)
// — S8.23 samples, amp in S8.23, phase_inc_q16 = per-sample step with
// 65536 == one cycle. Install under name; src may be a full program or body.
STATIC mp_obj_t tulip_install_c_osc(mp_obj_t name_obj, mp_obj_t src_obj) {
    char err[512];
    int slot = user_c_dsp_install(mp_obj_str_get_str(name_obj), mp_obj_str_get_str(src_obj), USER_C_DSP_KIND_OSC, err, sizeof(err));
    if (slot < 0) mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("install_c_osc: %s"), err);
    return mp_obj_new_int(slot);
}
MP_DEFINE_CONST_FUN_OBJ_2(tulip_install_c_osc_obj, tulip_install_c_osc);

// c_osc(name, osc, on=True): replace AMY osc number osc's waveform with the
// named user oscillator (or restore it with on=False).
STATIC mp_obj_t tulip_c_osc(size_t n_args, const mp_obj_t *args) {
    int on = (n_args > 2) ? mp_obj_is_true(args[2]) : 1;
    int r = user_c_dsp_bind_osc(mp_obj_str_get_str(args[0]), mp_obj_get_int(args[1]), on);
    if (r == -1) mp_raise_ValueError(MP_ERROR_TEXT("no such c_osc"));
    if (r == -2) mp_raise_ValueError(MP_ERROR_TEXT("bad osc number"));
    if (r == -3) mp_raise_ValueError(MP_ERROR_TEXT("not an osc (installed with install_c_process?)"));
    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_c_osc_obj, 2, 3, tulip_c_osc);

// c_process(name, on, bus=0): enable/disable a named process on a bus.
STATIC mp_obj_t tulip_c_process(size_t n_args, const mp_obj_t *args) {
    int bus = (n_args > 2) ? mp_obj_get_int(args[2]) : 0;
    int r = user_c_dsp_set(mp_obj_str_get_str(args[0]), bus, mp_obj_is_true(args[1]));
    if (r == -1) mp_raise_ValueError(MP_ERROR_TEXT("no such c_process"));
    if (r == -2) mp_raise_ValueError(MP_ERROR_TEXT("bad bus"));
    if (r == -3) mp_raise_ValueError(MP_ERROR_TEXT("not an effect (installed with install_c_osc?)"));
    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_c_process_obj, 2, 3, tulip_c_process);

// c_process_calls(name): blocks processed since install (is my effect running?)
STATIC mp_obj_t tulip_c_process_calls(mp_obj_t name_obj) {
    int64_t calls = user_c_dsp_calls(mp_obj_str_get_str(name_obj));
    if (calls < 0) mp_raise_ValueError(MP_ERROR_TEXT("no such c_process"));
    return mp_obj_new_int_from_ll(calls);
}
MP_DEFINE_CONST_FUN_OBJ_1(tulip_c_process_calls_obj, tulip_c_process_calls);

STATIC mp_obj_t tulip_uninstall_c_process(mp_obj_t name_obj) {
    if (user_c_dsp_uninstall(mp_obj_str_get_str(name_obj)) < 0)
        mp_raise_ValueError(MP_ERROR_TEXT("no such c_process"));
    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_1(tulip_uninstall_c_process_obj, tulip_uninstall_c_process);
#endif  // TULIP_USER_C_DSP



/*

#if !defined(AMYBOARD) && !defined(__EMSCRIPTEN__)
extern char * alles_local_ip;
STATIC mp_obj_t tulip_multicast_start(size_t n_args, const mp_obj_t *args) {
    const char * local_ip = mp_obj_str_get_str(args[0]);
    if(strlen(local_ip)>2) {
        strcpy(alles_local_ip, local_ip);
    }
    alles_init_multicast();
    return mp_const_none;

}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_multicast_start_obj, 1, 1, tulip_multicast_start);

extern uint8_t alive;
extern int16_t client_id;
extern int32_t clocks[255];
extern int32_t ping_times[255];

STATIC mp_obj_t tulip_alles_map(size_t n_args, const mp_obj_t *args) {
    mp_obj_t list = mp_obj_new_list(0, NULL);
    for(uint8_t i=0;i<255;i++) {
        mp_obj_t tuple[3];
        if(clocks[i]>0) {
            tuple[0] = mp_obj_new_int(i);
            tuple[1] = mp_obj_new_int(clocks[i]);
            tuple[2] = mp_obj_new_int(ping_times[i]);
            mp_obj_list_append(list, mp_obj_new_tuple(3, tuple));
        }
    }
    // TODO - sort this so that client 0 is the earliest, etc. Maybe do the sort in python 
    return list;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_alles_map_obj, 0, 0, tulip_alles_map);


#endif

#ifndef AMYBOARD_WEB
extern uint8_t ipv4_quartet;
STATIC mp_obj_t tulip_set_quartet(size_t n_args, const mp_obj_t *args) {
    ipv4_quartet = mp_obj_get_int(args[0]);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_set_quartet_obj, 1, 1, tulip_set_quartet);
#endif
*/
extern float compute_cpu_usage(uint8_t debug);
STATIC mp_obj_t tulip_cpu(size_t n_args, const mp_obj_t *args) {
    // for now just printf to uart
    float idle;
    if(n_args > 0) {
        idle = compute_cpu_usage(1);
    } else {
        idle = compute_cpu_usage(0);
    }
    return mp_obj_new_float_from_f(idle);
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_cpu_obj, 0, 1, tulip_cpu);

#ifndef ESP_PLATFORM
#ifndef __linux__
#ifndef __EMSCRIPTEN__
extern char* get_tulip_home_path();
STATIC mp_obj_t tulip_app_path(size_t n_args, const mp_obj_t *args) {
    char * path = get_tulip_home_path();
    return mp_obj_new_str(path, strlen(path));
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_app_path_obj, 0, 0, tulip_app_path);
#endif
#endif
#endif





STATIC mp_obj_t tulip_build_strings(size_t n_args, const mp_obj_t *args) {
    mp_obj_t tuple[3];
    tuple[0] = mp_obj_new_str(MICROPY_GIT_TAG, strlen(MICROPY_GIT_TAG));
    tuple[1] = mp_obj_new_str(MICROPY_GIT_HASH, strlen(MICROPY_GIT_HASH));
    tuple[2] = mp_obj_new_str(MICROPY_BUILD_DATE, strlen(MICROPY_BUILD_DATE));
    return mp_obj_new_tuple(3, tuple);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_build_strings_obj, 0,0, tulip_build_strings);


#if defined(AMYBOARD)
extern float cv_local_value[2];
extern uint8_t cv_local_override[2];
extern float cv_input_hook(uint16_t channel);
#endif

#if defined(AMYBOARD_WEB)
float cv_local_value[2] = {0, 0};
uint8_t cv_local_override[2] = {0, 0};
float cv_input_hook(uint16_t channel) {
    return cv_local_value[channel];
}
#endif

#if defined(AMYBOARD) || defined(AMYBOARD_WEB)
STATIC mp_obj_t tulip_cv_local(size_t n_args, const mp_obj_t *args) {
    uint8_t channel = mp_obj_get_int(args[0]);
    if(n_args>1) {
        cv_local_override[channel] = 1;
        cv_local_value[channel] = mp_obj_get_float(args[1]);
    } else {
        cv_local_override[channel] = 0;
    }
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_cv_local_obj, 1, 2, tulip_cv_local);

STATIC mp_obj_t tulip_cv_in(size_t n_args, const mp_obj_t *args) {
    uint8_t channel = (n_args > 0) ? mp_obj_get_int(args[0]) : 0;
    return mp_obj_new_float(cv_input_hook(channel));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_cv_in_obj, 0, 1, tulip_cv_in);
#endif


#ifdef AMYBOARD_WEB

uint32_t expand_4bit_oled(uint8_t fourbit) {
    if(fourbit==1)  return 0xff111111;
    if(fourbit==2)  return 0xff222222;
    if(fourbit==3)  return 0xff333333;
    if(fourbit==4)  return 0xff444444;
    if(fourbit==5)  return 0xff555555;
    if(fourbit==6)  return 0xff666666;
    if(fourbit==7)  return 0xff777777;
    if(fourbit==8)  return 0xff888888;
    if(fourbit==9)  return 0xff999999;
    if(fourbit==10) return 0xffAAAAAA;
    if(fourbit==11) return 0xffBBBBBB;
    if(fourbit==12) return 0xffCCCCCC;
    if(fourbit==13) return 0xffDDDDDD;
    if(fourbit==14) return 0xffEEEEEE;
    if(fourbit==15) return 0xffFFFFFF;
    return 0xff000000;
}

// Update the web framebuffer if there is one
STATIC mp_obj_t tulip_framebuf_web_update(size_t n_args, const mp_obj_t *args) {
    mp_buffer_info_t bufinfo;
    mp_get_buffer(args[0], &bufinfo, MP_BUFFER_READ);
    uint8_t * p = (uint8_t*)bufinfo.buf;
    uint32_t canvas_pixels[256*256];
    uint16_t i = 0;
    for(uint16_t y=0;y<256;y++) {
        for(uint16_t x=0;x<64;x++) {
            uint8_t two_pixels = p[(y/2)*64 + x];
            uint32_t px0 = expand_4bit_oled((two_pixels >> 4) & 0x000F);
            uint32_t px1 = expand_4bit_oled(two_pixels & 0x000F);
            canvas_pixels[i++] = px0;
            canvas_pixels[i++] = px0;
            canvas_pixels[i++] = px1;
            canvas_pixels[i++] = px1;
        }
    }
    EM_ASM_({
      let canvas = document.getElementById("canvas");
      if (!canvas) return;
      let context = canvas.getContext('2d');
      let imageData = context.createImageData($1, $2);
      // .slice() to copy from SharedArrayBuffer into a regular ArrayBuffer
      let src = Module.HEAPU8.slice($0, $0 + $1 * $2 * 4);
      imageData.data.set(src);
      context.putImageData(imageData, 0, 0);
    }, canvas_pixels, 256, 256);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_framebuf_web_update_obj, 1, 1, tulip_framebuf_web_update);

#endif

// Just AMYBOARD c code
#ifdef AMYBOARD

extern void run_amy(uint8_t);

STATIC mp_obj_t tulip_amyboard_start(size_t n_args, const mp_obj_t *args) {
    uint8_t midi_out_pin = mp_obj_get_int(args[0]);
    run_amy(midi_out_pin);
    #ifdef AMYBOARD_USB_HOST
    // AMY is up; let the USB MIDI host task (usb_host.c) feed it MIDI.
    extern uint8_t tulip_ready;
    tulip_ready = 1;
    #endif
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_amyboard_start_obj, 1, 1, tulip_amyboard_start);

#if defined(AMYBOARD)
// Switch the MIDI OUT TRS standard live (Type A = pin 14, Type B = pin 15). See
// amyboard.set_midi_type() — AMY keeps running; only the UART TX line moves.
extern void amyboard_set_midi_out(uint8_t);
STATIC mp_obj_t tulip_amyboard_set_midi_out(mp_obj_t pin_obj) {
    amyboard_set_midi_out((uint8_t)mp_obj_get_int(pin_obj));
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(tulip_amyboard_set_midi_out_obj, tulip_amyboard_set_midi_out);
#endif


STATIC mp_obj_t tulip_bootloader_mode(void) {
#if defined(AMYBOARD) && defined(ESP_PLATFORM)
    extern uint32_t amyboard_bootloader_flag;
    #define AMYBOARD_BOOTLOADER_MAGIC 0xABCD0001
    if (amyboard_bootloader_flag == AMYBOARD_BOOTLOADER_MAGIC) {
        amyboard_bootloader_flag = 0;  // clear for next boot
        return mp_const_true;
    }
#endif
    return mp_const_false;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(tulip_bootloader_mode_obj, tulip_bootloader_mode);

STATIC mp_obj_t tulip_amyboard_send(size_t n_args, const mp_obj_t *args) {
    amy_add_message((char*)mp_obj_str_get_str(args[0]));
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_amyboard_send_obj, 1, 1, tulip_amyboard_send);

#ifdef ESP_PLATFORM
// Background I2C write queue (amyboard_support.c): the OLED drivers enqueue
// their transactions here so display refreshes don't block Python while the
// bytes clock out at 400kHz.
extern uint8_t amyboard_i2c_bg_write(uint8_t addr, const uint8_t *buf, uint32_t len);
extern uint32_t amyboard_i2c_bg_pending(void);
extern uint32_t amyboard_i2c_bg_errors(void);

STATIC mp_obj_t tulip_i2c_bg_write(mp_obj_t addr_obj, mp_obj_t buf_obj) {
    mp_buffer_info_t bufinfo;
    mp_get_buffer_raise(buf_obj, &bufinfo, MP_BUFFER_READ);
    amyboard_i2c_bg_write((uint8_t)mp_obj_get_int(addr_obj), (const uint8_t *)bufinfo.buf, (uint32_t)bufinfo.len);
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(tulip_i2c_bg_write_obj, tulip_i2c_bg_write);

STATIC mp_obj_t tulip_i2c_bg_pending(void) {
    return mp_obj_new_int(amyboard_i2c_bg_pending());
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(tulip_i2c_bg_pending_obj, tulip_i2c_bg_pending);

STATIC mp_obj_t tulip_i2c_bg_errors(void) {
    return mp_obj_new_int(amyboard_i2c_bg_errors());
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(tulip_i2c_bg_errors_obj, tulip_i2c_bg_errors);
#endif // ESP_PLATFORM




#else

#ifndef AMYBOARD_WEB

/// Tulip-with-screen stuff only below
extern void unix_display_set_clock(uint8_t);
extern void display_start();
extern void display_stop();
extern void save_tfb();
extern void restore_tfb();
extern uint8_t tfb_active;
extern uint8_t tfb_font;

STATIC mp_obj_t tulip_display_clock(size_t n_args, const mp_obj_t *args) {
    if(n_args==1) {
        uint16_t mhz = mp_obj_get_int(args[0]);
        display_set_clock(mhz);
        return mp_const_none;
    }
    return mp_obj_new_int(PIXEL_CLOCK_MHZ);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_display_clock_obj, 0, 1, tulip_display_clock);

extern void esp32s3_display_restart();
STATIC mp_obj_t tulip_display_restart(size_t n_args, const mp_obj_t *args) {
    #ifdef ESP_PLATFORM
    esp32s3_display_restart();
    #endif
    //display_set_clock(PIXEL_CLOCK_MHZ);
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_display_restart_obj, 0, 0, tulip_display_restart);

STATIC mp_obj_t tulip_display_stop(size_t n_args, const mp_obj_t *args) {
    display_stop();
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_display_stop_obj, 0, 0, tulip_display_stop);


STATIC mp_obj_t tulip_display_start(size_t n_args, const mp_obj_t *args) {
    display_start();
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_display_start_obj, 0, 0, tulip_display_start);


STATIC mp_obj_t tulip_tfb_stop(size_t n_args, const mp_obj_t *args) {
    tfb_active = 0;
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_tfb_stop_obj, 0, 0, tulip_tfb_stop);


STATIC mp_obj_t tulip_tfb_start(size_t n_args, const mp_obj_t *args) {
    tfb_active = 1;
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_tfb_start_obj, 0, 0, tulip_tfb_start);


STATIC mp_obj_t tulip_gpu_log(size_t n_args, const mp_obj_t *args) {
    gpu_log = 1;
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_gpu_log_obj, 0, 0, tulip_gpu_log);



STATIC mp_obj_t tulip_tfb_save(size_t n_args, const mp_obj_t *args) {
    save_tfb();
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_tfb_save_obj, 0, 0, tulip_tfb_save);

STATIC mp_obj_t tulip_tfb_restore(size_t n_args, const mp_obj_t *args) {
    restore_tfb();
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_tfb_restore_obj, 0, 0, tulip_tfb_restore);


STATIC mp_obj_t tulip_tfb_update(size_t n_args, const mp_obj_t *args) {
    display_tfb_update(-1); 
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_tfb_update_obj, 0, 0, tulip_tfb_update);

// tulip.tfb_font() -> current font number
// tulip.tfb_font(x) -> set font number (0=8x12, 1=portfolio, 2=12x16)
STATIC mp_obj_t tulip_tfb_font(size_t n_args, const mp_obj_t *args) {
    if(n_args == 0) {
        return mp_obj_new_int(tfb_font);
    }
    int font_no = mp_obj_get_int(args[0]);
    if(font_no < TFB_FONT_8X12 || font_no > TFB_FONT_12X16) {
        mp_raise_ValueError(MP_ERROR_TEXT("tfb_font must be 0, 1, or 2"));
    }
    tfb_font = (uint8_t)font_no;
    uint8_t visible_cols = display_tfb_visible_cols();
    uint8_t visible_rows = display_tfb_visible_rows();
    if(visible_cols == 0) visible_cols = 1;
    if(visible_rows == 0) visible_rows = 1;
    if(tfb_x_col >= visible_cols) tfb_x_col = visible_cols - 1;
    if(tfb_y_row >= visible_rows) tfb_y_row = visible_rows - 1;
    display_tfb_update(-1);
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_tfb_font_obj, 0, 1, tulip_tfb_font);

// fps = tulip.fps()
STATIC mp_obj_t tulip_fps(size_t n_args, const mp_obj_t *args) {
    return mp_obj_new_float_from_f(reported_fps);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_fps_obj, 0, 0, tulip_fps);

// usage = tulip.gpu()
STATIC mp_obj_t tulip_gpu(size_t n_args, const mp_obj_t *args) {
    return mp_obj_new_float_from_f(reported_gpu_usage);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_gpu_obj, 0, 0, tulip_gpu);


//tulip.bg_swap()
STATIC mp_obj_t tulip_bg_swap(size_t n_args, const mp_obj_t *args) {
    display_swap();
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_swap_obj, 0, 0, tulip_bg_swap);

// tulip.bg_pixel(x,y, pal_idx)
// (r,g,b) = tulip.bg_pixel(x,y)
STATIC mp_obj_t tulip_bg_pixel(size_t n_args, const mp_obj_t *args) {
    uint16_t x = mp_obj_get_int(args[0]);
    uint16_t y = mp_obj_get_int(args[1]);
    if(n_args == 3) { // set
        // Set the pixel
        uint8_t pal_idx = mp_obj_get_int(args[2]);
        display_set_bg_pixel_pal(x,y,pal_idx);
        return mp_const_none; 
    } else { // get the pixel
        return mp_obj_new_int( display_get_bg_pixel_pal(x,y)); 
    }
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_pixel_obj, 2, 3, tulip_bg_pixel);



// This version of bg_clear is 2.5x as fast as the old one, as it's just copying within SPIRAM.
// tulip.bg_clear(pal_idx)
// tulip.bg_clear() # uses default
STATIC mp_obj_t tulip_bg_clear(size_t n_args, const mp_obj_t *args) {
    uint8_t pal_idx = bg_pal_color;
    if(n_args == 1) {
        pal_idx = mp_obj_get_int(args[0]);
    }
    // Set a single pixel
    display_set_bg_pixel_pal(0,0,pal_idx);
    // Copy that pixel
    for (uint16_t j = 0; j < V_RES+OFFSCREEN_Y_PX; j++) {
        for (uint16_t i = 0; i < H_RES+OFFSCREEN_X_PX; i++) {
            (bg)[(((j*(H_RES+OFFSCREEN_X_PX) + i)*BYTES_PER_PIXEL) + 0)] = (bg)[0];
        }
    }    
    return mp_const_none; 
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_clear_obj, 0, 1, tulip_bg_clear);


// tulip.bg_bitmap(x, y, w, h, bitmap)  --> sets or gets bitmap to fb ram
STATIC mp_obj_t tulip_bg_bitmap(size_t n_args, const mp_obj_t *args) {
    uint16_t x = mp_obj_get_int(args[0]);
    uint16_t y = mp_obj_get_int(args[1]);
    uint16_t w = mp_obj_get_int(args[2]);
    uint16_t h = mp_obj_get_int(args[3]);
    if(n_args == 5) {
        // Set the rect with bitmap pixels
        mp_buffer_info_t bufinfo;
        if (mp_obj_get_type(args[4]) == &mp_type_bytes) {
            mp_get_buffer(args[4], &bufinfo, MP_BUFFER_READ);
            display_set_bg_bitmap_raw(x, y, w, h, (uint8_t*)bufinfo.buf);
        }
        return mp_const_none; 
    } else {
        // return a bitmap
        uint8_t bitmap[w*h*BYTES_PER_PIXEL];  
        display_get_bg_bitmap_raw(x,y,w,h, bitmap);
        return mp_obj_new_bytes(bitmap, w*h*BYTES_PER_PIXEL);
    }
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_bitmap_obj, 4, 5, tulip_bg_bitmap);


// tulip.bg_blit(x, y, w, h, x1, y1)  --> copies bitmap ram
STATIC mp_obj_t tulip_bg_blit(size_t n_args, const mp_obj_t *args) {
    uint16_t x = mp_obj_get_int(args[0]);
    uint16_t y = mp_obj_get_int(args[1]);
    uint16_t w = mp_obj_get_int(args[2]);
    uint16_t h = mp_obj_get_int(args[3]);
    uint16_t x1 = mp_obj_get_int(args[4]);
    uint16_t y1 = mp_obj_get_int(args[5]);
    if(n_args > 6) {
        display_bg_bitmap_blit_alpha(x,y,w,h,x1,y1);
    } else {
        display_bg_bitmap_blit(x,y,w,h,x1,y1);
    }
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_blit_obj, 6, 7, tulip_bg_blit);



// tulip.bg_png(bytes, x,y)
// tulip.bg_png(filename, x,y)
STATIC mp_obj_t tulip_bg_png(size_t n_args, const mp_obj_t *args) {
    unsigned error;
    unsigned char* image;
    unsigned width, height;
    uint16_t x = mp_obj_get_int(args[1]);
    uint16_t y = mp_obj_get_int(args[2]);

    mp_buffer_info_t bufinfo;
    uint8_t file = 0;
    if (mp_obj_get_type(args[0]) == &mp_type_bytes) {
        mp_get_buffer(args[0], &bufinfo, MP_BUFFER_READ);
    } else {
        uint32_t fs = file_size(mp_obj_str_get_str(args[0]));
        bufinfo.buf = malloc_caps(fs, MALLOC_CAP_SPIRAM);
        bufinfo.len = fs;
        read_file(mp_obj_str_get_str(args[0]), (uint8_t *)bufinfo.buf, -1, 1);
        file = 1;
    }
    error = lodepng_decode_memory(&image, &width, &height, (uint8_t*)bufinfo.buf, bufinfo.len, LCT_RGBA, 8);
    if(error) printf("error %u: %s\n", error, lodepng_error_text(error));
    display_set_bg_bitmap_rgba(x,y,width,height,image);
    free_caps(image);
    if(file) {
        free_caps(bufinfo.buf);
    }
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_png_obj, 3, 3, tulip_bg_png);

//tulip.bg_scroll(line, x_offset, y_offset, x_speed, y_speed)
//tulip.bg_scroll() # resets
STATIC mp_obj_t tulip_bg_scroll(size_t n_args, const mp_obj_t *args) {
    if(n_args<5) {
        // Reset
        for(uint16_t line_no=0;line_no<V_RES;line_no++) {
            x_offsets[line_no] = 0;
            y_offsets[line_no] = line_no;
            x_speeds[line_no] = 0;
            y_speeds[line_no] = 0;
        }
    } else {
        uint16_t line_no = mp_obj_get_int(args[0]);
        uint16_t x_offset = mp_obj_get_int(args[1]);
        uint16_t y_offset = mp_obj_get_int(args[2]);
        int16_t x_speed = mp_obj_get_int(args[3]);
        int16_t y_speed = mp_obj_get_int(args[4]);
        x_offsets[line_no] = x_offset;
        y_offsets[line_no] = y_offset;
        x_speeds[line_no] = x_speed;
        y_speeds[line_no] = y_speed;
    }
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_scroll_obj, 0, 5, tulip_bg_scroll);

STATIC mp_obj_t tulip_bg_scroll_x_speed(size_t n_args, const mp_obj_t *args) {
    uint16_t line_no = mp_obj_get_int(args[0]);
    int16_t x_speed = mp_obj_get_int(args[1]);
    x_speeds[line_no] = x_speed;
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_scroll_x_speed_obj, 2, 2, tulip_bg_scroll_x_speed);


STATIC mp_obj_t tulip_bg_scroll_y_speed(size_t n_args, const mp_obj_t *args) {
    uint16_t line_no = mp_obj_get_int(args[0]);
    int16_t y_speed = mp_obj_get_int(args[1]);
    y_speeds[line_no] = y_speed;
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_scroll_y_speed_obj, 2, 2, tulip_bg_scroll_y_speed);


STATIC mp_obj_t tulip_bg_scroll_x_offset(size_t n_args, const mp_obj_t *args) {
    uint16_t line_no = mp_obj_get_int(args[0]);
    int16_t x_offset = mp_obj_get_int(args[1]);
    x_offsets[line_no] = x_offset;
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_scroll_x_offset_obj, 2, 2, tulip_bg_scroll_x_offset);


STATIC mp_obj_t tulip_bg_scroll_y_offset(size_t n_args, const mp_obj_t *args) {
    uint16_t line_no = mp_obj_get_int(args[0]);
    int16_t y_offset = mp_obj_get_int(args[1]);
    y_offsets[line_no] = y_offset;
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_scroll_y_offset_obj, 2, 2, tulip_bg_scroll_y_offset);



// tulip.tfb_str(x,y, str, [format], [fg_color], [bg_color])
// (str, format, fg, bg) = tulip.tfb_str(x,y)
STATIC mp_obj_t tulip_tfb_str(size_t n_args, const mp_obj_t *args) {
    uint16_t x = mp_obj_get_int(args[0]);
    uint16_t y = mp_obj_get_int(args[1]);
    uint8_t set = 0;
    if(n_args > 2) set = 1;
    if(set) {
        const char * str = mp_obj_str_get_str(args[2]);
        if(x>0) {
            // Clear the front so the redraw works
            for(uint16_t i=0;i<x;i++) {
                if(TFB[y*TFB_COLS+i]==0) TFB[y*TFB_COLS+i] = 32;
            }
        }
        for(uint16_t i=0;i<strlen(str);i++) {
            TFB[y*TFB_COLS+x+i] = str[i];
        }
        if(n_args > 3) {
            if(mp_obj_get_int(args[3])>=0) {
                for(uint16_t i=0;i<strlen(str);i++) {
                    TFBf[y*TFB_COLS+x+i] = mp_obj_get_int(args[3]);
                }
            }
        }
        if(n_args > 4 ) {
            if(mp_obj_get_int(args[4])>=0) {
                for(uint16_t i=0;i<strlen(str);i++) {
                    TFBfg[y*TFB_COLS+x+i] = mp_obj_get_int(args[4]);
                }
            }
        }
        if(n_args > 5 ) {
            if(mp_obj_get_int(args[5])>=0) {
                for(uint16_t i=0;i<strlen(str);i++) {
                    TFBbg[y*TFB_COLS+x+i] = mp_obj_get_int(args[5]);
                }
            }
        }
        display_tfb_update(y);
        return mp_const_none; 
    } else {
        mp_obj_t tuple[5];
        tuple[0] = mp_obj_new_str((const char*)(TFB + (y*TFB_COLS+x)), 1);
        tuple[1] = mp_obj_new_int(TFBf[y*TFB_COLS+x]);
        tuple[2] = mp_obj_new_int(TFBfg[y*TFB_COLS+x]);
        tuple[3] = mp_obj_new_int(TFBbg[y*TFB_COLS+x]);
        tuple[4] = mp_obj_new_int(TFB[y*TFB_COLS+x]);
        return mp_obj_new_tuple(5,tuple);
    }
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_tfb_str_obj, 2, 6, tulip_tfb_str);





STATIC mp_obj_t tulip_screen_size(size_t n_args, const mp_obj_t *args) {
    mp_obj_t tuple[2];
    tuple[0] = mp_obj_new_int(H_RES);
    tuple[1] = mp_obj_new_int(V_RES);
    return mp_obj_new_tuple(2,tuple);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_screen_size_obj, 0, 0, tulip_screen_size);


mp_obj_t frame_callback = NULL; 
mp_obj_t frame_arg = NULL; 
mp_obj_t touch_callback = NULL; 
mp_obj_t keyboard_callback = NULL;
mp_obj_t ui_quit_callback = NULL;
mp_obj_t ui_switch_callback = NULL;


STATIC mp_obj_t mp_lv_task_handler(mp_obj_t arg)
{  
    lv_task_handler();
    //lv_timer_handler_brian();
    //if(lv_tick_counter++ % 100 == 0) {
    //    fprintf(stderr, "%d ticks, brian %d %2.4f bs/tick\n", lv_tick_counter, brian_counter, (float)(brian_counter)/(float)(lv_tick_counter));
   // }
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_lv_task_handler_obj, mp_lv_task_handler);


void mp_schedule_lv() {
    // schedule lvgl task
    mp_sched_schedule((mp_obj_t)&mp_lv_task_handler_obj, mp_const_none);
}

void tulip_frame_isr() {
    mp_schedule_lv();
    if(frame_callback != NULL) {
        // Schedule the python callback given to run asap
        //fprintf(stderr, "calling function %p with arg %p at frame %d\n", frame_callback, frame_arg, vsync_count);
        mp_sched_schedule(frame_callback, frame_arg);
#ifdef ESP_PLATFORM
        //mp_hal_wake_main_task_from_isr();
#endif
    }
}


void tulip_touch_isr(uint8_t up) {
    if(touch_callback != NULL) {
        mp_sched_schedule(touch_callback, mp_obj_new_int(up)); 
    }
}




// tulip.frame_callback(cb, arg)
// tulip.frame_callback() -- stops 
STATIC mp_obj_t tulip_frame_callback(size_t n_args, const mp_obj_t *args) {
    if(n_args == 0) {
        frame_callback = NULL;
    } else {
        frame_callback = args[0];
    }
    if(n_args > 1) {
        frame_arg = args[1];
    }
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_frame_callback_obj, 0, 2, tulip_frame_callback);



STATIC mp_obj_t tulip_touch_callback(size_t n_args, const mp_obj_t *args) {
    if(n_args == 0) {
        touch_callback = NULL;
    } else {
        touch_callback = args[0];
    }
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_touch_callback_obj, 0, 1, tulip_touch_callback);

STATIC mp_obj_t tulip_keyboard_callback(size_t n_args, const mp_obj_t *args) {
    if(n_args == 0) {
        keyboard_callback = NULL;
    } else {
        keyboard_callback = args[0];
    }
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_keyboard_callback_obj, 0, 1, tulip_keyboard_callback);



STATIC mp_obj_t tulip_ui_quit_callback(size_t n_args, const mp_obj_t *args) {
    if(n_args == 0) {
        ui_quit_callback = NULL;
    } else {
        ui_quit_callback = args[0];
    }
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_ui_quit_callback_obj, 0, 1, tulip_ui_quit_callback);

STATIC mp_obj_t tulip_ui_switch_callback(size_t n_args, const mp_obj_t *args) {
    if(n_args == 0) {
        ui_switch_callback = NULL;
    } else {
        ui_switch_callback = args[0];
    }
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_ui_switch_callback_obj, 0, 1, tulip_ui_switch_callback);




//(w,h,bytes) = sprite_png(pngdata, mem_pos) 
//(w,h,bytes) = sprite_png("filename.png", mem_pos)
STATIC mp_obj_t tulip_sprite_png(size_t n_args, const mp_obj_t *args) {
    unsigned error;
    unsigned char* image;
    unsigned width, height;
    uint16_t mem_pos = mp_obj_get_int(args[1]);
    mp_buffer_info_t bufinfo;
    uint8_t file = 0;
    if (mp_obj_get_type(args[0]) == &mp_type_bytes) {
        mp_get_buffer(args[0], &bufinfo, MP_BUFFER_READ);
    } else {
        uint32_t fs = file_size(mp_obj_str_get_str(args[0]));
        bufinfo.buf = malloc_caps(fs, MALLOC_CAP_SPIRAM);
        bufinfo.len = fs;
        read_file(mp_obj_str_get_str(args[0]), (uint8_t *)bufinfo.buf, -1, 1);
        file = 1;
    }
    error = lodepng_decode_memory(&image, &width, &height, (uint8_t*)bufinfo.buf, bufinfo.len, LCT_RGBA, 8);
    if(error) printf("error %u: %s\n", error, lodepng_error_text(error));
    display_load_sprite_rgba(mem_pos, width*height*BYTES_PER_PIXEL, image);
    free_caps(image);
    if(file) free_caps(bufinfo.buf);
    mp_obj_t tuple[3];
    tuple[0] = mp_obj_new_int(width);
    tuple[1] = mp_obj_new_int(height);
    tuple[2] = mp_obj_new_int(width*height*BYTES_PER_PIXEL);
    return mp_obj_new_tuple(3, tuple);
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_sprite_png_obj, 2, 2, tulip_sprite_png);


//bytes = sprite_bitmap(bitmap, mem_pos) 
//buffer_of_bytes = sprite_bitmap(mem_pos, length)
STATIC mp_obj_t tulip_sprite_bitmap(size_t n_args, const mp_obj_t *args) {
    if (mp_obj_get_type(args[0]) == &mp_type_bytes) {
        uint16_t mem_pos = mp_obj_get_int(args[1]);
        mp_buffer_info_t bufinfo;
        mp_get_buffer(args[0], &bufinfo, MP_BUFFER_READ);
        display_load_sprite_raw(mem_pos, bufinfo.len, bufinfo.buf);
        return mp_obj_new_int(bufinfo.len);
    } 
    uint16_t mem_pos = mp_obj_get_int(args[0]);
    uint16_t length = mp_obj_get_int(args[1]);
    return mp_obj_new_bytes(sprite_ram+mem_pos, length);
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_sprite_bitmap_obj, 2, 2, tulip_sprite_bitmap);

extern uint8_t spriteno_activated; // tells the drawing loop to look at sprites
//sprite_register(34, mem_pos, w,h, type) # 34 = sprite number, can be up to ...
STATIC mp_obj_t tulip_sprite_register(size_t n_args, const mp_obj_t *args) {
    uint16_t spriteno = mp_obj_get_int(args[0]);
    if(spriteno_activated < spriteno+1)
        spriteno_activated = spriteno+1;
    uint32_t mem_pos = mp_obj_get_int(args[1]);
    if(spriteno < SPRITES) {
        sprite_mem[spriteno] = mem_pos;
    }
    if(n_args > 2) {
        uint16_t width = mp_obj_get_int(args[2]);
        uint16_t height = mp_obj_get_int(args[3]);
        if(spriteno < SPRITES) {
            sprite_w_px[spriteno] = width;
            sprite_h_px[spriteno] = height;
        }
    }
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_sprite_register_obj, 2, 4, tulip_sprite_register);


//sprite_move(34, x,y)
STATIC mp_obj_t tulip_sprite_move(size_t n_args, const mp_obj_t *args) {
    uint16_t spriteno = mp_obj_get_int(args[0]);
    uint16_t x = mp_obj_get_int(args[1]);
    uint16_t y = mp_obj_get_int(args[2]);
    if(spriteno < SPRITES) {
        if(check_dim_xy(x,y)) {
            sprite_x_px[spriteno] = x;
            sprite_y_px[spriteno] = y;
        } else {
            //fprintf(stderr, "bad sprite xy %d %d\n", x,y);
        }
    } else {
        //fprintf(stderr, "move bad spriteno %d\n", spriteno);
    }
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_sprite_move_obj, 3, 3, tulip_sprite_move);

STATIC mp_obj_t tulip_sprite_on(size_t n_args, const mp_obj_t *args) {
    uint16_t spriteno = mp_obj_get_int(args[0]);
    if(spriteno < SPRITES) sprite_vis[spriteno] = SPRITE_IS_SPRITE;        
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_sprite_on_obj, 1, 1, tulip_sprite_on);


STATIC mp_obj_t tulip_sprite_off(size_t n_args, const mp_obj_t *args) {
    uint16_t spriteno = mp_obj_get_int(args[0]);
    if(spriteno < SPRITES) sprite_vis[spriteno] = 0;
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_sprite_off_obj, 1, 1, tulip_sprite_off);


STATIC mp_obj_t tulip_sprite_clear(size_t n_args, const mp_obj_t *args) {
    display_reset_sprites();
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_sprite_clear_obj, 0, 0, tulip_sprite_clear);


STATIC mp_obj_t tulip_collisions(size_t n_args, const mp_obj_t *args) {
    mp_obj_t list = mp_obj_new_list(0, NULL);
    // iterate through all fields
    for(uint8_t a=0;a<32;a++) {
        for(uint8_t b=a+1;b<32;b++) {
            if(collide_mask_get(a,b)) {
                mp_obj_t tuple[2];
                tuple[0] = mp_obj_new_int(a);
                tuple[1] = mp_obj_new_int(b);
                mp_obj_list_append(list, mp_obj_new_tuple(2, tuple));
            }
        }
    }
    // clear collision
    // TODO -- divine 62 a better way 
    for(uint8_t i=0;i<62;i++) collision_bitfield[i] = 0;
    return list;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_collisions_obj, 0, 0, tulip_collisions);



extern void editor_start(const char * filename);
extern void editor_activate();
extern void editor_key(int c); 
extern void editor_deinit();


STATIC mp_obj_t tulip_run_editor(size_t n_args, const mp_obj_t *args) {
    if(n_args) {
        editor_start(mp_obj_str_get_str(args[0]));
    } else {
        editor_start(NULL);
    }
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_run_editor_obj, 0, 1, tulip_run_editor);


STATIC mp_obj_t tulip_key_editor(size_t n_args, const mp_obj_t *args) {
    editor_key(mp_obj_get_int(args[0]));
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_key_editor_obj, 1, 1, tulip_key_editor);



STATIC mp_obj_t tulip_deinit_editor(size_t n_args, const mp_obj_t *args) {
    editor_deinit();
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_deinit_editor_obj, 0, 0, tulip_deinit_editor);


STATIC mp_obj_t tulip_activate_editor(size_t n_args, const mp_obj_t *args) {
    editor_activate();
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_activate_editor_obj, 0, 1, tulip_activate_editor);


extern void unix_display_timings(uint16_t, uint16_t, uint16_t, uint16_t);
STATIC mp_obj_t tulip_gpu_reset(size_t n_args, const mp_obj_t *args) {
    display_reset_bg();
    display_reset_sprites();
    display_reset_tfb();
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_gpu_reset_obj, 0, 0, tulip_gpu_reset);



STATIC mp_obj_t tulip_int_screenshot(size_t n_args, const mp_obj_t *args) {
    char fn[50];
    strcpy(fn, mp_obj_str_get_str(args[0]));
    if(n_args>1) {
        int16_t x = mp_obj_get_int(args[1]);
        int16_t y = mp_obj_get_int(args[2]);
        int16_t w = mp_obj_get_int(args[3]);
        int16_t h = mp_obj_get_int(args[4]);
        display_screenshot(fn, x,y,w,h);
    } else {
        display_screenshot(fn, -1, -1, -1, -1);
    }
    return mp_const_none;

}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_int_screenshot_obj, 1, 5, tulip_int_screenshot);




STATIC mp_obj_t tulip_brightness(size_t n_args, const mp_obj_t *args) {
    if(n_args > 0) {
        display_brightness(mp_obj_get_int(args[0]));
        return mp_const_none;
    } else {
        return mp_obj_new_int(brightness);
    }

}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_brightness_obj, 0, 1, tulip_brightness);


extern const uint16_t rgb332_rgb565_i[256];

STATIC mp_obj_t tulip_rgb332_565(size_t n_args, const mp_obj_t *args) {
    return mp_obj_new_int(rgb332_rgb565_i[mp_obj_get_int(args[0])]);
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_rgb332_565_obj, 1, 1, tulip_rgb332_565);



extern uint8_t last_scan[8];
STATIC mp_obj_t tulip_keys(size_t n_args, const mp_obj_t *args) {
    mp_obj_t tuple[7];
    tuple[0] = mp_obj_new_int(last_scan[0]);
    for(uint8_t i=0;i<6;i++) tuple[i+1] = mp_obj_new_int(last_scan[i+2]);
    return mp_obj_new_tuple(7, tuple);

}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_keys_obj, 0, 0, tulip_keys);

extern int16_t last_touch_x[3];
extern int16_t last_touch_y[3];
STATIC mp_obj_t tulip_touch(size_t n_args, const mp_obj_t *args) {
    mp_obj_t tuple[6];
    for(uint8_t i=0;i<3;i++) {
        tuple[i*2] = mp_obj_new_int(last_touch_x[i]);
        tuple[i*2+1] = mp_obj_new_int(last_touch_y[i]);
    }
    return mp_obj_new_tuple(6, tuple);

}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_touch_obj, 0, 0, tulip_touch);

#ifdef TULIP_DIY
#include "ft5x06_touchscreen.h"
#elif defined MAKERFABS
#include "gt911_touchscreen.h"
#endif

#ifdef ESP_PLATFORM
extern int16_t touch_x_delta;
extern int16_t touch_y_delta;
extern float touch_y_scale;
#else
int16_t touch_x_delta = 0;
int16_t touch_y_delta = 0;
float touch_y_scale = 1.0;
#endif

STATIC mp_obj_t tulip_touch_delta(size_t n_args, const mp_obj_t *args) {
    if(n_args > 0) {
        touch_x_delta = mp_obj_get_int(args[0]);
        touch_y_delta = mp_obj_get_int(args[1]);
        // Allow people to still set x,y delta without scale
        if(n_args > 2) touch_y_scale = mp_obj_get_float(args[2]);
    } else {
        mp_obj_t tuple[3];
        tuple[0] = mp_obj_new_int(touch_x_delta);
        tuple[1] = mp_obj_new_int(touch_y_delta);
        tuple[2] = mp_obj_new_float(touch_y_scale);
        return mp_obj_new_tuple(3, tuple);
    }
    return mp_const_none;

}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_touch_delta_obj, 0, 3, tulip_touch_delta);


STATIC mp_obj_t tulip_key_remap(size_t n_args, const mp_obj_t *args) {
    for(uint8_t i=0;i<MAX_KEY_REMAPS;i++) {
        if(key_remaps[i].scan==0) {
            key_remaps[i].scan = mp_obj_get_int(args[0]);
            key_remaps[i].mod = mp_obj_get_int(args[1]);
            key_remaps[i].code = mp_obj_get_int(args[2]);
            i = MAX_KEY_REMAPS + 1;
        }
    }
    return mp_const_none;

}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_key_remap_obj, 3, 3, tulip_key_remap);

STATIC mp_obj_t tulip_key_remaps_clear(size_t n_args, const mp_obj_t *args) {
    for(uint8_t i=0;i<MAX_KEY_REMAPS;i++) {
        key_remaps[i].scan =0 ;
        key_remaps[i].mod =0 ;
        key_remaps[i].code =0 ;
    }
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_key_remaps_clear_obj, 0, 0, tulip_key_remaps_clear);


STATIC mp_obj_t tulip_key_wait(size_t n_args, const mp_obj_t *args) {
    mp_obj_t tuple[3];
    tuple[0] = mp_obj_new_int(mp_hal_stdin_rx_chr());
    tuple[1] = mp_obj_new_int(last_held_code);
    tuple[2] = mp_obj_new_int(last_held_modifier);
    return mp_obj_new_tuple(3, tuple);
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_key_wait_obj, 0, 0, tulip_key_wait);


STATIC mp_obj_t tulip_key(size_t n_args, const mp_obj_t *args) {
    return mp_obj_new_int(check_rx_char());
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_key_obj, 0, 0, tulip_key);

extern uint8_t keyboard_send_keys_to_micropython;
STATIC mp_obj_t tulip_key_scan(size_t n_args, const mp_obj_t *args) {
    keyboard_send_keys_to_micropython = !(mp_obj_get_int(args[0]));
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_key_scan_obj, 1, 1, tulip_key_scan);

void send_key_to_micropython(uint16_t key);
STATIC mp_obj_t tulip_key_send(size_t n_args, const mp_obj_t *args) {
    send_key_to_micropython(mp_obj_get_int(args[0]));
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_key_send_obj, 1, 1, tulip_key_send);


STATIC mp_obj_t tulip_bg_bezier(size_t n_args, const mp_obj_t *args) {
    uint16_t x0 = mp_obj_get_int(args[0]);
    uint16_t y0 = mp_obj_get_int(args[1]);
    uint16_t x1 = mp_obj_get_int(args[2]);
    uint16_t y1 = mp_obj_get_int(args[3]);
    uint16_t x2 = mp_obj_get_int(args[4]);
    uint16_t y2 = mp_obj_get_int(args[5]);
    uint16_t pal_idx = mp_obj_get_int(args[6]);
    plotQuadBezier(x0,y0,x1,y1,x2,y2,pal_idx);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_bezier_obj, 7, 7, tulip_bg_bezier);



STATIC mp_obj_t tulip_bg_line(size_t n_args, const mp_obj_t *args) {
    int16_t x0 = mp_obj_get_int(args[0]);
    int16_t y0 = mp_obj_get_int(args[1]);
    int16_t x1 = mp_obj_get_int(args[2]);
    int16_t y1 = mp_obj_get_int(args[3]);
    uint8_t pal_idx = mp_obj_get_int(args[4]);
    uint16_t width = 1;
    if(n_args>5) width = mp_obj_get_int(args[5]);
    drawLine_scanline(x0,y0,x1,y1,pal_idx, width);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_line_obj, 5, 6, tulip_bg_line);

STATIC mp_obj_t tulip_bg_roundrect(size_t n_args, const mp_obj_t *args) {
    uint16_t x = mp_obj_get_int(args[0]);
    uint16_t y = mp_obj_get_int(args[1]);
    uint16_t w = mp_obj_get_int(args[2]);
    uint16_t h = mp_obj_get_int(args[3]);
    uint16_t r = mp_obj_get_int(args[4]);
    uint16_t pal_idx = mp_obj_get_int(args[5]);
    if(n_args > 6) {
        if(mp_obj_get_int(args[6])>0) {
            fillRoundRect(x,y,w,h,r,pal_idx);
            return mp_const_none;
        }
    }
    drawRoundRect(x,y,w,h,r,pal_idx);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_roundrect_obj, 6, 7, tulip_bg_roundrect);


STATIC mp_obj_t tulip_bg_rect(size_t n_args, const mp_obj_t *args) {
    uint16_t x = mp_obj_get_int(args[0]);
    uint16_t y = mp_obj_get_int(args[1]);
    uint16_t w = mp_obj_get_int(args[2]);
    uint16_t h = mp_obj_get_int(args[3]);
    uint16_t pal_idx = mp_obj_get_int(args[4]);
    if(n_args > 5) {
        if(mp_obj_get_int(args[5])>0) {
            fillRect(x,y,w,h,pal_idx);
            return mp_const_none;
        } 
    }
    drawRect(x,y,w,h,pal_idx);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_rect_obj, 5, 6, tulip_bg_rect);

STATIC mp_obj_t tulip_bg_circle(size_t n_args, const mp_obj_t *args) {
    uint16_t x = mp_obj_get_int(args[0]);
    uint16_t y = mp_obj_get_int(args[1]);
    uint16_t r = mp_obj_get_int(args[2]);
    uint16_t pal_idx = mp_obj_get_int(args[3]);
    if(n_args > 4) {
        if(mp_obj_get_int(args[4])>0) {
            fillCircle(x,y,r,pal_idx);
            return mp_const_none;
        } 
    }
    drawCircle(x,y,r,pal_idx);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_circle_obj, 4, 5, tulip_bg_circle);


STATIC mp_obj_t tulip_bg_triangle(size_t n_args, const mp_obj_t *args) {
    uint16_t x0 = mp_obj_get_int(args[0]);
    uint16_t y0 = mp_obj_get_int(args[1]);
    uint16_t x1 = mp_obj_get_int(args[2]);
    uint16_t y1 = mp_obj_get_int(args[3]);
    uint16_t x2 = mp_obj_get_int(args[4]);
    uint16_t y2 = mp_obj_get_int(args[5]);
    uint16_t pal_idx = mp_obj_get_int(args[6]);
    if(n_args > 7) {
        if(mp_obj_get_int(args[7])>0) {
            fillTriangle(x0, y0, x1, y1, x2, y2, pal_idx);
            return mp_const_none;
        }
    }
    drawTriangle(x0, y0, x1, y1, x2, y2, pal_idx);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_triangle_obj, 7, 8, tulip_bg_triangle);

STATIC mp_obj_t tulip_bg_fill(size_t n_args, const mp_obj_t *args) {
    uint16_t x0 = mp_obj_get_int(args[0]);
    uint16_t y0 = mp_obj_get_int(args[1]);
    uint16_t pal_idx = mp_obj_get_int(args[2]);
    fill(x0,y0,pal_idx);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_fill_obj, 3, 3, tulip_bg_fill);

STATIC mp_obj_t tulip_bg_char(size_t n_args, const mp_obj_t *args) {
    uint16_t c = mp_obj_get_int(args[0]);
    uint16_t x = mp_obj_get_int(args[1]);
    uint16_t y = mp_obj_get_int(args[2]);
    uint16_t pal_idx = mp_obj_get_int(args[3]);
    uint16_t font_no = mp_obj_get_int(args[4]);
    return mp_obj_new_int(draw_new_char(c, x, y, pal_idx, font_no));
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_char_obj, 5, 5, tulip_bg_char);

STATIC mp_obj_t tulip_bg_str(size_t n_args, const mp_obj_t *args) {
    const char *str =  mp_obj_str_get_str(args[0]);
    uint16_t x = mp_obj_get_int(args[1]);
    uint16_t y = mp_obj_get_int(args[2]);
    uint16_t pal_idx = mp_obj_get_int(args[3]);
    uint16_t font_no = mp_obj_get_int(args[4]);
    if(n_args>5) {
        uint16_t w = mp_obj_get_int(args[5]);
        uint16_t h = mp_obj_get_int(args[6]);        
        return mp_obj_new_int(draw_new_str(str, x, y, pal_idx, font_no, w, h, 1));
    }
    return mp_obj_new_int(draw_new_str(str, x, y, pal_idx, font_no, 0, 0, 0));
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_bg_str_obj, 5, 7, tulip_bg_str);



extern int16_t lvgl_is_repl;
STATIC mp_obj_t tulip_set_screen_as_repl(size_t n_args, const mp_obj_t *args) {
    // set a glob var of the current lvgl screen to test in C for the repl screen later
    // called by boot ui.py 
    int16_t x = mp_obj_get_int(args[0]);
    lvgl_is_repl = x;
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tulip_set_screen_as_repl_obj, 1,1, tulip_set_screen_as_repl);

#endif // #ifndef AMYBOARD_WEB
#endif // #ifndef AMYBOARD

STATIC const mp_rom_map_elem_t tulip_module_globals_table[] = {
    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR__tulip) },
    { MP_ROM_QSTR(MP_QSTR_ticks_ms), MP_ROM_PTR(&tulip_ticks_ms_obj) },
    { MP_ROM_QSTR(MP_QSTR_stderr_write), MP_ROM_PTR(&tulip_stderr_write_obj) },
    { MP_ROM_QSTR(MP_QSTR_defer), MP_ROM_PTR(&tulip_defer_obj) },
    { MP_ROM_QSTR(MP_QSTR_seq_add_callback), MP_ROM_PTR(&tulip_seq_add_callback_obj) },
    { MP_ROM_QSTR(MP_QSTR_seq_remove_callback), MP_ROM_PTR(&tulip_seq_remove_callback_obj) },
    { MP_ROM_QSTR(MP_QSTR_seq_remove_callbacks), MP_ROM_PTR(&tulip_seq_remove_callbacks_obj) },
    { MP_ROM_QSTR(MP_QSTR_midi_callback), MP_ROM_PTR(&tulip_midi_callback_obj) },
    { MP_ROM_QSTR(MP_QSTR_amy_overload_callback), MP_ROM_PTR(&tulip_amy_overload_callback_obj) },
#ifndef __EMSCRIPTEN__
    { MP_ROM_QSTR(MP_QSTR_amy_block_done_callback), MP_ROM_PTR(&tulip_amy_block_done_callback_obj) },
    { MP_ROM_QSTR(MP_QSTR_amy_get_input_buffer), MP_ROM_PTR(&tulip_amy_get_input_buffer_obj) },
    { MP_ROM_QSTR(MP_QSTR_amy_get_output_buffer), MP_ROM_PTR(&tulip_amy_get_output_buffer_obj) },
    { MP_ROM_QSTR(MP_QSTR_amy_set_external_input_buffer), MP_ROM_PTR(&tulip_amy_set_external_input_buffer_obj) },
    { MP_ROM_QSTR(MP_QSTR_amy_get_synth_commands), MP_ROM_PTR(&tulip_amy_get_synth_commands_obj) },
    { MP_ROM_QSTR(MP_QSTR_amy_dump_state), MP_ROM_PTR(&tulip_amy_dump_state_obj) },
    { MP_ROM_QSTR(MP_QSTR_sequencer_start), MP_ROM_PTR(&tulip_sequencer_start_obj) },
#endif
    { MP_ROM_QSTR(MP_QSTR_sysex_in), MP_ROM_PTR(&tulip_sysex_in_obj) },
    { MP_ROM_QSTR(MP_QSTR_seq_ticks), MP_ROM_PTR(&tulip_seq_ticks_obj) },
    { MP_ROM_QSTR(MP_QSTR_midi_in), MP_ROM_PTR(&tulip_midi_in_obj) },
    { MP_ROM_QSTR(MP_QSTR_midi_out), MP_ROM_PTR(&tulip_midi_out_obj) },
    { MP_ROM_QSTR(MP_QSTR_midi_local), MP_ROM_PTR(&tulip_midi_local_obj) },
    { MP_ROM_QSTR(MP_QSTR_cpu), MP_ROM_PTR(&tulip_cpu_obj) },
    { MP_ROM_QSTR(MP_QSTR_board), MP_ROM_PTR(&tulip_board_obj) }, 
    { MP_ROM_QSTR(MP_QSTR_build_strings), MP_ROM_PTR(&tulip_build_strings_obj) },
#if !defined(__EMSCRIPTEN__) && !defined(AMYBOARD)
    //{ MP_ROM_QSTR(MP_QSTR_multicast_start), MP_ROM_PTR(&tulip_multicast_start_obj) },
    //{ MP_ROM_QSTR(MP_QSTR_alles_map), MP_ROM_PTR(&tulip_alles_map_obj) },
#endif

#ifndef __EMSCRIPTEN__
    { MP_ROM_QSTR(MP_QSTR_amy_send), MP_ROM_PTR(&tulip_amy_send_obj) },
    { MP_ROM_QSTR(MP_QSTR_amy_send_sysex), MP_ROM_PTR(&tulip_amy_send_sysex_obj) },
    { MP_ROM_QSTR(MP_QSTR_amy_ticks_ms), MP_ROM_PTR(&tulip_amy_ticks_ms_obj) },
    { MP_ROM_QSTR(MP_QSTR_amy_render_load), MP_ROM_PTR(&tulip_amy_render_load_obj) },
    { MP_ROM_QSTR(MP_QSTR_amy_set_render_load_threshold), MP_ROM_PTR(&tulip_amy_set_render_load_threshold_obj) },
    { MP_ROM_QSTR(MP_QSTR_pcm_load_file), MP_ROM_PTR(&tulip_pcm_load_file_obj) },
#endif

#ifdef TULIP_USER_C_DSP
    { MP_ROM_QSTR(MP_QSTR_install_c_process), MP_ROM_PTR(&tulip_install_c_process_obj) },
    { MP_ROM_QSTR(MP_QSTR_install_c_osc), MP_ROM_PTR(&tulip_install_c_osc_obj) },
    { MP_ROM_QSTR(MP_QSTR_c_process), MP_ROM_PTR(&tulip_c_process_obj) },
    { MP_ROM_QSTR(MP_QSTR_c_osc), MP_ROM_PTR(&tulip_c_osc_obj) },
    { MP_ROM_QSTR(MP_QSTR_c_process_calls), MP_ROM_PTR(&tulip_c_process_calls_obj) },
    { MP_ROM_QSTR(MP_QSTR_uninstall_c_process), MP_ROM_PTR(&tulip_uninstall_c_process_obj) },
#endif

#if defined(AMYBOARD) || defined(AMYBOARD_WEB)
    { MP_ROM_QSTR(MP_QSTR_cv_local), MP_ROM_PTR(&tulip_cv_local_obj) },
    { MP_ROM_QSTR(MP_QSTR_cv_in), MP_ROM_PTR(&tulip_cv_in_obj) },
#endif

#ifdef AMYBOARD_WEB
    { MP_ROM_QSTR(MP_QSTR_framebuf_web_update), MP_ROM_PTR(&tulip_framebuf_web_update_obj) },
#endif

#ifdef ESP_PLATFORM
    { MP_ROM_QSTR(MP_QSTR_amy_set_external_channel), MP_ROM_PTR(&tulip_amy_set_external_channel_obj)},
    { MP_ROM_QSTR(MP_QSTR_set_cv_synth), MP_ROM_PTR(&tulip_set_cv_synth_obj)},
#endif

#ifdef AMYBOARD
    { MP_ROM_QSTR(MP_QSTR_amyboard_send), MP_ROM_PTR(&tulip_amyboard_send_obj) },
    { MP_ROM_QSTR(MP_QSTR_amyboard_start), MP_ROM_PTR(&tulip_amyboard_start_obj) },
    { MP_ROM_QSTR(MP_QSTR_amyboard_set_midi_out), MP_ROM_PTR(&tulip_amyboard_set_midi_out_obj) },
    { MP_ROM_QSTR(MP_QSTR_bootloader_mode), MP_ROM_PTR(&tulip_bootloader_mode_obj) },
#ifdef ESP_PLATFORM
    { MP_ROM_QSTR(MP_QSTR_i2c_bg_write), MP_ROM_PTR(&tulip_i2c_bg_write_obj) },
    { MP_ROM_QSTR(MP_QSTR_i2c_bg_pending), MP_ROM_PTR(&tulip_i2c_bg_pending_obj) },
    { MP_ROM_QSTR(MP_QSTR_i2c_bg_errors), MP_ROM_PTR(&tulip_i2c_bg_errors_obj) },
#endif
#else
    #ifndef AMYBOARD_WEB
    { MP_ROM_QSTR(MP_QSTR_display_clock), MP_ROM_PTR(&tulip_display_clock_obj) },
    { MP_ROM_QSTR(MP_QSTR_display_restart), MP_ROM_PTR(&tulip_display_restart_obj) },
    { MP_ROM_QSTR(MP_QSTR_display_stop), MP_ROM_PTR(&tulip_display_stop_obj) },
    { MP_ROM_QSTR(MP_QSTR_display_start), MP_ROM_PTR(&tulip_display_start_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_swap), MP_ROM_PTR(&tulip_bg_swap_obj) },
    { MP_ROM_QSTR(MP_QSTR_tfb_stop), MP_ROM_PTR(&tulip_tfb_stop_obj) },
    { MP_ROM_QSTR(MP_QSTR_tfb_start), MP_ROM_PTR(&tulip_tfb_start_obj) },
    { MP_ROM_QSTR(MP_QSTR_tfb_save), MP_ROM_PTR(&tulip_tfb_save_obj) },
    { MP_ROM_QSTR(MP_QSTR_tfb_restore), MP_ROM_PTR(&tulip_tfb_restore_obj) },
    { MP_ROM_QSTR(MP_QSTR_tfb_update), MP_ROM_PTR(&tulip_tfb_update_obj) },
    { MP_ROM_QSTR(MP_QSTR_tfb_font), MP_ROM_PTR(&tulip_tfb_font_obj) },
    { MP_ROM_QSTR(MP_QSTR_fps), MP_ROM_PTR(&tulip_fps_obj) },
    { MP_ROM_QSTR(MP_QSTR_gpu), MP_ROM_PTR(&tulip_gpu_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_pixel), MP_ROM_PTR(&tulip_bg_pixel_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_png), MP_ROM_PTR(&tulip_bg_png_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_clear), MP_ROM_PTR(&tulip_bg_clear_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_scroll), MP_ROM_PTR(&tulip_bg_scroll_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_scroll_x_speed), MP_ROM_PTR(&tulip_bg_scroll_x_speed_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_scroll_y_speed), MP_ROM_PTR(&tulip_bg_scroll_y_speed_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_scroll_x_offset), MP_ROM_PTR(&tulip_bg_scroll_x_offset_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_scroll_y_offset), MP_ROM_PTR(&tulip_bg_scroll_y_offset_obj) },
    { MP_ROM_QSTR(MP_QSTR_tfb_str), MP_ROM_PTR(&tulip_tfb_str_obj) },
    { MP_ROM_QSTR(MP_QSTR_frame_callback), MP_ROM_PTR(&tulip_frame_callback_obj) },
    { MP_ROM_QSTR(MP_QSTR_touch_callback), MP_ROM_PTR(&tulip_touch_callback_obj) },
    { MP_ROM_QSTR(MP_QSTR_keyboard_callback), MP_ROM_PTR(&tulip_keyboard_callback_obj) },
    { MP_ROM_QSTR(MP_QSTR_ui_quit_callback), MP_ROM_PTR(&tulip_ui_quit_callback_obj) },
    { MP_ROM_QSTR(MP_QSTR_ui_switch_callback), MP_ROM_PTR(&tulip_ui_switch_callback_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_bitmap), MP_ROM_PTR(&tulip_bg_bitmap_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_blit), MP_ROM_PTR(&tulip_bg_blit_obj) },
    { MP_ROM_QSTR(MP_QSTR_sprite_png), MP_ROM_PTR(&tulip_sprite_png_obj) },
    { MP_ROM_QSTR(MP_QSTR_sprite_bitmap), MP_ROM_PTR(&tulip_sprite_bitmap_obj) },
    { MP_ROM_QSTR(MP_QSTR_sprite_register), MP_ROM_PTR(&tulip_sprite_register_obj) },
    { MP_ROM_QSTR(MP_QSTR_sprite_move), MP_ROM_PTR(&tulip_sprite_move_obj) },
    { MP_ROM_QSTR(MP_QSTR_sprite_on), MP_ROM_PTR(&tulip_sprite_on_obj) },
    { MP_ROM_QSTR(MP_QSTR_sprite_off), MP_ROM_PTR(&tulip_sprite_off_obj) },
    { MP_ROM_QSTR(MP_QSTR_sprite_clear), MP_ROM_PTR(&tulip_sprite_clear_obj) },
    { MP_ROM_QSTR(MP_QSTR_collisions), MP_ROM_PTR(&tulip_collisions_obj) },
    { MP_ROM_QSTR(MP_QSTR_run_editor), MP_ROM_PTR(&tulip_run_editor_obj) },
    { MP_ROM_QSTR(MP_QSTR_deinit_editor), MP_ROM_PTR(&tulip_deinit_editor_obj) },
    { MP_ROM_QSTR(MP_QSTR_key_editor), MP_ROM_PTR(&tulip_key_editor_obj) },
    { MP_ROM_QSTR(MP_QSTR_activate_editor), MP_ROM_PTR(&tulip_activate_editor_obj) },
    { MP_ROM_QSTR(MP_QSTR_int_screenshot), MP_ROM_PTR(&tulip_int_screenshot_obj) },
    { MP_ROM_QSTR(MP_QSTR_brightness), MP_ROM_PTR(&tulip_brightness_obj) },
    { MP_ROM_QSTR(MP_QSTR_rgb332_565), MP_ROM_PTR(&tulip_rgb332_565_obj) },
    { MP_ROM_QSTR(MP_QSTR_keys), MP_ROM_PTR(&tulip_keys_obj) },
    { MP_ROM_QSTR(MP_QSTR_touch), MP_ROM_PTR(&tulip_touch_obj) },
    { MP_ROM_QSTR(MP_QSTR_touch_delta), MP_ROM_PTR(&tulip_touch_delta_obj) },
    { MP_ROM_QSTR(MP_QSTR_key_remap), MP_ROM_PTR(&tulip_key_remap_obj) },
    { MP_ROM_QSTR(MP_QSTR_key_remaps_clear), MP_ROM_PTR(&tulip_key_remaps_clear_obj) },
    { MP_ROM_QSTR(MP_QSTR_key_wait), MP_ROM_PTR(&tulip_key_wait_obj) },
    { MP_ROM_QSTR(MP_QSTR_key), MP_ROM_PTR(&tulip_key_obj) },
    { MP_ROM_QSTR(MP_QSTR_key_scan), MP_ROM_PTR(&tulip_key_scan_obj) },
    { MP_ROM_QSTR(MP_QSTR_key_send), MP_ROM_PTR(&tulip_key_send_obj) },
    { MP_ROM_QSTR(MP_QSTR_gpu_reset), MP_ROM_PTR(&tulip_gpu_reset_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_circle), MP_ROM_PTR(&tulip_bg_circle_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_bezier), MP_ROM_PTR(&tulip_bg_bezier_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_line), MP_ROM_PTR(&tulip_bg_line_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_roundrect), MP_ROM_PTR(&tulip_bg_roundrect_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_triangle), MP_ROM_PTR(&tulip_bg_triangle_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_fill), MP_ROM_PTR(&tulip_bg_fill_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_rect), MP_ROM_PTR(&tulip_bg_rect_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_char), MP_ROM_PTR(&tulip_bg_char_obj) },
    { MP_ROM_QSTR(MP_QSTR_bg_str), MP_ROM_PTR(&tulip_bg_str_obj) },
    { MP_ROM_QSTR(MP_QSTR_gpu_log), MP_ROM_PTR(&tulip_gpu_log_obj) },
    { MP_ROM_QSTR(MP_QSTR_screen_size), MP_ROM_PTR(&tulip_screen_size_obj) },
    { MP_ROM_QSTR(MP_QSTR_set_screen_as_repl), MP_ROM_PTR(&tulip_set_screen_as_repl_obj) },
    #endif
#endif


// Special platform specific things
#ifndef ESP_PLATFORM
#ifndef __linux__
#ifndef __EMSCRIPTEN__
    { MP_ROM_QSTR(MP_QSTR_app_path), MP_ROM_PTR(&tulip_app_path_obj) },
#endif
#endif
#endif

};

STATIC MP_DEFINE_CONST_DICT(tulip_module_globals, tulip_module_globals_table);

const mp_obj_module_t tulip_module = {
    .base = { &mp_type_module },
    .globals = (mp_obj_dict_t *)&tulip_module_globals,
};


MP_REGISTER_MODULE(MP_QSTR__tulip, tulip_module); // MICROPY_PY_TULIP);