denko 0.13.0

data/src/lib/DenkoCoreIO.cpp

@@ -0,0 +1,322 @@
+#include "Denko.h"
+
+// CMD = 00
+// Set up a single pin for the desired type of input or output.
+void Denko::setMode(byte p, byte m) {
+  //
+  // Use the lowest 3 bits of m to set different input/output modes, and enable 
+  // or disable needed peripherals on different platforms.
+  //
+  // OUTPUT MODES:  
+  // 000 = Digital Output
+  // 010 = PWM Ouptut
+  // 100 = DAC Output
+  //
+  // INPUT MODES
+  // 001 = Digital Input
+  // 011 = Digital Input with internal pulldown if available.
+  // 101 = Digital Input with internal pullup if available.
+  // 111 = Digital Input/Output (ESP32 Only?)
+  m = m & 0b00000111;
+
+  #if defined(ESP32) && defined(SOC_DAC_SUPPORTED)
+      // Free the LEDC channel if leaving PWM mode.
+    if (m != 0b010) releaseLEDC(p);
+    
+    // Disable attached DAC if leaving DAC mode.
+    if (m != 0b100) dacDisable(p);
+  #endif
+      
+  // On the SAMD21, mode needs to be INPUT when using the DAC.
+  #ifdef __SAMD21G18A__
+    if (m == 0b100){
+      pinMode(p, INPUT);
+      return;
+    }
+  #endif
+  
+  // Handle the named INPUT_* states on boards implementing them.
+  #ifdef INPUT_PULLDOWN
+  if (m == 0b011) {
+    pinMode(p, INPUT_PULLDOWN);
+    return;
+  }
+  #endif
+  
+  #ifdef INPUT_OUTPUT
+  if (m == 0b111) {
+    pinMode(p, INPUT_OUTPUT);
+    return;
+  }
+  #endif
+  
+  #ifdef INPUT_PULLUP
+  if (m == 0b101) {
+    pinMode(p, INPUT_PULLUP);
+    return;
+  }
+  #endif
+  
+  // Handle the standard INPUT and OUTPUT states.
+  // Allows INPUT_* to fallback to INPUT when not implemented.
+  if (bitRead(m, 0) == 0) {
+    pinMode(p, OUTPUT);
+  } else {
+    pinMode(p, INPUT);
+  }
+
+  // Write high to set pullup for AVRs that use this method.
+  #ifdef __AVR__
+    if (m == 0b101) digitalWrite(p, HIGH);
+  #endif
+}
+
+// CMD = 01
+// Write a digital output pin. 0 for LOW, 1 or >0 for HIGH.
+void Denko::dWrite(byte p, byte v, boolean echo) {
+
+  #ifdef __SAMD21G18A__
+    // digitalWrite doesn't implicitly disconnect PWM on the SAMD21.
+    pinMode(p, OUTPUT);
+  #endif
+
+  #ifdef ESP32
+    // Disconnect any DAC or LEDC peripheral the pin was using.
+    // Without this, setting GPIO level has no effect.
+    // NOTE: Does not release the LEDC channel or config. Can reattach in aWrite.
+    #if defined(SOC_DAC_SUPPORTED)
+      dacDisable(p);
+    #endif
+    ledcDetachPin(p);
+  #endif
+    
+  if (v == 0) {
+    digitalWrite(p, LOW);
+  }
+  else {
+    digitalWrite(p, HIGH);
+  }
+  if (echo) coreResponse(p, v);
+}
+
+// CMD = 02
+// Read a digital input pin. 0 for LOW, 1 for HIGH.
+byte Denko::dRead(byte p) {
+  byte rval = digitalRead(p);
+  coreResponse(p, rval);
+  return rval;
+}
+
+// CMD = 03
+// Write an analog output pin. 0 for LOW, up to 255 for HIGH @ 8-bit resolution.
+void Denko::pwmWrite(byte p, int v, boolean echo) {
+  #ifdef ESP32
+    // Assign new or find existing LEDC channel for this pin.
+    byte channel = ledcChannel(p);
+    
+    // Reattach the pin in case dWrite detached it.
+    ledcAttachPin(p, channel);
+    
+    ledcWrite(channel, v);
+  #else
+    analogWrite(p,v);
+  #endif
+
+  if (echo) coreResponse(p, v);
+}
+
+//
+// Manage ESP32 LEDC channels so we can do PWM write.
+//
+#ifdef ESP32
+byte Denko::ledcChannel(byte p) {
+  // Search for enabled LEDC channel with given pin and use that if found.
+  for (int i = LEDC_CHANNEL_COUNT -1; i > 0; i--){
+    if ((ledcPins[i][0] == 1) && (ledcPins[i][1] == p)){
+      return i;
+    }
+  }
+
+  // We didn't find a channel to reuse.
+  for (int i = LEDC_CHANNEL_COUNT -1; i > 0; i--){
+    // If the channel isn't initialized and it isn't marked as used, use it.
+    // should find some way to check if the channel itslef is being used
+    if ((ledcPins[i][0] == 0)) {
+      assignLEDC(i, p);
+      return i;
+    }
+  }
+  
+  // Return a useless channel if none available.
+  return 255;
+};
+
+// Assign a LEDC channel to a pin and save it.
+byte Denko::assignLEDC(byte channel, byte p){
+  // First 8 channels: up to 40Mhz @ 16-bits
+  // Last 8 channels: up to 500kHz @ 13-bits
+  // Just use similar settings to ATmega for now.
+  ledcSetup(channel, 1000, 8);
+  ledcAttachPin(p, channel);
+  
+  // Save the pin and mark it as in use.
+  ledcPins[channel][0] = 1;
+  ledcPins[channel][1] = p;
+  return channel;
+}
+
+// Release a LEDC channel when done with it.
+void Denko::releaseLEDC(byte p){
+  // Detach the pin from the channel.
+  ledcDetachPin(p);
+  
+  // Mark any channel associated with the pin as unused.
+  for (int i = LEDC_CHANNEL_COUNT -1; i > 0; i--){
+    if (ledcPins[i][1] == p) ledcPins[i][0] = 0;
+  }
+}
+
+// Clear all the LEDC channels on reset.
+void Denko::clearLedcChannels(){
+  for (int i = LEDC_CHANNEL_COUNT -1; i > 0; i--){
+    // Stop the channel if it was still enabled.
+    if (ledcPins[i][0] != 0) ledcDetachPin(ledcPins[i][1]);
+    
+    // Mark the channel as unused.
+    ledcPins[i][0] = 0;
+  }
+}
+#endif
+
+// CMD = 04
+// Write to a DAC (digital to analog converter) pin.
+// This outputs a true analog resolution, unlike PWM.
+void Denko::dacWrite(byte p, int v, boolean echo) {
+  #if defined(ESP32) && defined(SOC_DAC_SUPPORTED)
+    ::dacWrite(p, v);
+  #endif
+    
+  #if defined(__SAM3X8E__) || defined(__SAMD21G18A__)
+    analogWrite(p, v);
+  #endif
+}
+
+// CMD = 05
+// Read an analog input pin. 0 for LOW, up to 1023 for HIGH @ 10-bit resolution.
+int Denko::aRead(byte p) {
+  int rval = analogRead(p);
+  coreResponse(p, rval);
+  return rval;
+}
+
+// Simple response for core listeners, or any response with the pin:value pattern.
+void Denko::coreResponse(int p, int v){
+  stream->print(p);
+  stream->print(':');
+  stream->print(v);
+  stream->print('\n');
+}
+
+// CMD = 06
+// Enable, disable and change settings for core (digital/analog) listeners.
+// See Denko.h for settings and mask layout.
+void Denko::setListener(byte p, boolean enabled, byte analog, byte exponent, boolean local){
+  // Pre-format the settings into a mask byte.
+  byte settingMask = 0;
+  if (enabled)  settingMask = settingMask | 0b10000000;
+  if (analog)   settingMask = settingMask | 0b1000000;
+  if (local)    settingMask = settingMask | 0b0010000;
+  settingMask = settingMask | exponent;
+
+  // If an existing listener was already using this pin, just update settings.
+  boolean found = false;
+  for(byte i=0; i<PIN_COUNT; i++){
+    if (listeners[i][1] == p){
+      found = true;
+      if (bitRead(listeners[i][0], 4) == 0) {
+        listeners[i][0] = settingMask;
+      } else if(local) {
+        // Only allow local code to update local listeners.
+        listeners[i][0] = settingMask;
+      }
+      break;
+    }
+  }
+
+  // If this pin wasn't used before, take the lowest index inactive listener.
+  if (!found){
+    for(byte i=0; i<PIN_COUNT; i++){
+      if (bitRead(listeners[i][0], 7) == 0){
+        listeners[i][0] = settingMask;
+        listeners[i][1] = p;
+        break;
+      }
+    }
+  }
+
+  // Keep track of how far into the listener array to go when updating.
+  findLastActiveListener();
+}
+
+// Runs once on every loop to update necessary listeners.
+void Denko::updateCoreListeners() {
+  for (byte i = 0; i <= lastActiveListener; i++){
+    // Check if active.
+    if (bitRead(listeners[i][0], 7) == 1){
+      // Check if to update it on this tick.
+	    // Divider exponent is last 3 bits of settings.
+      byte exponent = listeners[i][0] & 0B00000111;
+      byte divider = dividerMap[exponent];
+      if(tickCount % divider == 0){
+        // Check if digital or analog.
+        if (bitRead(listeners[i][0], 6) == 1){
+          analogListenerUpdate(i);
+        } else {
+          digitalListenerUpdate(i);
+        }
+      }
+    }
+  }
+}
+
+// Handle a single analog listener when it needs to read.
+void Denko::analogListenerUpdate(byte i){
+  int rval = analogRead(listeners[i][1]);
+  analogListenCallback(listeners[i][1], rval);
+  coreResponse(listeners[i][1], rval);
+}
+
+// Handle a single digital listener when it needs to read.
+void Denko::digitalListenerUpdate(byte i){
+  byte rval = digitalRead(listeners[i][1]);
+
+  if (rval != bitRead(listeners[i][0], 5)){
+    // State for digital listeners is stored in byte 5 of the listener itself.
+    bitWrite(listeners[i][0], 5, rval);
+    digitalListenCallback(listeners[i][1], rval);
+    coreResponse(listeners[i][1], rval);
+  }
+}
+
+// Gets called by Denko::reset to clear all listeners set by the remote client.
+void Denko::clearCoreListeners(){
+  for (int i = 0; i < PIN_COUNT; i++){
+    // Only clear listeners if they were started by the remote client.
+    // Leaves listeners started by local code running.
+    if (bitRead(listeners[i][0], 4) == 0) {
+      listeners[i][0] = 0;
+      listeners[i][1] = 0;
+    }
+  }
+  findLastActiveListener();
+}
+
+// Track the last active listener whenever changes are made.
+// Call this after setting or clearing any listeners.
+void Denko::findLastActiveListener(){
+  for(byte i=0; i<PIN_COUNT; i++){
+    if (bitRead(listeners[i][0], 7) == 1){
+      lastActiveListener = i;
+    }
+  }
+}

data/src/lib/DenkoDefines.h

@@ -0,0 +1,116 @@
+// If using Wi-Fi or Ethernet shield, uncomment this to let the SPI library know.
+// #define TXRX_SPI
+
+// Uncomment this line to enable debugging mode.
+// #define debug
+
+// Define the version of Denko the board was flashed with so we can verify in Ruby.
+#define DENKO_VERSION __VERSION__
+
+// Uncomment these to include features beyond core features.
+// #define DENKO_ONE_WIRE
+// #define DENKO_TONE
+// #define DENKO_SPI_BB
+// #define DENKO_I2C
+// #define DENKO_SPI
+// #define DENKO_SERVO
+// #define DENKO_UART
+// #define DENKO_UART_BB
+// #define DENKO_IR_OUT
+// #define DENKO_LED_ARRAY
+
+// Include libraries for specific LED array protocols.
+#ifdef DENKO_LED_ARRAY
+  #define DENKO_LED_WS2812
+#endif
+
+// Define number of pins to set up listener storage.
+#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
+  #define PIN_COUNT 70
+#elif defined(__SAM3X8E__)
+  #define PIN_COUNT 72
+#elif defined(ESP8266)
+  #define PIN_COUNT 18
+#elif defined(ESP32)
+  #define PIN_COUNT 40
+#elif defined(ARDUINO_ARCH_RP2040)
+  #define PIN_COUNT 26
+#else
+  #define PIN_COUNT 22
+#endif
+
+// No EEPROM on the Due or Zero.
+#if !defined(__SAM3X8E__) && !defined(__SAMD21G18A__)
+  #define EEPROM_PRESENT
+  #include <EEPROM.h>
+#endif
+
+// Emulate 512 bytes of EEPROM on ESP chips and the RP2040.
+#if defined(ESP8266) || defined(ESP32) || defined(ARDUINO_ARCH_RP2040)
+#  define EEPROM_EMULATED
+#  define EMULATED_EEPROM_LENGTH 512
+#endif
+
+// Figure out how many LEDC channels are available on ESP32 boards.
+#ifdef ESP32
+  #define LEDC_CHANNEL_COUNT 16
+#endif
+
+// Filter for boards that can set their analog write resolution.
+#if defined(__SAM3X8E__) || defined(__SAMD21G18A__) || defined(ESP32) || defined(ARDUINO_ARCH_RP2040) || defined(ESP8266)
+  #define WRITE_RESOLUTION_SETTER
+#endif
+
+// Filter for boards that can set their analog read resolution.
+#if defined(__SAM3X8E__) || defined(__SAMD21G18A__) || defined(ESP32) || defined(ARDUINO_ARCH_RP2040)
+  #define READ_RESOLUTION_SETTER
+#endif
+
+// Figure out how many open (not connected to a USB port) hardware UARTS there are on the board.
+#ifdef DENKO_UART
+  // Look for TX pin definitions on RP2040.
+  #if defined(RP2040)
+    #if   defined(PIN_SERIAL2_TX)
+      #define DENKO_UARTS 2
+    #elif defined(PIN_SERIAL_1_TX)
+      #define DENKO_UARTS 1
+    #endif
+  
+  // ESP32 has either 1 or 2 extra UARTS enabled, depending on chip and board.
+  #elif defined(ESP32)
+    #if SOC_UART_NUM == 3
+      #define DENKO_UARTS 2
+    #elif SOC_UART_NUM == 2
+      #define DENKO_UARTS 1
+    #endif  
+
+  // ESP8266 has a single open transmit-only UART.
+  #elif defined(ESP8266) && defined(SERIAL_PORT_HARDWARE_OPEN)
+    #define DENKO_UARTS 1
+
+  // This works for all the Atmel cores.
+  #else
+    #if defined(SERIAL_PORT_HARDWARE3)
+      #define DENKO_UARTS 3
+    #elif defined(SERIAL_PORT_HARDWARE2)
+      #define DENKO_UARTS 2
+    #elif defined(SERIAL_PORT_HARDWARE1)
+      #define DENKO_UARTS 1
+    #endif
+  #endif
+#endif
+
+#ifdef DENKO_UART_BB
+  #include <SoftwareSerial.h>
+#endif
+
+// If no high usage features (core sketch), 32 + 16.
+#if !defined(DENKO_SHIFT) && !defined (DENKO_I2C) && !defined(DENKO_SPI) && !defined(DENKO_UARTS) && !defined(DENKO_UART_BB) && !defined(DENKO_IR_OUT) && !defined(DENKO_LED_ARRAY)
+  #define AUX_SIZE 48
+// If using IR_OUT or LED_ARRAY, and not on the ATmega168, 512 + 16.
+#elif (defined(DENKO_IR_OUT) || defined(DENKO_LED_ARRAY)) && !defined(__AVR_ATmega168__)
+  #define AUX_SIZE 528
+// Default aux message size to 256 + 16 bytes.
+#else
+  #define AUX_SIZE 272
+#endif

data/src/lib/DenkoEEPROM.cpp

@@ -0,0 +1,64 @@
+//
+// Basic EEPROM read and write functionality.
+//
+#include "Denko.h"
+
+#ifdef EEPROM_PRESENT
+// CMD = 6
+// Read from the microcontroller's EEPROM.
+//
+// pin         = empty
+// val         = number of bytes to read
+// auxMsg[0-1] = start address
+//
+void Denko::eepromRead(){
+  if (val > 0) {
+	  #if defined(EEPROM_EMULATED)
+	    EEPROM.begin(EMULATED_EEPROM_LENGTH);
+    #endif
+	  
+    uint16_t startAddress = ((uint16_t)auxMsg[1] << 8) | auxMsg[0];
+
+    // Use pin 254 as a "virtual pin" for the built-in EEPROM.
+    stream->print("254");
+    stream->print(':');
+    stream->print(startAddress);
+    stream->print('-');
+
+    for (byte i = 0;  (i < val);  i++) {
+      stream->print(EEPROM.read(startAddress + i));
+      stream->print((i+1 == val) ? '\n' : ',');
+    }
+	
+  	#if defined(EEPROM_EMULATED)
+  	  EEPROM.end();
+  	#endif
+  }
+}
+
+// CMD = 7
+// Write to the microcontroller's EEPROM.
+//
+// pin         = empty
+// val         = number of bytes to write
+// auxMsg[0-1] = start address
+// auxMsg[2+]  = bytes to write
+//
+void Denko::eepromWrite(){
+  if (val > 0) {
+  	#if defined(EEPROM_EMULATED)
+  	  EEPROM.begin(EMULATED_EEPROM_LENGTH);
+  	#endif
+	  
+    uint16_t startAddress = ((uint16_t)auxMsg[1] << 8) | auxMsg[0];
+
+    for (byte i = 0;  (i < val);  i++) {
+	  EEPROM.write(startAddress + i, auxMsg[2+i]);
+    }
+	
+  	#if defined(EEPROM_EMULATED)
+  	  EEPROM.end();
+  	#endif
+  }
+}
+#endif

data/src/lib/DenkoI2C.cpp

@@ -0,0 +1,155 @@
+//
+// This file adds to the Denko class only if DENKO_I2C is defined in Denko.h.
+//
+#include "Denko.h"
+#ifdef DENKO_I2C
+
+#include <Wire.h>
+
+bool i2cStarted = false;
+
+// Only start the I2C interface if not already started.
+// Lazy initialization in case user wants to use I2C pins for something else.
+void Denko::i2cBegin() {
+  if (!i2cStarted) {
+    Wire.begin();
+    i2cStarted = true;
+  }
+}
+
+// End the I2C interface.
+// This is mostly used as a Reset in Denko::handshake.
+void Denko::i2cEnd(){
+  // ESP8266 core does not define Wire.end()
+  #ifndef ESP8266
+    Wire.end();
+  #endif
+  i2cStarted = false;
+}
+
+// Configurable I2C speed each time read or write is called.
+void Denko::i2cSetSpeed(uint8_t code) {
+  switch(code) {
+    case 0:  Wire.setClock(100000);  break;
+    case 1:  Wire.setClock(400000);  break;
+    case 2:  Wire.setClock(1000000); break;
+    case 3:  Wire.setClock(3400000); break;
+    default: Wire.setClock(100000);  break;
+  }
+}
+
+// CMD = 33
+// Ask each address for a single byte to see if it exists on the bus.
+void Denko::i2cSearch() {
+  byte error;
+  uint8_t addr;
+  i2cBegin();
+  stream->print(SDA);
+
+  // Only addresses from 0x08 to 0x77 are usable (8 to 127).
+  for (addr = 0x08; addr < 0x78;  addr++) {
+    Wire.beginTransmission(addr);
+    error = Wire.endTransmission();
+    if (error == 0){
+      stream->print(':'); stream->print(addr);
+    }
+  }
+  stream->print('\n');
+}
+
+// CMD = 34
+// Write to an I2C device over a harwdare I2C interface.
+//
+// pin
+//  bits 0..6 = Device address
+//  bit  7    = Send stop condition. 0 = no, repeated start. 1 = yes.
+//
+// val
+//  bits 0..4 = Data length. NOTE: maximum of 32. Anything more is ignored.
+// 
+// auxMsg[0]  = I2C settings. Just speed selection for now.
+//
+// auxMsg[1]+ = data
+//
+void Denko::i2cWrite() {
+  // Get parameters from message.
+  uint8_t address     =  (uint8_t)pin & 0b01111111;
+  uint8_t dataLength  =  (uint8_t)val;
+
+  // Limit to 32 bytes.
+  if (dataLength > 32) dataLength = 32;
+
+  i2cBegin();
+  i2cSetSpeed(auxMsg[0]);
+
+  Wire.beginTransmission(address);
+  Wire.write(&auxMsg[1], dataLength);
+
+  // No repeated start on ESP32.
+  #if defined(ESP32)
+    Wire.endTransmission();
+  #else
+    uint8_t sendStop = (uint8_t)pin >> 7;
+    Wire.endTransmission(sendStop);
+  #endif
+}
+
+// CMD = 35
+// Read from an I2C device over a harwdare I2C interface.
+//
+// pin
+//  bits 0..6 = Device address
+//  bit  7    = Send stop condition. 0 = no, repeated start. 1 = yes.
+//
+// val
+//  bits 0..4 = Data length. NOTE: maximum of 32. Anything more is ignored.
+//
+// auxMsg[0]  = I2C settings. Just speed selection for now.
+//
+// auxMsg[1]  = If > 0, write a register address of that many bytes before reading.
+// auxMsg[2]+ = Register address bytes in order.
+//
+void Denko::i2cRead() {
+  // Get parameters from message.
+  uint8_t address         = (uint8_t)pin & 0b01111111;
+  uint8_t sendStop        = (uint8_t)pin >> 7;
+  uint8_t dataLength      = (uint8_t)val;
+
+  // Limit to 32 bytes.
+  if (dataLength > 32) dataLength = 32;
+
+  i2cBegin();
+  i2cSetSpeed(auxMsg[0]);
+  
+  // Optionally write up to a 4 byte register address before reading.
+  if ((auxMsg[1] > 0) && (auxMsg[1] < 5)) {
+    Wire.beginTransmission(address);
+    Wire.write(&auxMsg[2], auxMsg[1]);
+    Wire.endTransmission(sendStop);
+  }
+  
+  // ESP32 crashes if requestFrom gets the 3rd arg.
+  #if defined(ESP32)  
+    Wire.requestFrom(address, dataLength);
+  #else
+    Wire.requestFrom(address, dataLength, sendStop);
+  #endif
+  
+  // Send data as if coming from SDA pin. Prefix with device adddress.
+  // Fail silently if no bytes read / invalid device address.
+  stream->print(SDA); stream->print(':');
+  stream->print(address); stream->print('-');  
+  while(Wire.available()){
+    stream->print(Wire.read());
+    stream->print(',');
+  }
+  stream->print('\n');
+
+  // No repeated start on ESP32.
+  #if defined(ESP32)
+    Wire.endTransmission();
+  #else
+    Wire.endTransmission(sendStop);
+  #endif
+}
+#endif

data/src/lib/DenkoIROut.cpp

@@ -0,0 +1,33 @@
+//
+// This file adds to the Denko class only if DENKO_IR_OUT is defined in Denko.h.
+//
+#include "Denko.h"
+#if defined(DENKO_IR_OUT) && !defined(ESP8266) && !defined(ESP32)
+
+// Save memory by disabling receiver.
+#undef RAW_BUFFER_LENGTH
+#define RAW_BUFFER_LENGTH 0
+#define DISABLE_CODE_FOR_RECEIVER
+
+// Save more memory.
+#define IR_REMOTE_DISABLE_RECEIVE_COMPLETE_CALLBACK true
+#define EXCLUDE_UNIVERSAL_PROTOCOLS
+#define EXCLUDE_EXOTIC_PROTOCOLS
+#define NO_LED_FEEDBACK_CODE
+
+#include <IRremote.hpp>
+
+// CMD = 16
+// Send an infrared signal.
+void Denko::irSend(){
+  // Byte 1+ of auxMsg is already little-endian uint16 pulses.
+  uint16_t *pulseArray = reinterpret_cast<uint16_t *>(auxMsg + 1);
+  
+  // Dynamically set the sending pin. Needs to be PWM capable.
+  IrSender.setSendPin(pin);
+
+  // auxMsg[0] contains number of uint16_t
+  // Val contains frequency
+  IrSender.sendRaw(pulseArray, auxMsg[0], val);
+}
+#endif