From a536899ab8c0fa5a307c84bedcb8eaf5a024ca23 Mon Sep 17 00:00:00 2001 From: Thomas Ball Date: Tue, 31 Dec 2024 20:59:13 +0000 Subject: [PATCH 01/16] bring cpp out of pxt-microbit --- cpp/arcadegamepad.h | 49 ++++++ cpp/arcadesound.h | 31 ++++ cpp/config_nrf.h | 69 ++++++++ cpp/controllerbuttons.cpp | 168 ++++++++++++++++++ cpp/indexedscreen.h | 85 +++++++++ cpp/jddisplay.cpp | 359 ++++++++++++++++++++++++++++++++++++++ cpp/jddisplay.h | 67 +++++++ cpp/jdprotocol.h | 125 +++++++++++++ cpp/pins.cpp | 71 ++++++++ cpp/pinsDigital.cpp | 142 +++++++++++++++ cpp/pxt.json | 39 +++++ cpp/screen.cpp | 348 ++++++++++++++++++++++++++++++++++++ cpp/screenhelpers.d.ts | 14 ++ cpp/shims.d.ts | 159 +++++++++++++++++ cpp/test.ts | 29 +++ pxt.json | 25 ++- 16 files changed, 1776 insertions(+), 4 deletions(-) create mode 100644 cpp/arcadegamepad.h create mode 100644 cpp/arcadesound.h create mode 100644 cpp/config_nrf.h create mode 100644 cpp/controllerbuttons.cpp create mode 100644 cpp/indexedscreen.h create mode 100644 cpp/jddisplay.cpp create mode 100644 cpp/jddisplay.h create mode 100644 cpp/jdprotocol.h create mode 100644 cpp/pins.cpp create mode 100644 cpp/pinsDigital.cpp create mode 100644 cpp/pxt.json create mode 100644 cpp/screen.cpp create mode 100644 cpp/screenhelpers.d.ts create mode 100644 cpp/shims.d.ts create mode 100644 cpp/test.ts diff --git a/cpp/arcadegamepad.h b/cpp/arcadegamepad.h new file mode 100644 index 0000000..bcfe457 --- /dev/null +++ b/cpp/arcadegamepad.h @@ -0,0 +1,49 @@ +// Autogenerated C header file for Arcade Gamepad +#ifndef _JACDAC_SPEC_ARCADE_GAMEPAD_H +#define _JACDAC_SPEC_ARCADE_GAMEPAD_H 1 + +#define JD_SERVICE_CLASS_ARCADE_GAMEPAD 0x1deaa06e + +// enum Button (uint8_t) +#define JD_ARCADE_GAMEPAD_BUTTON_LEFT 0x1 +#define JD_ARCADE_GAMEPAD_BUTTON_UP 0x2 +#define JD_ARCADE_GAMEPAD_BUTTON_RIGHT 0x3 +#define JD_ARCADE_GAMEPAD_BUTTON_DOWN 0x4 +#define JD_ARCADE_GAMEPAD_BUTTON_A 0x5 +#define JD_ARCADE_GAMEPAD_BUTTON_B 0x6 +#define JD_ARCADE_GAMEPAD_BUTTON_MENU 0x7 +#define JD_ARCADE_GAMEPAD_BUTTON_SELECT 0x8 +#define JD_ARCADE_GAMEPAD_BUTTON_RESET 0x9 +#define JD_ARCADE_GAMEPAD_BUTTON_EXIT 0xa + +/** + * Indicates which buttons are currently active (pressed). + * `pressure` should be `0xff` for digital buttons, and proportional for analog ones. + */ +#define JD_ARCADE_GAMEPAD_REG_BUTTONS JD_REG_READING +typedef struct jd_arcade_gamepad_buttons { + uint8_t button; // Button + uint8_t pressure; // ratio u0.8 +} jd_arcade_gamepad_buttons_t; + + +/** + * Constant. Indicates number of players supported and which buttons are present on the controller. + */ +#define JD_ARCADE_GAMEPAD_REG_AVAILABLE_BUTTONS 0x180 +typedef struct jd_arcade_gamepad_available_buttons { + uint8_t button[0]; // Button +} jd_arcade_gamepad_available_buttons_t; + + +/** + * Argument: button Button (uint8_t). Emitted when button goes from inactive to active. + */ +#define JD_ARCADE_GAMEPAD_EV_DOWN JD_EV_ACTIVE + +/** + * Argument: button Button (uint8_t). Emitted when button goes from active to inactive. + */ +#define JD_ARCADE_GAMEPAD_EV_UP JD_EV_INACTIVE + +#endif diff --git a/cpp/arcadesound.h b/cpp/arcadesound.h new file mode 100644 index 0000000..7b47d36 --- /dev/null +++ b/cpp/arcadesound.h @@ -0,0 +1,31 @@ +// Autogenerated C header file for Arcade sound +#ifndef _JACDAC_SPEC_ARCADE_SOUND_H +#define _JACDAC_SPEC_ARCADE_SOUND_H 1 + +#define JD_SERVICE_CLASS_ARCADE_SOUND 0x1fc63606 + +/** + * Argument: samples bytes. Play samples, which are single channel, signed 16-bit little endian values. + */ +#define JD_ARCADE_SOUND_CMD_PLAY 0x80 + +/** + * Read-write Hz u22.10 (uint32_t). Get or set playback sample rate (in samples per second). + * If you set it, read it back, as the value may be rounded up or down. + */ +#define JD_ARCADE_SOUND_REG_SAMPLE_RATE 0x80 + +/** + * Constant B uint32_t. The size of the internal audio buffer. + */ +#define JD_ARCADE_SOUND_REG_BUFFER_SIZE 0x180 + +/** + * Read-only B uint32_t. How much data is still left in the buffer to play. + * Clients should not send more data than `buffer_size - buffer_pending`, + * but can keep the `buffer_pending` as low as they want to ensure low latency + * of audio playback. + */ +#define JD_ARCADE_SOUND_REG_BUFFER_PENDING 0x181 + +#endif diff --git a/cpp/config_nrf.h b/cpp/config_nrf.h new file mode 100644 index 0000000..8c8a531 --- /dev/null +++ b/cpp/config_nrf.h @@ -0,0 +1,69 @@ +// here we hard code the dependence on micro:bit V2 +// and Arcade Shield, to avoid potential conflicts with pxt-microbit + +#include "NRF52Pin.h" +#include "NRF52SPI.h" + +#define CODAL_PIN NRF52Pin +#define CODAL_SPI NRF52SPI + +#define MY_DISPLAY_TYPE 4242 // smart shield +#define MY_DISPLAY_CFG0 0x02000080 // allow execution without shield plugged in +#define MY_DISPLAY_CFG1 0x00000603 +#define MY_DISPLAY_CFG2 8 // maximum SPI frequency for smart shield + +#define MY_PIN_BTNMX_LATCH &uBit.io.P9 // DAL.P0_9 +#define MY_PIN_BTNMX_CLOCK &uBit.io.P20 // DAL.P1_0 +#define MY_PIN_BTNMX_DATA &uBit.io.P14 // DAL.P0_1 + +#define MY_PIN_DISPLAY_SCK &uBit.io.P13 // DAL.P0_17 +#define MY_PIN_DISPLAY_MOSI &uBit.io.P15 // DAL.P0_13 +#define MY_PIN_DISPLAY_MISO &uBit.io.P14 // DAL.P0_1 +#define MY_PIN_DISPLAY_BL &uBit.io.P19 // DAL.P0_26 +#define MY_PIN_DISPLAY_DC &uBit.io.P8 // DAL.P0_10 +#define MY_PIN_DISPLAY_RST &uBit.io.P16 // DAL.P1_2 +#define MY_PIN_DISPLAY_CS ((CODAL_PIN*)NULL) // not connected +#define MY_PIN_LED ((CODAL_PIN*)NULL) // not connected + +#undef DEV_NUM_PINS +#define DEV_NUM_PINS 48 +#define DEVICE_ID_IO_P0 100 + +#define DEV_PWM_PINS 0x0000ffffffffULL // all pins are PWM pins it seems +#define DEV_AIN_PINS 0x0000f000001fULL + +// Codal doesn't yet distinguish between PWM and AIN +#define DEV_ANALOG_PINS (DEV_PWM_PINS | DEV_AIN_PINS) + +#ifndef IS_ANALOG_PIN +#define IS_ANALOG_PIN(id) ((DEV_ANALOG_PINS >> (id)) & 1) +#endif + +typedef CODAL_PIN DevicePin; + +typedef DevicePin *DigitalInOutPin; +typedef DevicePin *AnalogInOutPin; +typedef DevicePin *AnalogInPin; +typedef DevicePin *AnalogOutPin; +typedef DevicePin *PwmPin; +typedef DevicePin *PwmOnlyPin; + +// remove the indirection through configuration +#undef PIN +#undef LOOKUP_PIN +#define PIN(name) MY_PIN_##name +#define LOOKUP_PIN(name) PIN(name) // pxt::myLookupPin(PIN(name)) + +#define PXT_INTERNAL_KEY_UP 2050 +#define PXT_INTERNAL_KEY_DOWN 2051 +#define DEVICE_ID_FIRST_BUTTON 4000 +#define BUTTON_ACTIVE_LOW_PULL_UP 32 + +namespace pxt { + uint32_t readButtonMultiplexer(int bits); + void disableButtonMultiplexer(); + DevicePin *myLookupPin(int pinName); + CodalComponent *lookupComponent(int id); + int pressureLevelByButtonId(int btnId, int codalId); +} + diff --git a/cpp/controllerbuttons.cpp b/cpp/controllerbuttons.cpp new file mode 100644 index 0000000..bea8b4e --- /dev/null +++ b/cpp/controllerbuttons.cpp @@ -0,0 +1,168 @@ +#include "pxt.h" + +#undef Button + +#include "Pin.h" +#define PinCompat codal::Pin + +#include "config_nrf.h" + +namespace pxt { + + +class PressureButton : public codal::Button { + public: + PressureButton(Pin &pin, uint16_t id, + ButtonEventConfiguration eventConfiguration = DEVICE_BUTTON_ALL_EVENTS, + ButtonPolarity polarity = ACTIVE_LOW, PullMode mode = PullMode::None) + : Button(pin, id, eventConfiguration, polarity, mode) {} + + virtual int pressureLevel() { return isPressed() ? 512 : 0; } +}; + +struct AnalogCache { + AnalogCache *next; + Pin *pin; + uint32_t lastMeasureMS; + uint16_t lastMeasure; + AnalogCache(Pin *pin) : pin(pin) { + next = NULL; + lastMeasureMS = 0; + lastMeasure = pin->getAnalogValue(); + } + uint16_t read(); +}; + +uint16_t AnalogCache::read() { + uint32_t now = current_time_ms(); + if (now - lastMeasureMS < 50) + return lastMeasure; + lastMeasureMS = now; + lastMeasure = pin->getAnalogValue(); + return lastMeasure; +} + +static AnalogCache *analogCache; + +class AnalogButton : public PressureButton { + public: + AnalogCache *cache; + int16_t threshold; + bool state; + + AnalogButton(AnalogCache *cache, uint16_t id, int threshold) + : PressureButton(*cache->pin, id), cache(cache), threshold(threshold), state(false) {} + + protected: + virtual int pressureLevel() override { + int v = cache->read() - 512; + if (threshold < 0) + v = -v; + int vmin = getConfig(CFG_ANALOG_JOYSTICK_MIN, 50); + int vmax = getConfig(CFG_ANALOG_JOYSTICK_MAX, 500); + v = (v - vmin) * 512 / (vmax - vmin); + if (v < 0) + v = 0; + if (v > 512) + v = 512; + return v; + } + + virtual int buttonActive() override { + int v = cache->read() - 512; + int thr = threshold; + + if (thr < 0) { + v = -v; + thr = -thr; + } + + if (v > thr) + state = true; + else if (state && v > thr * 3 / 4) + state = true; + else + state = false; + + return state; + } +}; + +AnalogCache *lookupAnalogCache(Pin *pin) { + for (auto c = analogCache; c; c = c->next) + if (c->pin == pin) + return c; + auto c = new AnalogCache(pin); + c->next = analogCache; + analogCache = c; + return c; +} + +int multiplexedButtonIsPressed(int btnId); +int registerMultiplexedButton(int pin, int buttonId); + +//% expose +int pressureLevelByButtonId(int btnId, int codalId) { + if (codalId <= 0) + codalId = DEVICE_ID_FIRST_BUTTON + btnId; + auto btn = (PressureButton *)lookupComponent(codalId); + if (!btn) { + return multiplexedButtonIsPressed(btnId) ? 512 : 0; + } + return btn->pressureLevel(); +} + +static void sendBtnDown(Event ev) { + Event(PXT_INTERNAL_KEY_DOWN, ev.source - DEVICE_ID_FIRST_BUTTON); +} + +static void sendBtnUp(Event ev) { + Event(PXT_INTERNAL_KEY_UP, ev.source - DEVICE_ID_FIRST_BUTTON); +} + +//% expose +void setupButton(int buttonId, int key) { + int pin = getConfig(key); + if (pin == -1) + return; + + unsigned highflags = (unsigned)pin >> 16; + int flags = BUTTON_ACTIVE_LOW_PULL_UP; + if (highflags & 0xff) + flags = highflags & 0xff; + + pin &= 0xffff; + + auto cpid = DEVICE_ID_FIRST_BUTTON + buttonId; + auto btn = (PressureButton *)lookupComponent(cpid); + if (btn == NULL) { + if (registerMultiplexedButton(pin, buttonId)) + return; + + if (1100 <= pin && pin < 1300) { + pin -= 1100; + int thr = getConfig(CFG_ANALOG_BUTTON_THRESHOLD, 300); + if (pin >= 100) { + thr = -thr; + pin -= 100; + } + btn = new AnalogButton(lookupAnalogCache(myLookupPin(pin)), cpid, thr); + } else { + auto pull = PullMode::None; + if ((flags & 0xf0) == 0x10) + pull = PullMode::Down; + else if ((flags & 0xf0) == 0x20) + pull = PullMode::Up; + else if ((flags & 0xf0) == 0x30) + pull = PullMode::None; + else + oops(3); + btn = new PressureButton(*myLookupPin(pin), cpid, DEVICE_BUTTON_ALL_EVENTS, + (ButtonPolarity)(flags & 0xf), pull); + } + EventModel::defaultEventBus->listen(btn->id, DEVICE_BUTTON_EVT_DOWN, sendBtnDown); + EventModel::defaultEventBus->listen(btn->id, DEVICE_BUTTON_EVT_UP, sendBtnUp); + } +} + +} // namespace pxt diff --git a/cpp/indexedscreen.h b/cpp/indexedscreen.h new file mode 100644 index 0000000..1cc0005 --- /dev/null +++ b/cpp/indexedscreen.h @@ -0,0 +1,85 @@ +// Autogenerated C header file for Indexed screen +#ifndef _JACDAC_SPEC_INDEXED_SCREEN_H +#define _JACDAC_SPEC_INDEXED_SCREEN_H 1 + +#define JD_SERVICE_CLASS_INDEXED_SCREEN 0x16fa36e5 + +/** + * Sets the update window for subsequent `set_pixels` commands. + */ +#define JD_INDEXED_SCREEN_CMD_START_UPDATE 0x81 +typedef struct jd_indexed_screen_start_update { + uint16_t x; // px + uint16_t y; // px + uint16_t width; // px + uint16_t height; // px +} jd_indexed_screen_start_update_t; + + +/** + * Argument: pixels bytes. Set pixels in current window, according to current palette. + * Each "line" of data is aligned to a byte. + */ +#define JD_INDEXED_SCREEN_CMD_SET_PIXELS 0x83 + +/** + * Read-write ratio u0.8 (uint8_t). Set backlight brightness. + * If set to `0` the display may go to sleep. + */ +#define JD_INDEXED_SCREEN_REG_BRIGHTNESS JD_REG_INTENSITY + +/** + * The current palette. + * The color entry repeats `1 << bits_per_pixel` times. + * This register may be write-only. + */ +#define JD_INDEXED_SCREEN_REG_PALETTE 0x80 +typedef struct jd_indexed_screen_palette { + uint8_t blue; + uint8_t green; + uint8_t red; + uint8_t padding; +} jd_indexed_screen_palette_t; + + +/** + * Constant bit uint8_t. Determines the number of palette entries. + * Typical values are 1, 2, 4, or 8. + */ +#define JD_INDEXED_SCREEN_REG_BITS_PER_PIXEL 0x180 + +/** + * Constant px uint16_t. Screen width in "natural" orientation. + */ +#define JD_INDEXED_SCREEN_REG_WIDTH 0x181 + +/** + * Constant px uint16_t. Screen height in "natural" orientation. + */ +#define JD_INDEXED_SCREEN_REG_HEIGHT 0x182 + +/** + * Read-write bool (uint8_t). If true, consecutive pixels in the "width" direction are sent next to each other (this is typical for graphics cards). + * If false, consecutive pixels in the "height" direction are sent next to each other. + * For embedded screen controllers, this is typically true iff `width < height` + * (in other words, it's only true for portrait orientation screens). + * Some controllers may allow the user to change this (though the refresh order may not be optimal then). + * This is independent of the `rotation` register. + */ +#define JD_INDEXED_SCREEN_REG_WIDTH_MAJOR 0x81 + +/** + * Read-write px uint8_t. Every pixel sent over wire is represented by `up_sampling x up_sampling` square of physical pixels. + * Some displays may allow changing this (which will also result in changes to `width` and `height`). + * Typical values are 1 and 2. + */ +#define JD_INDEXED_SCREEN_REG_UP_SAMPLING 0x82 + +/** + * Read-write ° uint16_t. Possible values are 0, 90, 180 and 270 only. + * Write to this register do not affect `width` and `height` registers, + * and may be ignored by some screens. + */ +#define JD_INDEXED_SCREEN_REG_ROTATION 0x83 + +#endif diff --git a/cpp/jddisplay.cpp b/cpp/jddisplay.cpp new file mode 100644 index 0000000..4d444bb --- /dev/null +++ b/cpp/jddisplay.cpp @@ -0,0 +1,359 @@ +#include "pxt.h" + +#include "jddisplay.h" + +#include "config_nrf.h" + +#define VLOG NOLOG +//#define VLOG DMESG + +namespace pxt { + +codal::CodalDevice device; + +#define ALIGN(x) (((x) + 3) & ~3) + +static void jd_panic(void) { + target_panic(121); // PANIC_SCREEN_ERROR +} + +static int jd_shift_frame(jd_frame_t *frame) { + int psize = frame->size; + jd_packet_t *pkt = (jd_packet_t *)frame; + int oldsz = pkt->service_size + 4; + if (ALIGN(oldsz) >= psize) + return 0; // nothing to shift + + int ptr; + if (frame->data[oldsz] == 0xff) { + ptr = frame->data[oldsz + 1]; + if (ptr >= psize) + return 0; // End-of-frame + if (ptr <= oldsz) { + DMESG("invalid super-frame %d %d", ptr, oldsz); + return 0; // don't let it go back, must be some corruption + } + } else { + ptr = ALIGN(oldsz); + } + + // assume the first one got the ACK sorted + frame->flags &= ~JD_FRAME_FLAG_ACK_REQUESTED; + + uint8_t *src = &frame->data[ptr]; + int newsz = *src + 4; + if (ptr + newsz > psize) { + DMESG("invalid super-frame %d %d %d", ptr, newsz, psize); + return 0; + } + uint32_t *dst = (uint32_t *)frame->data; + uint32_t *srcw = (uint32_t *)src; + // don't trust memmove() + for (int i = 0; i < newsz; i += 4) + *dst++ = *srcw++; + // store ptr + ptr += ALIGN(newsz); + frame->data[newsz] = 0xff; + frame->data[newsz + 1] = ptr; + + return 1; +} + +static void *jd_push_in_frame(jd_frame_t *frame, unsigned service_num, unsigned service_cmd, + unsigned service_size) { + if (service_num >> 8) + jd_panic(); + if (service_cmd >> 16) + jd_panic(); + uint8_t *dst = frame->data + frame->size; + unsigned szLeft = (uint8_t *)frame + sizeof(*frame) - dst; + if (service_size + 4 > szLeft) + return NULL; + *dst++ = service_size; + *dst++ = service_num; + *dst++ = service_cmd & 0xff; + *dst++ = service_cmd >> 8; + frame->size += ALIGN(service_size + 4); + return dst; +} + +JDDisplay::JDDisplay(SPI *spi, Pin *cs, Pin *flow) : spi(spi), cs(cs), flow(flow) { + inProgress = false; + stepWaiting = false; + displayServiceNum = 0; + controlsStartServiceNum = 0; + controlsEndServiceNum = 0; + soundServiceNum = 0; + buttonState = 0; + brightness = 100; + soundBufferPending = 0; + soundSampleRate = 44100; + avgFrameTime = 26300; // start with a reasonable default + lastFrameTimestamp = 0; + + EventModel::defaultEventBus->listen(DEVICE_ID_DISPLAY, 4243, this, &JDDisplay::sendDone); + + flow->getDigitalValue(PullMode::Down); + EventModel::defaultEventBus->listen(flow->id, DEVICE_PIN_EVENT_ON_EDGE, this, + &JDDisplay::onFlowHi, MESSAGE_BUS_LISTENER_IMMEDIATE); + flow->eventOn(DEVICE_PIN_EVT_RISE); +} + +void JDDisplay::waitForSendDone() { + if (inProgress) + fiber_wait_for_event(DEVICE_ID_DISPLAY, 4242); +} + +void JDDisplay::sendDone(Event) { + inProgress = false; + Event(DEVICE_ID_DISPLAY, 4242); +} + +void *JDDisplay::queuePkt(uint32_t service_num, uint32_t service_cmd, uint32_t size) { + void *res = jd_push_in_frame(&sendFrame, service_num, service_cmd, size); + if (res == NULL) + target_panic(122); // PANIC_SCREEN_ERROR + return res; +} + +void JDDisplay::flushSend() { + if (cs) + cs->setDigitalValue(0); + spi->startTransfer((uint8_t *)&sendFrame, sizeof(sendFrame), (uint8_t *)&recvFrame, + sizeof(recvFrame), &JDDisplay::stepStatic, this); +} + +void JDDisplay::stepStatic(void *p) { + ((JDDisplay *)p)->step(); +} + +// We assume EIC IRQ pre-empts SPI/DMA IRQ (that is the numerical priority value of EIC is lower) +// This is true for codal STM32, SAMD, and NRF52 +void JDDisplay::onFlowHi(Event) { + if (stepWaiting) + step(); +} + +void JDDisplay::handleIncoming(jd_packet_t *pkt) { + if (pkt->service_number == JD_SERVICE_NUMBER_CTRL && + pkt->service_command == JD_CMD_ADVERTISEMENT_DATA) { + uint32_t *servptr = (uint32_t *)pkt->data; + int numServ = pkt->service_size >> 2; + for (uint8_t servIdx = 1; servIdx < numServ; ++servIdx) { + uint32_t service_class = servptr[servIdx]; + if (service_class == JD_SERVICE_CLASS_INDEXED_SCREEN) { + displayServiceNum = servIdx; + VLOG("JDA: found screen, serv=%d", servIdx); + } else if (service_class == JD_SERVICE_CLASS_ARCADE_GAMEPAD) { + if (!controlsStartServiceNum) + controlsStartServiceNum = servIdx; + controlsEndServiceNum = servIdx; + VLOG("JDA: found controls, serv=%d", servIdx); + } else if (service_class == JD_SERVICE_CLASS_ARCADE_SOUND) { + soundServiceNum = servIdx; + VLOG("JDA: found sound, serv=%d", servIdx); + } else { + VLOG("JDA: unknown service: %x", service_class); + } + } + } else if (pkt->service_number == JD_SERVICE_NUMBER_CTRL && + pkt->service_command == JD_CMD_CTRL_NOOP) { + // do nothing + } else if (pkt->service_number == soundServiceNum) { + switch (pkt->service_command) { + case JD_GET(JD_ARCADE_SOUND_REG_BUFFER_PENDING): + soundBufferPending = *(uint32_t *)pkt->data; + break; + case JD_GET(JD_ARCADE_SOUND_REG_SAMPLE_RATE): + soundSampleRate = *(uint32_t *)pkt->data >> 10; + break; + } + } else if (pkt->service_number == displayServiceNum) { + switch (pkt->service_command) { + case JD_GET(JD_INDEXED_SCREEN_REG_HEIGHT): + screenHeight = *(uint16_t *)pkt->data; + break; + case JD_GET(JD_INDEXED_SCREEN_REG_WIDTH): + screenWidth = *(uint16_t *)pkt->data; + break; + } + } else if (controlsStartServiceNum <= pkt->service_number && + pkt->service_number <= controlsEndServiceNum && + pkt->service_command == (JD_CMD_GET_REG | JD_REG_READING)) { + auto report = (jd_arcade_gamepad_buttons_t *)pkt->data; + auto endp = pkt->data + pkt->service_size; + uint32_t state = 0; + + while ((uint8_t *)report < endp) { + int idx = 0; + int b = report->button; + + if (report->pressure < 0x20) + continue; + + if (b == JD_ARCADE_GAMEPAD_BUTTON_SELECT) + b = JD_ARCADE_GAMEPAD_BUTTON_MENU; + + if (b == JD_ARCADE_GAMEPAD_BUTTON_RESET || b == JD_ARCADE_GAMEPAD_BUTTON_EXIT) + target_reset(); + + if (1 <= b && b <= 7) { + idx = b + 7 * (pkt->service_number - controlsStartServiceNum); + } + + if (idx > 0) + state |= 1 << idx; + + report++; + } + + if (state != buttonState) { + for (int i = 0; i < 32; ++i) { + if ((state & (1 << i)) && !(buttonState & (1 << i))) + Event(PXT_INTERNAL_KEY_DOWN, i); + if (!(state & (1 << i)) && (buttonState & (1 << i))) + Event(PXT_INTERNAL_KEY_UP, i); + } + buttonState = state; + } + } else { + // TODO remove later + VLOG("JDA: unknown packet for %d (cmd=%x)", pkt->service_number, pkt->service_command); + } +} + +void JDDisplay::step() { + if (cs) + cs->setDigitalValue(1); + + target_disable_irq(); + if (!flow->getDigitalValue()) { + stepWaiting = true; + target_enable_irq(); + return; + } else { + stepWaiting = false; + } + target_enable_irq(); + + memset(&sendFrame, 0, JD_SERIAL_FULL_HEADER_SIZE); + sendFrame.crc = JDSPI_MAGIC; + sendFrame.device_identifier = device.getSerialNumber(); + + if (recvFrame.crc == JDSPI_MAGIC_NOOP) { + // empty frame, skip + } else if (recvFrame.crc != JDSPI_MAGIC) { + DMESG("JDA: magic mismatch %x", (int)recvFrame.crc); + } else if (recvFrame.size == 0) { + // empty frame, skip + } else { + for (;;) { + handleIncoming((jd_packet_t *)&recvFrame); + if (!jd_shift_frame(&recvFrame)) + break; + } + } + + if (displayServiceNum == 0) { + // poke the control service to enumerate + queuePkt(JD_SERVICE_NUMBER_CTRL, JD_CMD_ADVERTISEMENT_DATA, 0); + flushSend(); + return; + } + + if (palette) { + { +#define PALETTE_SIZE (16 * 4) + auto cmd = + queuePkt(displayServiceNum, JD_SET(JD_INDEXED_SCREEN_REG_PALETTE), PALETTE_SIZE); + memcpy(cmd, palette, PALETTE_SIZE); + palette = NULL; + } + { + auto cmd = (jd_indexed_screen_start_update_t *)queuePkt( + displayServiceNum, JD_INDEXED_SCREEN_CMD_START_UPDATE, + sizeof(jd_indexed_screen_start_update_t)); + *cmd = this->addr; + } + { + auto cmd = + (uint8_t *)queuePkt(displayServiceNum, JD_SET(JD_INDEXED_SCREEN_REG_BRIGHTNESS), 1); + *cmd = this->brightness * 0xff / 100; + } + + if (soundServiceNum) { + // we only need this for sending sound + uint32_t now = (uint32_t)(pxt::current_time_ms()); + if (lastFrameTimestamp) { + uint32_t thisFrame = now - lastFrameTimestamp; + avgFrameTime = (avgFrameTime * 15 + thisFrame) >> 4; + } + lastFrameTimestamp = now; + // send around 2 frames of sound; typically around 60ms, so ~3000 samples + soundBufferDesiredSize = + sizeof(int16_t *) * ((((avgFrameTime * 2) >> 10) * soundSampleRate) >> 10); + } + + flushSend(); + return; + } + + if (dataLeft > 0) { + uint32_t transfer = bytesPerTransfer; + if (dataLeft < transfer) + transfer = dataLeft; + auto pixels = queuePkt(displayServiceNum, JD_INDEXED_SCREEN_CMD_SET_PIXELS, transfer); + memcpy(pixels, dataPtr, transfer); + dataPtr += transfer; + dataLeft -= transfer; + flushSend(); + } else if (soundServiceNum && soundBufferPending < soundBufferDesiredSize) { + int bytesLeft = soundBufferDesiredSize - soundBufferPending; + if (bytesLeft > bytesPerTransfer) + bytesLeft = bytesPerTransfer; + auto samples = (int16_t *)queuePkt(soundServiceNum, JD_ARCADE_SOUND_CMD_PLAY, bytesLeft); + if (pxt::redirectSamples(samples, bytesLeft >> 1, soundSampleRate)) { + soundBufferPending += bytesLeft; + } else { + // no sound generated, fill with 0 and stop + memset(samples, 0, bytesLeft); + soundBufferDesiredSize = 0; + } + flushSend(); + } else { + // trigger sendDone(), which executes outside of IRQ context, so there + // is no race with waitForSendDone + Event(DEVICE_ID_DISPLAY, 4243); + } +} + +int JDDisplay::sendIndexedImage(const uint8_t *src, unsigned width, unsigned height, + uint32_t *palette) { + if (height & 1 || !height || !width) + target_panic(123); // PANIC_SCREEN_ERROR + if (width != addr.width || height != addr.height) + target_panic(124); // PANIC_SCREEN_ERROR + if (inProgress) + target_panic(125); // PANIC_SCREEN_ERROR + + if (addr.y && addr.y >= screenHeight) + return 0; // out of range + + inProgress = true; + + int numcols = JD_SERIAL_PAYLOAD_SIZE / (height / 2); + + bytesPerTransfer = numcols * (height / 2); + dataLeft = (height / 2) * width; + dataPtr = src; + + this->palette = palette; + + memset(&sendFrame, 0, sizeof(sendFrame)); + + step(); + + return 0; +} + +} // namespace pxt \ No newline at end of file diff --git a/cpp/jddisplay.h b/cpp/jddisplay.h new file mode 100644 index 0000000..f9626d3 --- /dev/null +++ b/cpp/jddisplay.h @@ -0,0 +1,67 @@ +#ifndef __JDDISPLAY_H +#define __JDDISPLAY_H + +#include "pxt.h" + +#include "Pin.h" +#define PinCompat codal::Pin + +#undef SPI +#include "jdprotocol.h" +#include "arcadegamepad.h" +#include "indexedscreen.h" +#include "arcadesound.h" + +namespace pxt { + +class JDDisplay { + jd_indexed_screen_start_update_t addr; + SPI *spi; + Pin *cs; + Pin *flow; + uint32_t dataLeft; + const uint8_t *dataPtr; + uint32_t *palette; + jd_frame_t sendFrame; + jd_frame_t recvFrame; + uint8_t bytesPerTransfer; + bool inProgress; + volatile bool stepWaiting; + uint8_t displayServiceNum; + uint8_t controlsStartServiceNum; + uint8_t controlsEndServiceNum; + uint8_t soundServiceNum; + uint16_t screenWidth, screenHeight; + uint32_t buttonState; + uint32_t avgFrameTime; // in us + uint32_t lastFrameTimestamp; + + uint32_t soundBufferDesiredSize; + uint32_t soundBufferPending; + uint16_t soundSampleRate; + + void *queuePkt(uint32_t service_num, uint32_t service_cmd, uint32_t size); + void flushSend(); + void step(); + void sendDone(Event); + static void stepStatic(void *); + void onFlowHi(Event); + void handleIncoming(jd_packet_t *pkt); + + public: + uint8_t brightness; + JDDisplay(SPI *spi, Pin *cs, Pin *flow); + void setAddrWindow(int x, int y, int w, int h) { + addr.x = x; + addr.y = y; + addr.width = w; + addr.height = h; + } + void waitForSendDone(); + + int sendIndexedImage(const uint8_t *src, unsigned width, unsigned height, uint32_t *palette); +}; + +} // namespace pxt + +#endif diff --git a/cpp/jdprotocol.h b/cpp/jdprotocol.h new file mode 100644 index 0000000..8d81c48 --- /dev/null +++ b/cpp/jdprotocol.h @@ -0,0 +1,125 @@ +#ifndef __JDPROTOCOL_H +#define __JDPROTOCOL_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// 255 minus size of the serial header, rounded down to 4 +#define JD_SERIAL_PAYLOAD_SIZE 236 +#define JD_SERIAL_FULL_HEADER_SIZE 16 + +#define JD_SERVICE_CLASS_CTRL 0x00000000 + +#define JD_SERVICE_NUMBER_CTRL 0x00 +#define JD_SERVICE_NUMBER_MASK 0x3f +#define JD_SERVICE_NUMBER_CRC_ACK 0x3f + +// the COMMAND flag signifies that the device_identifier is the recipent +// (i.e., it's a command for the peripheral); the bit clear means device_identifier is the source +// (i.e., it's a report from peripheral or a broadcast message) +#define JD_FRAME_FLAG_COMMAND 0x01 +// an ACK should be issued with CRC of this package upon reception +#define JD_FRAME_FLAG_ACK_REQUESTED 0x02 +// the device_identifier contains target service class number +#define JD_FRAME_FLAG_IDENTIFIER_IS_SERVICE_CLASS 0x04 + +#define JD_FRAME_SIZE(pkt) ((pkt)->size + 12) + +// Registers 0x001-0x07f - r/w common to all services +// Registers 0x080-0x0ff - r/w defined per-service +// Registers 0x100-0x17f - r/o common to all services +// Registers 0x180-0x1ff - r/o defined per-service +// Registers 0x200-0xeff - custom, defined per-service +// Registers 0xf00-0xfff - reserved for implementation, should not be on the wire + +// this is either binary (0 or non-zero), or can be gradual (eg. brightness of neopixel) +#define JD_REG_INTENSITY 0x01 +// the primary value of actuator (eg. servo angle) +#define JD_REG_VALUE 0x02 +// enable/disable streaming +#define JD_REG_IS_STREAMING 0x03 +// streaming interval in miliseconds +#define JD_REG_STREAMING_INTERVAL 0x04 +// for analog sensors +#define JD_REG_LOW_THRESHOLD 0x05 +#define JD_REG_HIGH_THRESHOLD 0x06 +// limit power drawn; in mA +#define JD_REG_MAX_POWER 0x07 + +// eg. one number for light sensor, all 3 coordinates for accelerometer +#define JD_REG_READING 0x101 + +#define JD_CMD_GET_REG 0x1000 +#define JD_CMD_SET_REG 0x2000 + +#define JD_GET(reg) (JD_CMD_GET_REG | (reg)) +#define JD_SET(reg) (JD_CMD_SET_REG | (reg)) + +// Commands 0x000-0x07f - common to all services +// Commands 0x080-0xeff - defined per-service +// Commands 0xf00-0xfff - reserved for implementation +// enumeration data for CTRL, ad-data for other services +#define JD_CMD_ADVERTISEMENT_DATA 0x00 +// event from sensor or on broadcast service +#define JD_CMD_EVENT 0x01 +// request to calibrate sensor +#define JD_CMD_CALIBRATE 0x02 +// request human-readable description of service +#define JD_CMD_GET_DESCRIPTION 0x03 + +// Commands specific to control service +// do nothing +#define JD_CMD_CTRL_NOOP 0x80 +// blink led or otherwise draw user's attention +#define JD_CMD_CTRL_IDENTIFY 0x81 +// reset device +#define JD_CMD_CTRL_RESET 0x82 +// identifies the type of hardware (eg., ACME Corp. Servo X-42 Rev C) +#define JD_REG_CTRL_DEVICE_DESCRIPTION 0x180 +// a numeric code for the string above; used to mark firmware images +#define JD_REG_CTRL_DEVICE_CLASS 0x181 +// MCU temperature in Celsius +#define JD_REG_CTRL_TEMPERATURE 0x182 +// this is very approximate; ADC reading from backward-biasing the identification LED +#define JD_REG_CTRL_LIGHT_LEVEL 0x183 +// typically the same as JD_REG_CTRL_DEVICE_CLASS; the bootloader will respond to that code +#define JD_REG_CTRL_BL_DEVICE_CLASS 0x184 + +struct _jd_packet_t { + uint16_t crc; + uint8_t _size; // of frame data[] + uint8_t flags; + + uint64_t device_identifier; + + uint8_t service_size; + uint8_t service_number; + uint16_t service_command; + + uint8_t data[0]; +} __attribute__((__packed__, aligned(4))); +typedef struct _jd_packet_t jd_packet_t; + +struct _jd_frame_t { + uint16_t crc; + uint8_t size; + uint8_t flags; + + uint64_t device_identifier; + + uint8_t data[JD_SERIAL_PAYLOAD_SIZE + 4]; +} __attribute__((__packed__, aligned(4))); +typedef struct _jd_frame_t jd_frame_t; + +#define JDSPI_MAGIC 0x7ACD +#define JDSPI_MAGIC_NOOP 0xB3CD + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cpp/pins.cpp b/cpp/pins.cpp new file mode 100644 index 0000000..01289ad --- /dev/null +++ b/cpp/pins.cpp @@ -0,0 +1,71 @@ +#include "pxt.h" + +#include "Pin.h" +#define PinCompat codal::Pin + +#include "config_nrf.h" + +// #undef Button + +namespace pxt { +static DevicePin **pinPtrs; +static uint8_t numPinPtrs; +static uint8_t pinPos[DEV_NUM_PINS]; + +DevicePin *myGetPin(int id) { + + id &= CFG_PIN_NAME_MSK; + + if (id >= DEV_NUM_PINS) + soft_panic(PANIC_NO_SUCH_PIN); + + // we could use lookupComponent() here - it would be slightly slower + + int ptr = pinPos[id]; + if (ptr == 0) { + pinPtrs = (DevicePin **)realloc(pinPtrs, (numPinPtrs + 1) * sizeof(void *)); + bool isAnalog = IS_ANALOG_PIN(id); + // GCTODO + pinPtrs[numPinPtrs++] = + new DevicePin(DEVICE_ID_IO_P0 + id, (PinName)id, + isAnalog ? PIN_CAPABILITY_AD : PIN_CAPABILITY_DIGITAL); + ptr = numPinPtrs; + pinPos[id] = ptr; + } + return pinPtrs[ptr - 1]; +} + +DevicePin *getPinCfg(int key) { + int p = getConfig(key, -1); + if (p == -1) + DMESG("no pin cfg: %d", key); + return myGetPin(p); +} + +void linkPin(int from, int to) { + if (from < 0 || from >= DEV_NUM_PINS) + soft_panic(PANIC_NO_SUCH_PIN); + myGetPin(to); + pinPos[from] = pinPos[to]; +} + +DevicePin *myLookupPin(int pinName) { + if (pinName < 0 || pinName == 0xff) + return NULL; + pinName &= CFG_PIN_NAME_MSK; + return myGetPin(pinName); +} + +DevicePin *lookupPinCfg(int key) { + return myLookupPin(getConfig(key)); +} + +CodalComponent *lookupComponent(int id) { + for (int i = 0; i < DEVICE_COMPONENT_COUNT; ++i) { + if (CodalComponent::components[i] && CodalComponent::components[i]->id == id) + return CodalComponent::components[i]; + } + return NULL; +} + +} // namespace pxt diff --git a/cpp/pinsDigital.cpp b/cpp/pinsDigital.cpp new file mode 100644 index 0000000..042a986 --- /dev/null +++ b/cpp/pinsDigital.cpp @@ -0,0 +1,142 @@ +#include "pxt.h" + +#include "Pin.h" +#define PinCompat codal::Pin + +#include "config_nrf.h" + +namespace pxt { + +static void waitABit() { + // for (int i = 0; i < 10; ++i) + // asm volatile("nop"); +} + +class ButtonMultiplexer : public CodalComponent { + public: + Pin &latch; + Pin &clock; + Pin &data; + uint32_t state; + uint32_t invMask; + uint16_t buttonIdPerBit[8]; + bool enabled; + + ButtonMultiplexer(uint16_t id) + : latch(uBit.io.P9), + clock(uBit.io.P20), + data((uBit.io.P14)) { + this->id = id; + this->status |= DEVICE_COMPONENT_STATUS_SYSTEM_TICK; + + state = 0; + invMask = 0; + enabled = true; + + memset(buttonIdPerBit, 0, sizeof(buttonIdPerBit)); + + data.setPull(PullMode::Down); + data.getDigitalValue(); + latch.setDigitalValue(1); + clock.setDigitalValue(1); + } + + void disable() { + data.getDigitalValue(PullMode::None); + latch.getDigitalValue(PullMode::None); + clock.getDigitalValue(PullMode::None); + enabled = false; + } + + bool isButtonPressed(int id) { + for (int i = 0; i < 8; ++i) { + if (buttonIdPerBit[i] == id) + return (state & (1 << i)) != 0; + } + return false; + } + + uint32_t readBits(int bits) { + latch.setDigitalValue(0); + waitABit(); + latch.setDigitalValue(1); + waitABit(); + + uint32_t state = 0; + for (int i = 0; i < bits; i++) { + state <<= 1; + if (data.getDigitalValue()) + state |= 1; + + clock.setDigitalValue(0); + waitABit(); + clock.setDigitalValue(1); + waitABit(); + } + + return state; + } + + virtual void periodicCallback() override { + if (!enabled) + return; + + uint32_t newState = readBits(8); + newState ^= invMask; + if (newState == state) + return; + + for (int i = 0; i < 8; ++i) { + uint32_t mask = 1 << i; + if (!buttonIdPerBit[i]) + continue; + int ev = 0; + if (!(state & mask) && (newState & mask)) + ev = PXT_INTERNAL_KEY_DOWN; + else if ((state & mask) && !(newState & mask)) + ev = PXT_INTERNAL_KEY_UP; + if (ev) { + Event(ev, buttonIdPerBit[i]); + Event(ev, 0); // any key + } + } + + state = newState; + } +}; + +static ButtonMultiplexer *btnMultiplexer; +ButtonMultiplexer *getMultiplexer() { + if (!btnMultiplexer) + btnMultiplexer = new ButtonMultiplexer(DEVICE_ID_FIRST_BUTTON); + return btnMultiplexer; +} + +int registerMultiplexedButton(int pin, int buttonId) { + if (1050 <= pin && pin < 1058) { + pin -= 50; + getMultiplexer()->invMask |= 1 << (pin - 1000); + } + if (1000 <= pin && pin < 1008) { + getMultiplexer()->buttonIdPerBit[pin - 1000] = buttonId; + return 1; + } + return 0; +} + +int multiplexedButtonIsPressed(int btnId) { + if (btnMultiplexer) + return btnMultiplexer->isButtonPressed(btnId) ? 512 : 0; + return 0; +} + +uint32_t readButtonMultiplexer(int bits) { + return getMultiplexer()->readBits(bits); +} + +void disableButtonMultiplexer() { + getMultiplexer()->disable(); +} + +} + diff --git a/cpp/pxt.json b/cpp/pxt.json new file mode 100644 index 0000000..fac8df7 --- /dev/null +++ b/cpp/pxt.json @@ -0,0 +1,39 @@ +{ + "name": "arcadeshield", + "description": "Support for the Arcade Shield. micro:bit (V2) only.", + "dependencies": { + "core": "file:../core", + "bitmap": "file:../bitmap", + "fonts": "file:../fonts" + }, + "files": [ + "config_nrf.h", + "arcadegamepad.h", + "indexedscreen.h", + "arcadesound.h", + "jdprotocol.h", + "jddisplay.h", + "jddisplay.cpp", + "pins.cpp", + "pinsDigital.cpp", + "controllerbuttons.cpp", + "screen.cpp", + "screenhelpers.d.ts", + "shims.d.ts" + ], + "test": [ + "test.ts" + ], + "public": true, + "hidden": true, + "preferredEditor": "tsprj", + "disablesVariants": [ + "mbdal" + ], + "yotta": { + "config": { + "DEVICE_BLE": 0, + "DMESG_SERIAL_DEBUG": 1 + } + } +} diff --git a/cpp/screen.cpp b/cpp/screen.cpp new file mode 100644 index 0000000..7307847 --- /dev/null +++ b/cpp/screen.cpp @@ -0,0 +1,348 @@ +#include "pxt.h" + +#include "Pin.h" +#define PinCompat codal::Pin + +#include "ST7735.h" +#include "ILI9341.h" + +// this is a hack because someone (don't know where) #defined SPI to be NRF52SPI, +// which messes with the include file below the #undef +#undef SPI +#include "SPIScreenIO.h" + +#include "jddisplay.h" + +#include "config_nrf.h" + +typedef RefImage *Bitmap_; + +namespace pxt { + +class WDisplay { + public: + ScreenIO *io; + ST7735 *lcd; + JDDisplay *smart; + + uint32_t currPalette[16]; + bool present; + bool newPalette; + bool inUpdate; + uint8_t *screenBuf; + + uint16_t width, height; + uint16_t displayHeight; + uint8_t offX, offY; + bool doubleSize; + uint32_t palXOR; + + WDisplay() { + uint32_t cfg2 = MY_DISPLAY_CFG2; + + uint32_t cfg0 = MY_DISPLAY_CFG0; + uint32_t frmctr1 = MY_DISPLAY_CFG1; + + int dispTp = MY_DISPLAY_TYPE; + + doubleSize = false; + smart = NULL; + + auto miso = LOOKUP_PIN(DISPLAY_MISO); + dispTp = smartConfigure(&cfg0, &frmctr1, &cfg2); + + if (dispTp != DISPLAY_TYPE_SMART) + miso = NULL; // only JDDisplay needs MISO, otherwise leave free + + SPI *spi = new CODAL_SPI(*LOOKUP_PIN(DISPLAY_MOSI), *miso, *LOOKUP_PIN(DISPLAY_SCK)); + io = new SPIScreenIO(*spi); + + if (dispTp == DISPLAY_TYPE_ST7735) { + width = 160; + height = 128; + lcd = new ST7735(*io, *LOOKUP_PIN(DISPLAY_CS), *LOOKUP_PIN(DISPLAY_DC)); + } else if (dispTp == DISPLAY_TYPE_SMART) { + lcd = NULL; + width = 160; + height = 120; + smart = new JDDisplay(spi, LOOKUP_PIN(DISPLAY_CS), LOOKUP_PIN(DISPLAY_DC)); + } else + target_panic(128); // PANIC_SCREEN_ERROR + + palXOR = (cfg0 & 0x1000000) ? 0xffffff : 0x000000; + auto madctl = cfg0 & 0xff; + offX = (cfg0 >> 8) & 0xff; + offY = (cfg0 >> 16) & 0xff; + + DMESG("configure screen: FRMCTR1=%p MADCTL=%p type=%d", frmctr1, madctl, dispTp); + + if (spi) { + auto freq = (cfg2 & 0xff); + if (!freq) + freq = 15; + spi->setFrequency(freq * 1000000); + spi->setMode(0); + // make sure the SPI peripheral is initialized before toggling reset + spi->write(0); + } + + auto rst = LOOKUP_PIN(DISPLAY_RST); + if (rst) { + rst->setDigitalValue(0); + fiber_sleep(20); + rst->setDigitalValue(1); + fiber_sleep(20); + } + + if (lcd) { + auto bl = LOOKUP_PIN(DISPLAY_BL); + if (bl) { + bl->setDigitalValue(1); + } + + lcd->init(); + lcd->configure(madctl, frmctr1); + } + + displayHeight = height; + setAddrMain(); + DMESG("screen: %d x %d, off=%d,%d", width, height, offX, offY); + int sz = doubleSize ? (width >> 1) * (height >> 1) : width * height; + screenBuf = (uint8_t *)app_alloc(sz / 2 + 20); + inUpdate = false; + } + + uint32_t smartConfigure(uint32_t *cfg0, uint32_t *cfg1, uint32_t *cfg2) { + uint32_t hc; + present = false; + + DMESG("74HC: waiting..."); + + // wait while nothing is connected + for (;;) { + auto rst = LOOKUP_PIN(DISPLAY_RST); + if (rst) { + rst->setDigitalValue(0); + target_wait_us(10); + rst->setDigitalValue(1); + fiber_sleep(3); // in reality we need around 1.2ms + } + + hc = readButtonMultiplexer(17); + if (hc != 0) + break; + + fiber_sleep(100); + + // the device will run without shield when the following is specified in user program: + // namespace userconfig { export const DISPLAY_CFG0 = 0x02000080 } + if (*cfg0 & 0x2000000) { + DMESG("74HC: no wait requested"); + return DISPLAY_TYPE_ST7735; + } + } + present = true; + + DMESG("74HC: %x", hc); + + // is the line forced up? if so, assume JDDisplay + if (hc == 0x1FFFF) { + disableButtonMultiplexer(); + return DISPLAY_TYPE_SMART; + } + + hc = hc >> 1; + + // SER pin (or first bit of second HC) is orientation + if (hc & 0x0010) + *cfg0 = 0x80; + else + *cfg0 = 0x40; + + uint32_t configId = (hc & 0xe0) >> 5; + + + switch (configId) { + case 1: + *cfg1 = 0x0603; // ST7735 + break; + case 2: + *cfg1 = 0xe14ff; // ILI9163C + *cfg0 |= 0x08; // BGR colors + break; + case 3: + *cfg1 = 0x0603; // ST7735 + *cfg0 |= 0x1000000; // inverted colors + break; + default: + target_panic(129); // PANIC_SCREEN_ERROR + break; + } + + DMESG("config type: %d; cfg0=%x cfg1=%x", configId, *cfg0, *cfg1); + + // for some reason, setting SPI frequency to 32 doesn't + // work with ST77735 in pxt-microbit + *cfg2 = 16; // Damn the torpedoes! 32MHz + + return DISPLAY_TYPE_ST7735; + } + + void setAddrMain() { + if (lcd) + lcd->setAddrWindow(offX, offY, width, displayHeight); + else + smart->setAddrWindow(offX, offY, width, displayHeight); + } + void waitForSendDone() { + if (lcd) + lcd->waitForSendDone(); + else + smart->waitForSendDone(); + } + int sendIndexedImage(const uint8_t *src, unsigned width, unsigned height, uint32_t *palette) { + if (lcd) + return lcd->sendIndexedImage(src, width, height, palette); + else + return smart->sendIndexedImage(src, width, height, palette); + } +}; + +SINGLETON_IF_PIN(WDisplay, DISPLAY_MOSI); + +//% +int setScreenBrightnessSupported() { + auto display = getWDisplay(); + if (display && display->smart) + return 1; + + auto bl = LOOKUP_PIN(DISPLAY_BL); + if (!bl) + return 0; +#ifdef SAMD51 + if (bl->name == PA06) + return 0; +#endif +#ifdef NRF52_SERIES + // PWM not implemented yet + return 0; +#else + return 1; +#endif +} + +//% +void setScreenBrightness(int level) { + if (level < 0) + level = 0; + if (level > 100) + level = 100; + + auto display = getWDisplay(); + if (display && display->smart) { + display->smart->brightness = level; + return; + } + + auto bl = LOOKUP_PIN(DISPLAY_BL); + if (!bl) + return; + + if (level == 0) + bl->setDigitalValue(0); + else if (level == 100) + bl->setDigitalValue(1); + else { + if (setScreenBrightnessSupported()) { + bl->setAnalogPeriodUs(1000); + bl->setAnalogValue(level * level * 1023 / 10000); + } + } +} + +//% +void setPalette(Buffer buf) { + auto display = getWDisplay(); + if (!display) + return; + + if (48 != buf->length) + target_panic(130); // PANIC_SCREEN_ERROR + for (int i = 0; i < 16; ++i) { + display->currPalette[i] = + (buf->data[i * 3] << 16) | (buf->data[i * 3 + 1] << 8) | (buf->data[i * 3 + 2] << 0); + display->currPalette[i] ^= display->palXOR; + } + display->newPalette = true; +} + +//% +bool displayPresent() { + auto display = getWDisplay(); + if (!display) + return false; + return display->present; +} + +//% +int displayHeight() { + auto display = getWDisplay(); + if (!display) + return -1; + return display->displayHeight; +} + +//% +int displayWidth() { + auto display = getWDisplay(); + if (!display) + return -1; + return display->width; +} + +//% +void updateScreen(Bitmap_ img) { + auto display = getWDisplay(); + if (!display) + return; + + if (display->inUpdate) + return; + + display->inUpdate = true; + + auto mult = display->doubleSize ? 2 : 1; + + if (img) { + if (img->bpp() != 4 || img->width() * mult != display->width || + img->height() * mult != display->displayHeight) + target_panic(131); // PANIC_SCREEN_ERROR + + // DMESG("wait for done"); + display->waitForSendDone(); + + auto palette = display->currPalette; + + if (display->newPalette) { + display->newPalette = false; + } else { + // smart mode always sends palette + if (!display->smart) + palette = NULL; + } + + memcpy(display->screenBuf, img->pix(), img->pixLength()); + + // DMESG("send"); + display->sendIndexedImage(display->screenBuf, img->width(), img->height(), palette); + } + + display->inUpdate = false; +} + +//% +void updateStats(String msg) { + // ignore... +} + +} // namespace pxt \ No newline at end of file diff --git a/cpp/screenhelpers.d.ts b/cpp/screenhelpers.d.ts new file mode 100644 index 0000000..7495f5d --- /dev/null +++ b/cpp/screenhelpers.d.ts @@ -0,0 +1,14 @@ +declare namespace __screenhelpers { + //% shim=pxt::displayPresent + function displayPresent(): boolean; + //% shim=pxt::setPalette + function setPalette(buf: Buffer): void; + //% shim=pxt::displayWidth + function displayWidth(): number; + //% shim=pxt::displayHeight + function displayHeight(): number; + //% shim=pxt::setScreenBrightness + function setScreenBrightness(b: number): void; + //% shim=pxt::updateScreen + function updateScreen(bmp: Bitmap): void; +} diff --git a/cpp/shims.d.ts b/cpp/shims.d.ts new file mode 100644 index 0000000..3c20787 --- /dev/null +++ b/cpp/shims.d.ts @@ -0,0 +1,159 @@ +// Auto-generated. Do not edit. + + +declare interface Bitmap { + /** + * Get underlying buffer + */ + //% property shim=BitmapMethods::__buffer + __buffer: Buffer; + + /** + * Get the width of the bitmap + */ + //% property shim=BitmapMethods::width + width: int32; + + /** + * Get the height of the bitmap + */ + //% property shim=BitmapMethods::height + height: int32; + + /** + * True if the bitmap is monochromatic (black and white) + */ + //% property shim=BitmapMethods::isMono + isMono: boolean; + + /** + * Sets all pixels in the current bitmap from the other bitmap, which has to be of the same size and + * bpp. + */ + //% shim=BitmapMethods::copyFrom + copyFrom(from: Bitmap): void; + + /** + * Set pixel color + */ + //% shim=BitmapMethods::setPixel + setPixel(x: int32, y: int32, c: int32): void; + + /** + * Get a pixel color + */ + //% shim=BitmapMethods::getPixel + getPixel(x: int32, y: int32): int32; + + /** + * Fill entire bitmap with a given color + */ + //% shim=BitmapMethods::fill + fill(c: int32): void; + + /** + * Copy row(s) of pixel from bitmap to buffer (8 bit per pixel). + */ + //% shim=BitmapMethods::getRows + getRows(x: int32, dst: Buffer): void; + + /** + * Copy row(s) of pixel from buffer to bitmap. + */ + //% shim=BitmapMethods::setRows + setRows(x: int32, src: Buffer): void; + + /** + * Return a copy of the current bitmap + */ + //% shim=BitmapMethods::clone + clone(): Bitmap; + + /** + * Flips (mirrors) pixels horizontally in the current bitmap + */ + //% shim=BitmapMethods::flipX + flipX(): void; + + /** + * Flips (mirrors) pixels vertically in the current bitmap + */ + //% shim=BitmapMethods::flipY + flipY(): void; + + /** + * Returns a transposed bitmap (with X/Y swapped) + */ + //% shim=BitmapMethods::transposed + transposed(): Bitmap; + + /** + * Every pixel in bitmap is moved by (dx,dy) + */ + //% shim=BitmapMethods::scroll + scroll(dx: int32, dy: int32): void; + + /** + * Stretches the bitmap horizontally by 100% + */ + //% shim=BitmapMethods::doubledX + doubledX(): Bitmap; + + /** + * Stretches the bitmap vertically by 100% + */ + //% shim=BitmapMethods::doubledY + doubledY(): Bitmap; + + /** + * Replaces one color in an bitmap with another + */ + //% shim=BitmapMethods::replace + replace(from: int32, to: int32): void; + + /** + * Stretches the bitmap in both directions by 100% + */ + //% shim=BitmapMethods::doubled + doubled(): Bitmap; + + /** + * Draw given bitmap on the current bitmap + */ + //% shim=BitmapMethods::drawBitmap + drawBitmap(from: Bitmap, x: int32, y: int32): void; + + /** + * Draw given bitmap with transparent background on the current bitmap + */ + //% shim=BitmapMethods::drawTransparentBitmap + drawTransparentBitmap(from: Bitmap, x: int32, y: int32): void; + + /** + * Check if the current bitmap "collides" with another + */ + //% shim=BitmapMethods::overlapsWith + overlapsWith(other: Bitmap, x: int32, y: int32): boolean; +} +declare namespace bitmaps { + + /** + * Create new bitmap with given content + */ + //% shim=bitmaps::ofBuffer + function ofBuffer(buf: Buffer): Bitmap; + + /** + * Create new empty (transparent) bitmap + */ + //% shim=bitmaps::create + function create(width: int32, height: int32): Bitmap; + + /** + * Double the size of an icon + */ + //% shim=bitmaps::doubledIcon + function doubledIcon(icon: Buffer): Buffer; +} + +// Auto-generated. Do not edit. Really. diff --git a/cpp/test.ts b/cpp/test.ts new file mode 100644 index 0000000..de610e9 --- /dev/null +++ b/cpp/test.ts @@ -0,0 +1,29 @@ +// tests go here; this will not be compiled when this package is used as an extension. + +const present = __screenhelpers.displayPresent(); +basic.showNumber(present ? 1 : 0) + +// set palette before creating screen, which initializes the display +__screenhelpers.setPalette(hex`000000ffffffff2121ff93c4ff8135fff609249ca378dc52003fad87f2ff8e2ec4a4839f5c406ce5cdc491463d000000`) + +const screen = bitmaps.create( + __screenhelpers.displayWidth(), + __screenhelpers.displayHeight() +) + +input.onButtonPressed(Button.A, () => { + screen.fill(2) + screen.drawLine(0,0,100,100,0) + __screenhelpers.updateScreen(screen) +}) + +input.onButtonPressed(Button.B, () => { + screen.fill(4) + screen.drawLine(100,0,0,100,0) + __screenhelpers.updateScreen(screen) +}) + +input.onButtonPressed(Button.AB, () => { + screen.fill(0) + __screenhelpers.updateScreen(screen) +}) diff --git a/pxt.json b/pxt.json index 0583c8d..6dd5143 100644 --- a/pxt.json +++ b/pxt.json @@ -6,7 +6,7 @@ "core": "*", "radio": "*", "microphone": "*", - "arcadeshield": "*", + "bitmap": "*", "fonts": "*" }, "files": [ @@ -24,6 +24,17 @@ "ns.ts", "shieldhelpers.ts", "text.ts", + "cpp/config_nrf.h", + "cpp/arcadegamepad.h", + "cpp/indexedscreen.h", + "cpp/arcadesound.h", + "cpp/jdprotocol.h", + "cpp/jddisplay.h", + "cpp/jddisplay.cpp", + "cpp/pins.cpp", + "cpp/pinsDigital.cpp", + "cpp/controllerbuttons.cpp", + "cpp/screen.cpp", "docs/clone.md", "docs/draw-line.md", "docs/draw-rect.md", @@ -54,6 +65,15 @@ "supportedTargets": [ "microbit" ], + "disablesVariants": [ + "mbdal" + ], + "yotta": { + "config": { + "DEVICE_BLE": 0, + "DMESG_SERIAL_DEBUG": 1 + } + }, "preferredEditor": "tsprj", "tests": [ "test.ts" @@ -75,8 +95,5 @@ "#e5cdc4", "#91463d", "#000000" - ], - "disablesVariants": [ - "mbdal" ] } From fa0b267b9ca8ea8fd1a28978b9b107f715ec994c Mon Sep 17 00:00:00 2001 From: Thomas Ball Date: Tue, 31 Dec 2024 21:01:15 +0000 Subject: [PATCH 02/16] is this really working? --- pxt.json | 1 + 1 file changed, 1 insertion(+) diff --git a/pxt.json b/pxt.json index 6dd5143..21ce430 100644 --- a/pxt.json +++ b/pxt.json @@ -35,6 +35,7 @@ "cpp/pinsDigital.cpp", "cpp/controllerbuttons.cpp", "cpp/screen.cpp", + "cpp/screenhelpers.d.ts", "docs/clone.md", "docs/draw-line.md", "docs/draw-rect.md", From baef52183c12ca022b4cd7ad429d44f95df93498 Mon Sep 17 00:00:00 2001 From: Thomas Ball Date: Tue, 31 Dec 2024 21:20:27 +0000 Subject: [PATCH 03/16] move pic to assets --- README.md | 2 +- simx/public/assets/shieldSim.png | Bin 0 -> 187717 bytes 2 files changed, 1 insertion(+), 1 deletion(-) create mode 100644 simx/public/assets/shieldSim.png diff --git a/README.md b/README.md index cb1de64..95e5518 100644 --- a/README.md +++ b/README.md @@ -74,7 +74,7 @@ D-pad, see arrow buttons). Blocks for the shield are under the toolbox categories `Controller` and `Drawing` and are described further below. -![MakeCode with Arcade Shield Simulator](./assets/shieldSim.png) +![MakeCode with Arcade Shield Simulator](https://microbit-apps.github.io/pxt-arcadeshield/assets/shieldSim.png) ## Blocks diff --git a/simx/public/assets/shieldSim.png b/simx/public/assets/shieldSim.png new file mode 100644 index 0000000000000000000000000000000000000000..31ca930ad909427da379229da5a97408285016e7 GIT binary patch literal 187717 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 z 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%0D6# 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 literal 0 HcmV?d00001 From b15b42b18b33c1015f023595116472ef8c376073 Mon Sep 17 00:00:00 2001 From: Thomas Ball Date: Tue, 31 Dec 2024 21:40:40 +0000 Subject: [PATCH 04/16] some documentation --- README.md | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 95e5518..f329fbc 100644 --- a/README.md +++ b/README.md @@ -101,7 +101,21 @@ Display present/absent ```blocks ``` -### Drawing with bitmaps +### Drawing into the screen bitmap + +The screen is 160 pixels wide and 120 pixels high. The upper +left of the screen is coordinate (0,0); The lower right of +the screen is coordinate (159,119). We draw two lines to +show the four corners of the screen: + +```blocks +screen().drawLine(0, 0, 159, 119, 2) +screen().drawLine(159, 0, 0, 119, 5) +``` + + +### Creating your own bitmaps + ## TypeScript APIs From e7d93ea78ad8baffd8d524b8fe8855f903069c9d Mon Sep 17 00:00:00 2001 From: Thomas Ball Date: Tue, 31 Dec 2024 21:54:59 +0000 Subject: [PATCH 05/16] some more doc --- README.md | 39 +++++++++++++++++++++++++++++++++++---- 1 file changed, 35 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index f329fbc..2298a13 100644 --- a/README.md +++ b/README.md @@ -103,16 +103,47 @@ Display present/absent ### Drawing into the screen bitmap -The screen is 160 pixels wide and 120 pixels high. The upper -left of the screen is coordinate (0,0); The lower right of -the screen is coordinate (159,119). We draw two lines to -show the four corners of the screen: +#### Screen coordinates and lines + +The screen bitmap is 160 pixels wide and 120 pixels high. +The upper left of the screen is coordinate (0,0); The lower +right of the screen is coordinate (159,119). We draw two lines +to the screen bitmap to show the four corners of the screen: ```blocks screen().drawLine(0, 0, 159, 119, 2) screen().drawLine(159, 0, 0, 119, 5) ``` +#### Screen center and setting a pixel + +Since the width and height of the screen are both even, the center of +the screen is bounded by these four pixels: +``` +screen().setPixel(79, 59, 1) +screen().setPixel(80, 59, 1) +screen().setPixel(79, 60, 1) +screen().setPixel(80, 60, 1) +``` + +#### Fixed point arithmetic + +You can pass floating point numbers to any drawing command that takes +a coordinate. The underlying representation is fixed point in the MakeCode +runtime. Fractional values are ignored when setting a pixel in a bitmap, so + +```blocks +screen().setPixel(79.6, 59.6, 1) +``` +has the same effect as +```blocks +screen().setPixel(79.4, 59.4, 1) +``` +which has the same effect as +```blocks +screen().setPixel(79, 59, 1) +``` + ### Creating your own bitmaps From 9ced5e553d01482526286a14bb21f44f588b5dfa Mon Sep 17 00:00:00 2001 From: Thomas Ball Date: Tue, 31 Dec 2024 22:08:21 +0000 Subject: [PATCH 06/16] more stuff --- README.md | 38 +++++++++++++++++++++++++++++++------- 1 file changed, 31 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 2298a13..fabc2b5 100644 --- a/README.md +++ b/README.md @@ -115,10 +115,11 @@ screen().drawLine(0, 0, 159, 119, 2) screen().drawLine(159, 0, 0, 119, 5) ``` -#### Screen center and setting a pixel +#### Screen center, setting a pixel, and floating point Since the width and height of the screen are both even, the center of -the screen is bounded by these four pixels: +the screen is bounded by these four pixels, as shown by the following +four commands that each draw a single pixel: ``` screen().setPixel(79, 59, 1) screen().setPixel(80, 59, 1) @@ -126,12 +127,10 @@ screen().setPixel(79, 60, 1) screen().setPixel(80, 60, 1) ``` -#### Fixed point arithmetic - You can pass floating point numbers to any drawing command that takes -a coordinate. The underlying representation is fixed point in the MakeCode -runtime. Fractional values are ignored when setting a pixel in a bitmap, so - +a coordinate. For efficiency, the underlying representation is fixed point +in the MakeCode runtime. Fractional values are ignored when setting a pixel +in a bitmap, so ```blocks screen().setPixel(79.6, 59.6, 1) ``` @@ -143,10 +142,35 @@ which has the same effect as ```blocks screen().setPixel(79, 59, 1) ``` +#### Getting a pixel's (color index) value + +The following code will show a 2 on the micro:bit screen, as this is the color index +stored in the pixel: +```blocks +screen().setPixel(80, 60, 2) +basic.showNumber(screen().getPixel(80, 60)) +} +``` +So we can see that each pixel is like a variable that stores a value (in the range 0-15) +that can later be retrieved. + +#### Drawing shapes + +Draw + +- rectangle +- circle +- triangle + +Fill ### Creating your own bitmaps +#### bitmap editor +#### bitmap as hex literal + +### Drawing a bitmap onto the screen ## TypeScript APIs From 00f049519f5440da05d3097b8dc6613cdf3e470c Mon Sep 17 00:00:00 2001 From: Thomas Ball Date: Thu, 2 Jan 2025 21:44:41 +0000 Subject: [PATCH 07/16] more on drawing --- README.md | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/README.md b/README.md index fabc2b5..7c6d8fe 100644 --- a/README.md +++ b/README.md @@ -115,6 +115,22 @@ screen().drawLine(0, 0, 159, 119, 2) screen().drawLine(159, 0, 0, 119, 5) ``` +### Drawing out of bounds + +You don't need to worry (for any drawing command) about drawing off +the screen. So, for example, +```blocks +screen().drawLine(-10,10,10,10,2) +``` +has the same effect as +```blocks +screen().drawLine(0,0,10,10,2) +``` +While the following code won't display anything on the screen at all: +```blocks +screen().drawLine(-1,=1,-10,-10,2) +``` + #### Screen center, setting a pixel, and floating point Since the width and height of the screen are both even, the center of From 95915e65aee3dc956605bc70d8f8b687f0c8f667 Mon Sep 17 00:00:00 2001 From: Thomas Ball Date: Thu, 2 Jan 2025 21:44:56 +0000 Subject: [PATCH 08/16] fix --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 7c6d8fe..ba33d17 100644 --- a/README.md +++ b/README.md @@ -128,7 +128,7 @@ screen().drawLine(0,0,10,10,2) ``` While the following code won't display anything on the screen at all: ```blocks -screen().drawLine(-1,=1,-10,-10,2) +screen().drawLine(-1,-1,-10,-10,2) ``` #### Screen center, setting a pixel, and floating point From c728999ca6b4a088118a84b622c323420fd66f59 Mon Sep 17 00:00:00 2001 From: Thomas Ball Date: Thu, 2 Jan 2025 21:47:57 +0000 Subject: [PATCH 09/16] typo --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index ba33d17..ebd7fc6 100644 --- a/README.md +++ b/README.md @@ -120,7 +120,7 @@ screen().drawLine(159, 0, 0, 119, 5) You don't need to worry (for any drawing command) about drawing off the screen. So, for example, ```blocks -screen().drawLine(-10,10,10,10,2) +screen().drawLine(-10,-10,10,10,2) ``` has the same effect as ```blocks From 5669df26a0233f7ce013afd923555908d55603b4 Mon Sep 17 00:00:00 2001 From: Thomas Ball Date: Thu, 2 Jan 2025 21:58:48 +0000 Subject: [PATCH 10/16] rectangle --- README.md | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index ebd7fc6..c59563e 100644 --- a/README.md +++ b/README.md @@ -145,8 +145,7 @@ screen().setPixel(80, 60, 1) You can pass floating point numbers to any drawing command that takes a coordinate. For efficiency, the underlying representation is fixed point -in the MakeCode runtime. Fractional values are ignored when setting a pixel -in a bitmap, so +in the MakeCode runtime. Fractional values are ignored when setting a pixel in a bitmap, so ```blocks screen().setPixel(79.6, 59.6, 1) ``` @@ -165,20 +164,32 @@ stored in the pixel: ```blocks screen().setPixel(80, 60, 2) basic.showNumber(screen().getPixel(80, 60)) -} ``` So we can see that each pixel is like a variable that stores a value (in the range 0-15) that can later be retrieved. #### Drawing shapes -Draw +You can draw a recentangle by specifying the upper left +corner with the first two parameters to the `drawRect` +function, followed by the width and the height of the +rectangle, and ending with the draw color: -- rectangle -- circle -- triangle +```blocks +screen().drawRect(0, 0, 10, 10, 1) +screen().drawRect(10, 10, 20, 20, 2) +screen().drawRect(0, 10, 10, 20, 3) +screen().drawRect(10, 0, 20, 10, 4) +``` + +You can have the rectangle filled with the specified color instead: +```blocks +screen().fillRect(0, 0, 10, 10, 1) +screen().fillRect(10, 10, 20, 20, 2) +screen().fillRect(0, 10, 10, 20, 3) +screen().fillRect(10, 0, 20, 10, 4) +``` -Fill ### Creating your own bitmaps From 2f33d0f7fbe41ca2a21d1990b9ccba9fb6be4e13 Mon Sep 17 00:00:00 2001 From: Thomas Ball Date: Thu, 2 Jan 2025 22:04:57 +0000 Subject: [PATCH 11/16] circle --- README.md | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index c59563e..df94389 100644 --- a/README.md +++ b/README.md @@ -170,7 +170,7 @@ that can later be retrieved. #### Drawing shapes -You can draw a recentangle by specifying the upper left +You can draw a recentangle by first specifying the upper left corner with the first two parameters to the `drawRect` function, followed by the width and the height of the rectangle, and ending with the draw color: @@ -190,7 +190,14 @@ screen().fillRect(0, 10, 10, 20, 3) screen().fillRect(10, 0, 20, 10, 4) ``` - +To draw a circle, first specify the coordinate +of the center of the circle, followed by the radius +of the circle and the draw color. Again, you can choose +to fill the circle or just draw its outline: +```blocks +screen().fillCircle(10, 10, 10, 2) +screen().drawCircle(10, 10, 10, 5) +``` ### Creating your own bitmaps From 8c32ce68af54a4ae421256640f5fe26e2b5e22b1 Mon Sep 17 00:00:00 2001 From: Thomas Ball Date: Thu, 2 Jan 2025 23:01:06 +0000 Subject: [PATCH 12/16] more docs --- README.md | 52 ++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 48 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index df94389..56f72d1 100644 --- a/README.md +++ b/README.md @@ -114,6 +114,10 @@ to the screen bitmap to show the four corners of the screen: screen().drawLine(0, 0, 159, 119, 2) screen().drawLine(159, 0, 0, 119, 5) ``` +The first two parameters to the function are the (x,y) +coordinate where the line should start, while the next +two parameters are the (x',y') coordinate where the line +should end. The final parameter is the color to draw. ### Drawing out of bounds @@ -198,13 +202,53 @@ to fill the circle or just draw its outline: screen().fillCircle(10, 10, 10, 2) screen().drawCircle(10, 10, 10, 5) ``` - ### Creating your own bitmaps -#### bitmap editor -#### bitmap as hex literal +There are two ways you can create your own bitmap. + +#### Bitmap editor and hex literal + +The first way to create a bitmap is with the bitmap editor, +which represents the bitmap in code as a hex literal that +must be assigned to a program variable. The bitmap won't appear +on the screen unless it is draw using the function below: +``` +```block +let bitmap = bmp` + . . . . . . . . . . . . . . . . + . 2 2 2 2 2 2 2 2 2 2 2 2 2 2 . + . 2 . . . . . . . . . . . . 2 . + . 2 . 2 2 2 2 2 2 2 2 2 2 . 2 . + . 2 . 2 . . . . . . . . 2 . 2 . + . 2 . 2 . . . . . . . . 2 . 2 . + . 2 . 2 . . 5 5 5 5 . . 2 . 2 . + . 2 . 2 . . 5 5 5 5 . . 2 . 2 . + . 2 . 2 . . 5 5 5 5 . . 2 . 2 . + . 2 . 2 . . 5 5 5 5 . . 2 . 2 . + . 2 . 2 . . . . . . . . 2 . 2 . + . 2 . 2 . . . . . . . . 2 . 2 . + . 2 . 2 2 2 2 2 2 2 2 2 2 . 2 . + . 2 . . . . . . . . . . . . 2 . + . 2 2 2 2 2 2 2 2 2 2 2 2 2 2 . + . . . . . . . . . . . . . . . . + ` + screen().fill(5) + screen().drawBitmap(0,0,bitmap) +``` +The `.` in string representation of the bitmap represents the +color value 0, which is interpreted as `transparent` by the following +function: +```blocks + screen().fill(5) + screen().drawTransparentBitmap(0,0,bitmap) +``` + +#### Bitmap create function + +#### Drawing to a bitmap -### Drawing a bitmap onto the screen +All the functions we previously reviewed for drawing to the +screen can also be applied to a bitmap. EXAMPLE ## TypeScript APIs From 6d3ac21a49abd422a1a7441fc3ee5d743fc9a540 Mon Sep 17 00:00:00 2001 From: Thomas Ball Date: Fri, 3 Jan 2025 01:07:54 +0000 Subject: [PATCH 13/16] get rid of reference reference --- docs/bitmap-type.md | 7 +++---- docs/draw-bitmap.md | 0 2 files changed, 3 insertions(+), 4 deletions(-) create mode 100644 docs/draw-bitmap.md diff --git a/docs/bitmap-type.md b/docs/bitmap-type.md index 5a4bbeb..208f5b8 100644 --- a/docs/bitmap-type.md +++ b/docs/bitmap-type.md @@ -2,7 +2,7 @@ A bitmap is some number of rows and columns of color pixels that make up rectangular picture. A _pixel_ is a single point of color inside the bitmap. -Bitmaps are two-dimensional so they have a known height and width. When a bitmap is declared, or created, the height and width are specified either by the _layout_ of the bitmap or as parameters to it's [create](/reference/bitmaps/create) method. +Bitmaps are two-dimensional so they have a known height and width. When a bitmap is declared, or created, the height and width are specified either by the _layout_ of the bitmap or as parameters to it's `create` method. ## Bitmap layout @@ -16,7 +16,7 @@ An zero size bitmap has no height or width and has no pixels, so the **bmp** str let emptyBitmap = bmp`` ``` -You can also use [create](/reference/bitmaps/create) and make another zero size bitmap with no pixels. +You can also use the `create` function and make another zero size bitmap with no pixels. ```blocks let emptyBitmap1 = bmp`` @@ -214,8 +214,7 @@ for (let i = 0; i < 32; i++) { let boxSprite = sprites.create(orangeBox) ``` -The [bitmap](/reference/bitmaps) functions let you do more complex pixel operations like filling and drawing shapes. - +Other functions let you do more complex pixel operations like filling and drawing shapes. ```package pxt-arcadeshield=github:microbit-apps/pxt-arcadeshield diff --git a/docs/draw-bitmap.md b/docs/draw-bitmap.md new file mode 100644 index 0000000..e69de29 From ee5c8a6b9c538503a9e0dadb14cabe6808aa9e2e Mon Sep 17 00:00:00 2001 From: Thomas Ball Date: Fri, 3 Jan 2025 01:24:57 +0000 Subject: [PATCH 14/16] move stuff about bitmaps to readme --- README.md | 225 +++++++++++++++++++++++++++++++++++++++++++- docs/bitmap-type.md | 221 ------------------------------------------- docs/draw-bitmap.md | 6 ++ pxt.json | 2 +- 4 files changed, 229 insertions(+), 225 deletions(-) delete mode 100644 docs/bitmap-type.md diff --git a/README.md b/README.md index 56f72d1..a931623 100644 --- a/README.md +++ b/README.md @@ -202,11 +202,230 @@ to fill the circle or just draw its outline: screen().fillCircle(10, 10, 10, 2) screen().drawCircle(10, 10, 10, 5) ``` -### Creating your own bitmaps +### Bitmap + +Let's dig into bitmaps, which you can create yourself (the screen is represented by a bitmap, as we have seen already). + +A bitmap is some number of rows and columns of color pixels that make up rectangular picture. A _pixel_ is a single point of color inside the bitmap. + +Bitmaps are two-dimensional so they have a known height and width. When a bitmap is declared, or created, the height and width are specified either by the _layout_ of the bitmap or as parameters to it's `create` method. + +#### Bitmap layout + +You _declare_ a bitmap by creating a layout. This is done in JavaScript with the ``bmp'...'`` string declaration. The pixels are single characters inside the string. + +##### Zero size bitmap + +An zero size bitmap has no height or width and has no pixels, so the **bmp** string is just ``bmp''``. + +```typescript +let emptyBitmap = bmp`` +``` + +You can also use the `create` function and make another zero size bitmap with no pixels. + +```blocks +let emptyBitmap1 = bmp`` +let emptyBitmap2 = bitmaps.create(0, 0) +``` + +A zero size bitmap isn't really useful so MakeCode actually makes it have some size if you declare it without any. + +#### Bitmaps with size + +To make a bitmap with some size, just set the pixel characters in the rows of the **bmp** string. A bitmap that is 1 pixel high by 1 pixel wide (1 x 1) is: + +```typescript +let oneByOne = bmp`.` +``` + +A bitmap that is 2 x 2 is declared like this: + +```typescript +let twoBytwo = bmp` +. . +. . +` +``` + +Here they are in blocks: + +```blocks +let oneByOne = bmp`.` +let twoBytwo = bmp` +. . +. . +` +``` + +You'll notice that they look the same. That's because the pixel colors are not set so the bitmaps are empty. + +Bitmaps don't have to be exactly square. The height and width can be different. Here's a 6 x 2 bitmap: + +```typescript +let sixByTwo = bmp` +. . . . . . +. . . . . . +` +``` + +#### Setting pixels + +##### Transparent pixels + +A pixel value of `.` means an empty pixel. This pixel has no color and that pixel _location_ in the bitmap is _transparent_. Being transparent means that if this bitmap is on top of another bitmap (overlapping) that has some pixel color, then the color of the pixel in the bitmap underneath shows through to the bitmap above it. + +##### Pixel colors + +Besides the empty, or transparent pixel `.`, there are 16 color pixels you can use. These are matched to colors in a _palette_. A palette is a group of colors you can choose from. The colors are selected by using a single number or letter to match them. The default palette, for example, uses these colors: + +* `.`: empty or transparent +* `0`: transparent +* `1`: white +* `2`: light blue +* `3`: medium blue +* `4`: dark blue +* `5`: violet +* `6`: lime +* `7`: olive +* `8`: brown +* `9`: cyan +* `a`: red +* `b`: purple +* `c`: pink +* `d`: orange +* `e`: yellow +* `f`: black + +A 1 x 1 bitmap with a red pixel is declared as: + +```typescript +let oneRed = bmp`a` +``` + +As a block it looks like this: + +```block +let oneRed = bmp`a` +``` + +We can make 4 x 4 bitmap that uses all of the colors: + +```typescript +let allColors = bmp` +0 1 2 3 +4 5 6 7 +8 9 a b +c d e f +` +``` + +This the same bitmap as a block: + +```block +let allColors = bmp` +0 1 2 3 +4 5 6 7 +8 9 a b +c d e f +` +``` + +#### Transparency and overlap + +Let's see how transparency works with bitmaps. A `.` means that a pixel is transparent. Only the pixels with a color will show in a bitmap and any pixels with color in a bitmap below it will show through. So, to demonstrate, let's make two bitmaps that are the same size and put one that has some transparent pixels on top of one that doesn't. + +Our first bitmap is a green circle inside a 8 x 8 rectangle. All of the pixels around the circle are transparent. + +```typescript +let greenBall = bmp` +. . . . . . . . +. . . 6 6 . . . +. . 6 6 6 6 . . +. 6 6 6 6 6 6 . +. 6 6 6 6 6 6 . +. . 6 6 6 6 . . +. . . 6 6 . . . +. . . . . . . . +` +``` + +The other bitmap is the same size but with all yellow pixels. + +```blocks +let greenBall = bmp` +. . . . . . . . +. . . 6 6 . . . +. . 6 6 6 6 . . +. 6 6 6 6 6 6 . +. 6 6 6 6 6 6 . +. . 6 6 6 6 . . +. . . 6 6 . . . +. . . . . . . . +` + +let yellowSquare = bmp` +e e e e e e e e +e e e e e e e e +e e e e e e e e +e e e e e e e e +e e e e e e e e +e e e e e e e e +e e e e e e e e +e e e e e e e e +e e e e e e e e +` +``` + +Putting the green circle bitmap exactly over the yellow square, you see that the yellow from the bitmap below isn't blocked out by the transparent pixels from the bitmap on top. + +```sim +let greenBall = bmp` +. . . . . . . . . . . . . . . . +. . . . . . . . . . . . . . . . +. . . . . . 6 6 6 6 . . . . . . +. . . . 6 6 6 6 6 6 6 6 . . . . +. . . 6 6 6 6 6 6 6 6 6 6 . . . +. . . 6 6 6 6 6 6 6 6 6 6 . . . +. . 6 6 6 6 6 6 6 6 6 6 6 6 . . +. . 6 6 6 6 6 6 6 6 6 6 6 6 . . +. . 6 6 6 6 6 6 6 6 6 6 6 6 . . +. . 6 6 6 6 6 6 6 6 6 6 6 6 . . +. . . 6 6 6 6 6 6 6 6 6 6 . . . +. . . 6 6 6 6 6 6 6 6 6 6 . . . +. . . . 6 6 6 6 6 6 6 6 . . . . +. . . . . . 6 6 6 6 . . . . . . +. . . . . . . . . . . . . . . . +. . . . . . . . . . . . . . . . +` +let yellowSquare = bitmaps.create(16, 16) +yellowSquare.fill(5) + +screen().drawBitmap(yellowSquare, 0, 0) +screeb().drawTransparentBitmap(greenBall, 0, 0) +``` + +#### Setting pixels at locations + +You can create your bitmaps while your program is running too (dynamically). To make a bitmap this way, you set the color of a pixel at its location with code. Pixels are addressed by their row (``x`` value) and column (``y`` value) inside the bitmap. You could create and empty bitmap and make some or all of the bitmap by setting pixel colors in your code. Let's make a 32 x 32 box by creating an empty bitmap and then draw an orange border around it. + +```blocks +let orangeBox = bitmaps.create(32, 32) +for (let i = 0; i <= 31; i++) { + orangeBox.setPixel(0, i, 4) + orangeBox.setPixel(i, 0, 4) + orangeBox.setPixel(i, 31, 4) + orangeBox.setPixel(31, i, 4) +} +screen().drawTransparentBitmap(orangeBox, 0, 0) +``` + + +#### Creating your own bitmaps There are two ways you can create your own bitmap. -#### Bitmap editor and hex literal +##### Bitmap editor and hex literal The first way to create a bitmap is with the bitmap editor, which represents the bitmap in code as a hex literal that @@ -243,7 +462,7 @@ function: screen().drawTransparentBitmap(0,0,bitmap) ``` -#### Bitmap create function +##### Bitmap create function #### Drawing to a bitmap diff --git a/docs/bitmap-type.md b/docs/bitmap-type.md deleted file mode 100644 index 208f5b8..0000000 --- a/docs/bitmap-type.md +++ /dev/null @@ -1,221 +0,0 @@ -# Bitmap - -A bitmap is some number of rows and columns of color pixels that make up rectangular picture. A _pixel_ is a single point of color inside the bitmap. - -Bitmaps are two-dimensional so they have a known height and width. When a bitmap is declared, or created, the height and width are specified either by the _layout_ of the bitmap or as parameters to it's `create` method. - -## Bitmap layout - -You _declare_ a bitmap by creating a layout. This is done in JavaScript with the ``bmp'...'`` string declaration. The pixels are single characters inside the string. - -### Zero size bitmap - -An zero size bitmap has no height or width and has no pixels, so the **bmp** string is just ``bmp''``. - -```typescript -let emptyBitmap = bmp`` -``` - -You can also use the `create` function and make another zero size bitmap with no pixels. - -```blocks -let emptyBitmap1 = bmp`` -let emptyBitmap2 = bitmaps.create(0, 0) -``` - -A zero size bitmap isn't really useful so MakeCode actually makes it have some size if you declare it without any. - -### Bitmaps with size - -To make a bitmap with some size, just set the pixel characters in the rows of the **bmp** string. A bitmap that is 1 pixel high by 1 pixel wide (1 x 1) is: - -```typescript -let oneByOne = bmp`.` -``` - -A bitmap that is 2 x 2 is declared like this: - -```typescript -let twoBytwo = bmp` -. . -. . -` -``` - -Here they are in blocks: - -```blocks -let oneByOne = bmp`.` -let twoBytwo = bmp` -. . -. . -` -``` - -You'll notice that they look the same. That's because the pixel colors are not set so the bitmaps are empty. - -Bitmaps don't have to be exactly square. The height and width can be different. Here's a 6 x 2 bitmap: - -```typescript -let sixByTwo = bmp` -. . . . . . -. . . . . . -` -``` - -## Setting pixels - -### Transparent pixels - -A pixel value of `.` means an empty pixel. This pixel has no color and that pixel _location_ in the bitmap is _transparent_. Being transparent means that if this bitmap is on top of another bitmap (overlapping) that has some pixel color, then the color of the pixel in the bitmap underneath shows through to the bitmap above it. - -### Pixel colors - -Besides the empty, or transparent pixel `.`, there are 16 color pixels you can use. These are matched to colors in a _palette_. A palette is a group of colors you can choose from. The colors are selected by using a single number or letter to match them. The default palette, for example, uses these colors: - -* `.`: empty or transparent -* `0`: transparent -* `1`: white -* `2`: light blue -* `3`: medium blue -* `4`: dark blue -* `5`: violet -* `6`: lime -* `7`: olive -* `8`: brown -* `9`: cyan -* `a`: red -* `b`: purple -* `c`: pink -* `d`: orange -* `e`: yellow -* `f`: black - -A 1 x 1 bitmap with a red pixel is declared as: - -```typescript -let oneRed = bmp`a` -``` - -As a block it looks like this: - -```block -let oneRed = bmp`a` -``` - -We can make 4 x 4 bitmap that uses all of the colors: - -```typescript -let allColors = bmp` -0 1 2 3 -4 5 6 7 -8 9 a b -c d e f -` -``` - -This the same bitmap as a block: - -```block -let allColors = bmp` -0 1 2 3 -4 5 6 7 -8 9 a b -c d e f -` -``` - -## Transparency and overlap - -Let's see how transparency works with bitmaps. A `.` means that a pixel is transparent. Only the pixels with a color will show in a bitmap and any pixels with color in a bitmap below it will show through. So, to demonstrate, let's make two bitmaps that are the same size and put one that has some transparent pixels on top of one that doesn't. - -Our first bitmap is a green circle inside a 8 x 8 rectangle. All of the pixels around the circle are transparent. - -```typescript -let greenBall = bmp` -. . . . . . . . -. . . 6 6 . . . -. . 6 6 6 6 . . -. 6 6 6 6 6 6 . -. 6 6 6 6 6 6 . -. . 6 6 6 6 . . -. . . 6 6 . . . -. . . . . . . . -` -``` - -The other bitmap is the same size but with all yellow pixels. - -```blocks -let greenBall = bmp` -. . . . . . . . -. . . 6 6 . . . -. . 6 6 6 6 . . -. 6 6 6 6 6 6 . -. 6 6 6 6 6 6 . -. . 6 6 6 6 . . -. . . 6 6 . . . -. . . . . . . . -` - -let yellowSquare = bmp` -e e e e e e e e -e e e e e e e e -e e e e e e e e -e e e e e e e e -e e e e e e e e -e e e e e e e e -e e e e e e e e -e e e e e e e e -e e e e e e e e -` -``` - -Putting the green circle bitmap exactly over the yellow square, you see that the yellow from the bitmap below isn't blocked out by the transparent pixels from the bitmap on top. - -```sim -let greenBall = bmp` -. . . . . . . . . . . . . . . . -. . . . . . . . . . . . . . . . -. . . . . . 6 6 6 6 . . . . . . -. . . . 6 6 6 6 6 6 6 6 . . . . -. . . 6 6 6 6 6 6 6 6 6 6 . . . -. . . 6 6 6 6 6 6 6 6 6 6 . . . -. . 6 6 6 6 6 6 6 6 6 6 6 6 . . -. . 6 6 6 6 6 6 6 6 6 6 6 6 . . -. . 6 6 6 6 6 6 6 6 6 6 6 6 . . -. . 6 6 6 6 6 6 6 6 6 6 6 6 . . -. . . 6 6 6 6 6 6 6 6 6 6 . . . -. . . 6 6 6 6 6 6 6 6 6 6 . . . -. . . . 6 6 6 6 6 6 6 6 . . . . -. . . . . . 6 6 6 6 . . . . . . -. . . . . . . . . . . . . . . . -. . . . . . . . . . . . . . . . -` -let yellowSquare = bitmaps.create(16, 16) -yellowSquare.fill(14) - -let yellowSprite = sprites.create(yellowSquare) -let greenSprite = sprites.create(greenBall) -``` - -## Setting pixels at locations - -You can create your bitmaps while your program is running too (dynamically). To make a bitmap this way, you set the color of a pixel at its location with code. Pixels are addressed by their row (``x`` value) and column (``y`` value) inside the bitmap. You could create and empty bitmap and make some or all of the bitmap by setting pixel colors in your code. Let's make a 32 x 32 box by creating an empty bitmap and then draw an orange border around it. - -```blocks -let orangeBox = bitmaps.create(32, 32) -for (let i = 0; i < 32; i++) { - orangeBox.setPixel(0, i, 13) - orangeBox.setPixel(i, 0, 13) - orangeBox.setPixel(i, 31, 13) - orangeBox.setPixel(31, i, 13) -} -let boxSprite = sprites.create(orangeBox) -``` - -Other functions let you do more complex pixel operations like filling and drawing shapes. - -```package -pxt-arcadeshield=github:microbit-apps/pxt-arcadeshield -``` diff --git a/docs/draw-bitmap.md b/docs/draw-bitmap.md index e69de29..6013b76 100644 --- a/docs/draw-bitmap.md +++ b/docs/draw-bitmap.md @@ -0,0 +1,6 @@ +# Draw bitmap + + +```package +pxt-arcadeshield=github:microbit-apps/pxt-arcadeshield +``` diff --git a/pxt.json b/pxt.json index 21ce430..be4d0c4 100644 --- a/pxt.json +++ b/pxt.json @@ -53,7 +53,7 @@ "docs/screen-bitmap.md", "docs/on-button-event.md", "docs/is-pressed.md", - "docs/bitmap-type.md" + "docs/draw-bitmap.md" ], "testFiles": [ "test.ts" From 229e8d340efb34d168a579945ff8ae78e2b35d33 Mon Sep 17 00:00:00 2001 From: Thomas Ball Date: Fri, 3 Jan 2025 02:10:05 +0000 Subject: [PATCH 15/16] drawline in bitmap --- README.md | 46 +++++++++++++++++++++++++++------------------- 1 file changed, 27 insertions(+), 19 deletions(-) diff --git a/README.md b/README.md index a931623..49bd270 100644 --- a/README.md +++ b/README.md @@ -282,31 +282,31 @@ Besides the empty, or transparent pixel `.`, there are 16 color pixels you can u * `.`: empty or transparent * `0`: transparent * `1`: white -* `2`: light blue -* `3`: medium blue -* `4`: dark blue -* `5`: violet -* `6`: lime -* `7`: olive -* `8`: brown -* `9`: cyan -* `a`: red -* `b`: purple -* `c`: pink -* `d`: orange -* `e`: yellow +* `2`: red +* `3`: pink +* `4`: orange +* `5`: yellow +* `6`: blue-green +* `7`: green +* `8`: dark blue +* `9`: light blue +* `a`: purple +* `b`: dark grey +* `c`: dark purple +* `d`: beige +* `e`: brown * `f`: black A 1 x 1 bitmap with a red pixel is declared as: ```typescript -let oneRed = bmp`a` +let oneRed = bmp`2` ``` As a block it looks like this: ```block -let oneRed = bmp`a` +let oneRed = bmp`2` ``` We can make 4 x 4 bitmap that uses all of the colors: @@ -407,7 +407,7 @@ screeb().drawTransparentBitmap(greenBall, 0, 0) #### Setting pixels at locations -You can create your bitmaps while your program is running too (dynamically). To make a bitmap this way, you set the color of a pixel at its location with code. Pixels are addressed by their row (``x`` value) and column (``y`` value) inside the bitmap. You could create and empty bitmap and make some or all of the bitmap by setting pixel colors in your code. Let's make a 32 x 32 box by creating an empty bitmap and then draw an orange border around it. +You can create your bitmaps while your program is running too (dynamically). To make a bitmap this way, you set the color of a pixel at its location with code. Pixels are addressed by their row (``x`` value) and column (``y`` value) inside the bitmap. You could create an empty bitmap and make some or all of the bitmap by setting pixel colors in your code. Let's make a 32 x 32 box by creating an empty bitmap and then draw an orange border in it. ```blocks let orangeBox = bitmaps.create(32, 32) @@ -420,7 +420,6 @@ for (let i = 0; i <= 31; i++) { screen().drawTransparentBitmap(orangeBox, 0, 0) ``` - #### Creating your own bitmaps There are two ways you can create your own bitmap. @@ -464,12 +463,21 @@ function: ##### Bitmap create function +The other way to create a bitmap is with the `create` function, as shown above. + #### Drawing to a bitmap All the functions we previously reviewed for drawing to the -screen can also be applied to a bitmap. EXAMPLE +screen can also be applied to a bitmap. For example, the orange border in a bitmap can be created as followsL -## TypeScript APIs +```blocks +let orangeBox = bitmaps.create(32, 32) +orangeBox.drawLine(0, 0, 31, 0, 4) +orangeBox.drawLine(0, 0, 0, 31, 4) +orangeBox.drawLine(0, 31, 31, 31, 4) +orangeBox.drawLine(31, 0, 31, 31, 4) +screen().drawTransparentBitmap(orangeBox, 0, 0) +``` # Supported targets From 6dc1b09bf84ef38e8ecc4f80d899f2476e0d7fb1 Mon Sep 17 00:00:00 2001 From: Thomas Ball Date: Fri, 3 Jan 2025 02:11:08 +0000 Subject: [PATCH 16/16] give this a try --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 49bd270..cac73c4 100644 --- a/README.md +++ b/README.md @@ -477,6 +477,7 @@ orangeBox.drawLine(0, 0, 0, 31, 4) orangeBox.drawLine(0, 31, 31, 31, 4) orangeBox.drawLine(31, 0, 31, 31, 4) screen().drawTransparentBitmap(orangeBox, 0, 0) +screen().drawTransparentBitmap(orangeBox, 32, 32) ``` # Supported targets