denko 0.13.0

data/src/lib/Denko.cpp

@@ -0,0 +1,330 @@
+/*
+  Library for denko ruby gem.
+*/
+#include "Denko.h"
+#include "BoardMap.h"
+
+Denko::Denko(){
+  messageFragments[0] = cmdStr;
+  messageFragments[1] = pinStr;
+  messageFragments[2] = valStr;
+  messageFragments[3] = auxMsg;
+  resetState();
+}
+
+void Denko::rxNotify() {
+  stream->print("Rx:");
+  stream->print(rxBytes);
+  stream->print("\n");
+  rxBytes = 0;
+}
+
+void Denko::sendHalt() {
+  stream->print("Hlt");
+  stream->print("\n");
+}
+
+// CMD = 92
+// Expose this for diagnostics and testing.
+void Denko::sendReady() {
+  stream->print("Rdy");
+  stream->print("\n");
+}
+
+void Denko::run(){
+  while(stream->available()) {
+    parse(stream->read());
+    rxBytes ++;
+    // Acknowledge when we've received half as many bytes as the serial buffer.
+    if (rxBytes >= rxNotifyLimit) rxNotify();
+  }
+
+  #ifdef DENKO_UARTS
+    uartUpdateListeners();
+  #endif
+
+  #ifdef DENKO_UART_BB
+    uartBBUpdateListener();
+  #endif
+
+  // Run denko's listeners.
+  updateListeners();
+}
+
+void Denko::parse(byte c) {
+  if ((c == '\n') || (c == '\\')) {
+    // If last char was a \, this \ or \n is escaped.
+    if(escaping){
+      append(c);
+      escaping = false;
+    }
+
+    // If EOL, process and reset.
+    else if (c == '\n'){
+      append('\0');
+      if ((fragmentIndex > 0) || (charIndex > 1)) process();
+      fragmentIndex = 0;
+      charIndex = 0;
+    }
+
+    // Backslash is the escape character.
+    else if (c == '\\') escaping = true;
+  }
+
+  // If fragment delimiter, terminate current fragment and move to next.
+  // Unless we're in the auxillary message fragment, then just append.
+  else if (c == '.') {
+    if (fragmentIndex < 3) {
+      escaping = false;
+      append('\0');
+      fragmentIndex++;
+      charIndex = 0;
+    } else {
+      append(c);
+    }
+  }
+
+  // Else just append the character.
+  else {
+    escaping = false;
+    append(c);
+  }
+}
+
+void Denko::append(byte c) {
+  messageFragments[fragmentIndex][charIndex] = c;
+  charIndex++;
+}
+
+void Denko::process() {
+  cmd = atoi((char *)cmdStr);
+  pin = atoi((char *)pinStr);
+  val = atoi((char *)valStr);
+
+  // Call the command.
+  switch(cmd) {
+    // Implemented in DenkoCoreIO.cpp
+    case 0:  setMode             (pin, val);        break;
+    case 1:  dWrite              (pin, val, false); break;
+    case 2:  dRead               (pin);             break;
+    case 3:  pwmWrite            (pin, val, false); break;
+    case 4:  dacWrite            (pin, val, false); break;
+    case 5:  aRead               (pin);             break;
+    case 6:  setListener         (pin, val, auxMsg[0], auxMsg[1], false); break;
+
+    // Implemented in DenkoEEPROM.cpp
+    #ifdef EEPROM_PRESENT
+    case 7:  eepromRead           (); break;
+    case 8:  eepromWrite          (); break;
+    #endif
+
+    // Implemented in DenkoPulseInput.cpp
+    case 9: pulseRead             (); break;
+
+    // Implemented in DenkoServo.cpp
+    #ifdef DENKO_SERVO
+    case 10:  servoToggle         (); break;
+    case 11:  servoWrite          (); break;
+    #endif
+
+    // Implemented in DenkoSerialBB.cpp
+    #ifdef DENKO_UART_BB
+    case 12: uartBBSetup (); break;
+    case 13: uartBBWrite (); break;
+    #endif
+
+    // Implemented in DenkoUART.cpp
+    #ifdef DENKO_UARTS
+    case 14: uartSetup  (); break;
+    case 15: uartWrite  (); break;
+    #endif
+
+    // Implemented in DenkoIROut.cpp
+    #ifdef DENKO_IR_OUT
+    case 16: irSend       (); break;
+    #endif
+
+    // Implemented in DenkoTone.cpp
+    #ifdef DENKO_TONE
+    case 17: tone         (); break;
+    case 18: noTone       (); break;
+    #endif
+
+    // Implemented in DenkoAddressableLED.cppp
+    #ifdef DENKO_LED_ARRAY
+    case 19: showLEDArray        ();   //cmd = 19
+    #endif
+
+    // Implemented in DenkoSPIBB.cpp
+    #ifdef DENKO_SPI_BB
+    case 21: spiBBtransfer       (auxMsg[3], auxMsg[4], auxMsg[5], pin, auxMsg[0], auxMsg[1], auxMsg[2], &auxMsg[7]);  break;
+    case 22: spiBBaddListener    ();  break;
+    #endif
+
+    // Implemented in DenkoSPI.cpp
+    #ifdef DENKO_SPI
+    case 26: {
+      // Do this since RP2040 crashes with reinterpet_cast of uint32_t.
+      uint32_t  clockRate  = (uint32_t)auxMsg[3];
+                clockRate |= (uint32_t)auxMsg[4] << 8;
+                clockRate |= (uint32_t)auxMsg[5] << 16;
+                clockRate |= (uint32_t)auxMsg[6] << 24;
+      spiTransfer(clockRate, pin, auxMsg[0], auxMsg[1], auxMsg[2], &auxMsg[7]); break;
+    }
+    case 27: spiAddListener   ();  break;
+    #endif
+
+    // Implemented in DenkoSPI.cpp
+    #if defined(DENKO_SPI) || defined(DENKO_SPI_BB)
+    case 28: spiRemoveListener();  break;
+    #endif
+    
+    // Implemented in DenkoI2C.cpp
+    #ifdef DENKO_I2C
+    case 33: i2cSearch           ();  break;
+    case 34: i2cWrite            ();  break;
+    case 35: i2cRead             ();  break;
+    #endif
+
+    // Implemented in DenkoOneWire.cpp
+    #ifdef DENKO_ONE_WIRE
+    case 41: owReset             ();  break;
+    case 42: owSearch            ();  break;
+    case 43: owWrite             ();  break;
+    case 44: owRead              ();  break;
+    #endif
+
+    // Implemented in this file.
+    case 90: handshake                ();  break;
+    case 91: resetState               ();  break;
+    case 92: sendReady                ();  break;
+    case 95: setRegisterDivider       ();  break;
+    case 96: setAnalogWriteResolution ();  break;
+    case 97: setAnalogReadResolution  ();  break;
+    case 99: microDelay(*reinterpret_cast<uint16_t*>(auxMsg)); break;
+
+    // Should send a "feature not implemented" message as default.
+    default:                          break;
+  }
+}
+
+//
+// Every 1000 microseconds count a tick and call the listeners.
+// Each core listener has its own divider, so it can read every
+// 1, 2, 4, 8, 16, 32, 64 or 128 ticks, independent of the others.
+//
+// Register listeners are still on a global divider for now.
+// Analog and register listeners always send values even if not changed.
+// Digital listeners only send values on change.
+//
+void Denko::updateListeners() {
+  currentTime = micros();
+  timeDiff = currentTime - lastTime;
+  
+  if (timeDiff > 999) {
+    // Add a tick for every 1000us passed.
+    tickCount = tickCount + (timeDiff / 1000);
+      
+    // lastTime for next run is currentTime offset by remainder.
+    lastTime = currentTime - (timeDiff % 1000);
+
+    updateCoreListeners();
+
+    // SPI register Listeners
+    #if defined(DENKO_SPI) || defined(DENKO_SPI_BB)
+      if (tickCount % registerDivider == 0) spiUpdateListeners();
+    #endif
+  }
+}
+
+// CMD = 90
+void Denko::handshake() {
+  // Reset the I2C interface.
+  // Some boards (like the ESP32-S2) behave badly without this.
+  #ifdef DENKO_I2C
+    i2cEnd();
+  #endif
+
+  // Reset all the state variables.
+  resetState();
+
+  // Reset this so we never send Rx along with ACK:
+  rxBytes = 0;
+  
+  // First handshake value is BOARD_MAP if set.
+  stream->print("ACK:");
+  #ifdef BOARD_MAP
+    stream->print(BOARD_MAP);
+  #endif
+
+  // Second is DENKO_VERSION.
+  stream->print(',');
+  #ifdef DENKO_VERSION
+    stream->print(DENKO_VERSION);
+  #endif
+
+  // Third is AUX_SIZE.
+  stream->print(',');
+  stream->print(AUX_SIZE);
+  
+  // Fourth is EEPROM size in bytes. None on Due or Zero.
+  stream->print(',');
+  #if defined(EEPROM_EMULATED)
+  	stream->print(EMULATED_EEPROM_LENGTH);
+  #elif defined(EEPROM_PRESENT)
+	  stream->print(EEPROM.length());
+  #else
+    stream->print('0');
+  #endif
+  
+  // End
+  stream->print('\n');
+}
+
+// CMD = 91
+void Denko::resetState() {
+  clearCoreListeners();
+  #if defined(DENKO_SPI) || defined(DENKO_SPI_BB)
+    spiClearListeners();
+  #endif
+  #ifdef ESP32
+    clearLedcChannels();
+  #endif
+  registerDivider = 8; // Update register listeners every ~8ms.
+  fragmentIndex = 0;
+  charIndex = 0;
+  tickCount = 0;
+  lastTime = micros();
+}
+
+// CMD = 95
+// Set the register read divider. Powers of 2 up to 128 are valid.
+void Denko::setRegisterDivider() {
+  registerDivider = val;
+}
+
+// CMD = 96
+// Set the analog write resolution.
+void Denko::setAnalogWriteResolution() {
+  #ifdef WRITE_RESOLUTION_SETTER
+    analogWriteResolution(val);
+  #endif
+}
+
+// CMD = 97
+// Set the analog read resolution.
+void Denko::setAnalogReadResolution() {
+  #ifdef READ_RESOLUTION_SETTER
+    analogReadResolution(val);
+  #endif
+}
+
+// CMD = 99
+// Use a different blocking microsecond delay on different platforms.
+void Denko::microDelay(uint32_t microseconds){
+  #if defined(ESP32)
+    ets_delay_us(microseconds);
+  #else
+    delayMicroseconds(microseconds);
+  #endif
+}

data/src/lib/Denko.h

@@ -0,0 +1,259 @@
+/*
+  Library for denko ruby gem.
+*/
+#include <Arduino.h>
+#include "DenkoDefines.h"
+
+class Denko {
+  public:
+    Denko();
+    void run();
+
+    // Expect main sketch to pass a reference to a Stream-like object for IO.
+    // Store it and call ->print, ->write, ->available, ->read etc. on it.
+    Stream* stream;
+
+    // Callback hooks for local logic (defined in main sketch) based on listeners.
+    // These should be used if:
+    //   1) a round-trip to the remote client is too slow, or
+    //   2) something needs to happen regardless of remote client connection.
+    // Eg. Instant feedback from a smart light switch.
+    void (*digitalListenCallback)(byte p, byte v);
+    void (*analogListenCallback)(byte p, int v);
+
+    // Core IO API Functions
+    // Functions with a cmd value can be called through the remote API.
+    //
+    // This subset is made public to allow use by local listener callbacks.
+    // Reading and writing through the denko library can help maintain
+    // consistency and notify the remote client of local actions automatically.
+    //
+    void setMode     (byte p, byte m);                     //cmd = 0
+    void dWrite      (byte p, byte v, boolean echo=true);  //cmd = 1
+    byte dRead       (byte p);                             //cmd = 2
+    void pwmWrite    (byte p, int v,  boolean echo=true);  //cmd = 3
+    void dacWrite    (byte p, int v,  boolean echo=true);  //cmd = 4
+    int  aRead       (byte p);                             //cmd = 5
+    void setListener (byte p, boolean enabled, byte analog, byte exponent, boolean local=true); //cmd = 6
+    
+    // Read value of micros() every loop.
+    unsigned long currentTime;
+    
+    // Counts 1ms ticks based on currentTime. Rolls over every 256ms.
+    byte tickCount;
+
+  private:
+    //
+    // Main loop listen functions.
+    //
+    void updateListeners       ();
+    void updateCoreListeners   ();
+    void analogListenerUpdate  (byte index);
+    void digitalListenerUpdate (byte index);
+    void clearCoreListeners    ();
+    void findLastActiveListener();
+
+    //
+    // Tanslating aWrite to ledcWrite for PWM out on the ESP32.
+    //
+    // Track which pin is assigned to each LEDC channel.
+    // Byte 0 = enabled or disabled
+    // Byte 1 = pin number attached to that channel
+    //
+    #ifdef ESP32
+    byte ledcPins[LEDC_CHANNEL_COUNT][2];
+    byte ledcChannel(byte p);
+    byte assignLEDC(byte channel, byte pin);
+    void releaseLEDC(byte p);
+    void clearLedcChannels();
+    #endif
+
+    //
+    // Store listeners as a 2 dimensional array where each gets 2 bytes:
+    //
+    // byte 0, bit 7   : 1 = enabled, 0  = disabled
+    // byte 0, bit 6   : 1 = analog, 0 = digital
+    // byte 0, bit 5   : digital listener state storage
+    // byte 0, bit 4   : local flag (remote client cannot modify listener if set)
+    // byte 0, bit 3   : unused
+    // byte 0, bits 2-0: timing divider exponent (2^0 through 2^7)
+    //
+    // byte 1          : pin number
+    //
+    byte listeners [PIN_COUNT][2];
+
+    // Track the highest number listener that's active.
+    byte lastActiveListener;
+    // Map 2's exponents for dividers to save time.
+    const byte dividerMap[8] = {1, 2, 4, 8, 16, 32, 64, 128};
+
+    // Response func for features following the pin:value pattern.
+    void coreResponse(int p, int v);
+
+    // Functions with a cmd value can be called through the remote API.
+    // EEPROM Access
+    void eepromRead         (); //cmd = 7
+    void eepromWrite        (); //cmd = 8
+
+    // Included Libraries
+    void pulseRead          (); //cmd = 9
+    void servoToggle        (); //cmd = 10
+    void servoWrite         (); //cmd = 11
+    void handleSerial       (); //cmd = 12
+
+    // Single Bit Bang UART
+    #ifdef DENKO_UART_BB
+      SoftwareSerial uartBB = SoftwareSerial(10,11);
+      uint8_t uartBBTx;
+      uint8_t uartBBRx;
+      bool uartBBListen = false;
+
+      void uartBBBegin          (uint32_t baud);
+      void uartBBEnd            ();
+      void uartBBSetup          (); //cmd = 12
+      void uartBBWrite          (); //cmd = 13
+      void uartBBUpdateListener ();
+    #endif
+
+    // Up to 3 extra hardware UARTs
+    #ifdef DENKO_UARTS
+      HardwareSerial* uarts[DENKO_UARTS+1];
+      bool uartListenStates[DENKO_UARTS+1];
+      byte uartRxPins[DENKO_UARTS+1];
+
+      void uartBegin            (uint8_t index, uint32_t baud);
+      void uartEnd              (uint8_t index);
+      void uartSetup            (); //cmd = 14
+      void uartWrite            (); //cmd = 15
+      void uartUpdateListeners  ();
+    #endif
+
+    void irSend             (); //cmd = 16
+    void tone               (); //cmd = 17
+    void noTone             (); //cmd = 18
+    void showLEDArray       (); //cmd = 19
+
+    // Bit Bang SPI
+    void spiBBtransfer         (uint8_t clock, uint8_t input, uint8_t output, uint8_t select, uint8_t settings, 
+                                uint8_t rLength, uint8_t wLength, byte *data);                                                          //cmd = 21
+    byte spiBBtransferByte     (uint8_t clock, uint8_t input, uint8_t output, uint8_t select,
+                                uint8_t mode, uint8_t bitOrder, byte data);
+    void spiBBaddListener      ();                                                                                                      //cmd = 22
+    void spiBBreadListener     (uint8_t i);
+
+    // Hardware SPI
+    void spiBegin              (byte settings, uint32_t clockRate);
+    void spiEnd                ();
+    void spiTransfer           (uint32_t clockRate, uint8_t select, uint8_t settings, uint8_t rLength, uint8_t wLength, byte *data);    //cmd = 26
+    void spiAddListener        ();                                                                                                      //cmd = 27
+    void spiReadListener       (uint8_t i);
+ 
+    // SPI Listeners (both hardware and bit bang)
+    void spiRemoveListener     ();                                                                                                      //cmd = 28
+    void spiUpdateListeners    ();
+    void spiClearListeners     ();
+
+    // I2C
+    void i2cBegin              ();
+    void i2cEnd                ();
+    void i2cSetSpeed           (uint8_t code);
+    void i2cSearch             (); //cmd = 33
+    void i2cWrite              (); //cmd = 34
+    void i2cRead               (); //cmd = 35
+    void i2cTransfer           (); //cmd = 36
+
+    // One Wire
+    void owReset               (); //cmd = 41
+    void owSearch              (); //cmd = 42
+    void owWrite               (); //cmd = 43
+    void owRead                (); //cmd = 44
+    void owWriteBit            (byte b);
+    byte owReadBit             ();
+
+    //
+    // Board level timings, resolutions and reset.
+    //
+    void handshake                      ();  //cmd = 90
+    void resetState                     ();  //cmd = 91
+    void setRegisterDivider             ();  //cmd = 97
+    void setAnalogWriteResolution       ();  //cmd = 96
+    void setAnalogReadResolution        ();  //cmd = 97
+    void microDelay(uint32_t microseconds);  //cmd = 99, Platform specific microsecond delay
+    unsigned long lastTime;
+    unsigned long timeDiff;
+    byte registerDivider;
+
+    //
+    // Main loop input functions.
+    //
+    void parse(byte c);
+    void process();
+
+    // Parser state storage and utility functions.
+    byte *messageFragments[4];
+    byte fragmentIndex;
+    int charIndex;
+    boolean escaping;
+    void append(byte c);
+
+    // Parsed message storage.
+    byte cmdStr[4]; byte cmd;
+    byte pinStr[4]; byte pin;
+    byte valStr[4]; byte val;
+    byte auxMsg[AUX_SIZE];
+
+    //
+    // Flow control stuff.
+    //
+    // Notify the computer when the board has received half a serial buffer of bytes.
+    //
+    void rxNotify();
+    uint8_t rxBytes  = 0;
+    //
+    // ESP32 uses a 128 byte FIFO buffer for UART Rx. Notify every 63 bytes instead of 32
+    // so serial over native USB performs better.
+    //
+    // Using 63 instead of 64 since the ATmega32u4 (Leonardo) is limited to 63.
+    //
+    #ifdef ESP32
+      uint8_t rxNotifyLimit = 63;
+    #else
+      uint8_t rxNotifyLimit = 32;
+    #endif
+
+    //
+    // Tell the computer to halt or resume sending data to the board.
+    //
+    // Only use these if running a function on the board that disables interrupts for
+    // longer than a single serial character (~85us at 115,200 baud).
+    //
+    // If the function was initiated by the computer (eg. writing to a WS2812 strip), do
+    // not call sendHalt(). The computer should have halted transmission itself after sending
+    // the WS2812 command. Only call sendReady() after data is written out to the strip.
+    //
+    // If the function was initiated on the board (eg. New IR input triggered by an interrupt),
+    // call sendHalt() as soon as possible, then call sendReady() when done.
+    //
+    // sendReady() is also exposed through the API for diagnostics and testing.
+    //
+    void sendHalt();
+    void sendReady(); // cmd = 92
+
+    //
+    // Shared SPI listeners that can be used by either hardware or bit bang SPI.
+    // 
+    #if defined(DENKO_SPI) || defined(DENKO_SPI_BB)
+      // How many SPI lsiteners.
+      #define SPI_LISTENER_COUNT 4
+
+      // How to store a SPI listener.
+      struct SpiListener{
+        uint32_t clock;     // Clock rate if hardware SPI. If bit bang: bits[0..7] = clock pin, bits [8..15] = input pin.
+        uint8_t  select;    // Select pin.
+        uint8_t  settings;  // Settings mask as given in request.
+        uint8_t  length;    // Read length as given in request.
+        uint8_t  enabled;   // 0 = disabled, 1 = hardware, 2 = bit bang.
+      };
+      SpiListener spiListeners[SPI_LISTENER_COUNT];
+    #endif
+};