From c86c32893761af642a6a58ed41426ba92b2b51e8 Mon Sep 17 00:00:00 2001 From: Rob Canning Date: Sat, 5 Aug 2023 16:06:34 +0200 Subject: [PATCH] added code for esp32 --- .../SLIPEncodedBluetoothSerial.cpp | 180 +++++++++++++++ .../SLIPEncodedBluetoothSerial.h | 62 +++++ .../esp32_8_capacitive2OSC_Tetractys.ino | 212 ++++++++++++++++++ 3 files changed, 454 insertions(+) create mode 100644 esp32_8_capacitive2OSC_Tetractys/SLIPEncodedBluetoothSerial.cpp create mode 100644 esp32_8_capacitive2OSC_Tetractys/SLIPEncodedBluetoothSerial.h create mode 100644 esp32_8_capacitive2OSC_Tetractys/esp32_8_capacitive2OSC_Tetractys.ino diff --git a/esp32_8_capacitive2OSC_Tetractys/SLIPEncodedBluetoothSerial.cpp b/esp32_8_capacitive2OSC_Tetractys/SLIPEncodedBluetoothSerial.cpp new file mode 100644 index 0000000..94c3d3d --- /dev/null +++ b/esp32_8_capacitive2OSC_Tetractys/SLIPEncodedBluetoothSerial.cpp @@ -0,0 +1,180 @@ +#include "SLIPEncodedBluetoothSerial.h" +#include "BluetoothSerial.h" + +/* + CONSTRUCTOR + */ +//instantiate with the tranmission layer +//use BluetoothSerial +SLIPEncodedBluetoothSerial::SLIPEncodedBluetoothSerial(BluetoothSerial &s){ + serial = &s; + rstate = CHAR; +} + +static const uint8_t eot = 0300; +static const uint8_t slipesc = 0333; +static const uint8_t slipescend = 0334; +static const uint8_t slipescesc = 0335; +/* + SERIAL METHODS + */ +bool SLIPEncodedBluetoothSerial::endofPacket() +{ + if(rstate == SECONDEOT) + { + rstate = CHAR; + return true; + } + if (rstate==FIRSTEOT) + { + if(serial->available()) + { + uint8_t c =serial->peek(); + if(c==eot) + { + serial->read(); // throw it on the floor + } + } + rstate = CHAR; + return true; + } + return false; +} +int SLIPEncodedBluetoothSerial::available(){ +back: + int cnt = serial->available(); + + if(cnt==0) + return 0; + if(rstate==CHAR) + { + uint8_t c =serial->peek(); + if(c==slipesc) + { + rstate = SLIPESC; + serial->read(); // throw it on the floor + goto back; + } + else if( c==eot) + { + rstate = FIRSTEOT; + serial->read(); // throw it on the floor + goto back; + } + return 1; // we may have more but this is the only sure bet + } + else if(rstate==SLIPESC) + return 1; + else if(rstate==FIRSTEOT) + { + if(serial->peek()==eot) + { + rstate = SECONDEOT; + serial->read(); // throw it on the floor + return 0; + } + rstate = CHAR; + }else if (rstate==SECONDEOT) { + rstate = CHAR; + } + + return 0; + +} + +//reads a byte from the buffer +int SLIPEncodedBluetoothSerial::read(){ +back: + uint8_t c = serial->read(); + if(rstate==CHAR) + { + if(c==slipesc) + { + rstate=SLIPESC; + goto back; + } + else if(c==eot){ + + return -1; // xxx this is an error + } + return c; + } + else + if(rstate==SLIPESC) + { + rstate=CHAR; + if(c==slipescend) + return eot; + else if(c==slipescesc) + return slipesc; + else { + // insert some error code here + return -1; + } + + } + else + return -1; +} + +// as close as we can get to correct behavior +int SLIPEncodedBluetoothSerial::peek(){ + uint8_t c = serial->peek(); + if(rstate==SLIPESC) + { + if(c==slipescend) + return eot; + else if(c==slipescesc) + return slipesc; + } + return c; +} + +//the arduino and wiring libraries have different return types for the write function +#if defined(WIRING) || defined(BOARD_DEFS_H) + +//encode SLIP + void SLIPEncodedBluetoothSerial::write(uint8_t b){ + if(b == eot){ + serial->write(slipesc); + return serial->write(slipescend); + } else if(b==slipesc) { + serial->write(slipesc); + return serial->write(slipescesc); + } else { + return serial->write(b); + } +} +void SLIPEncodedBluetoothSerial::write(const uint8_t *buffer, size_t size) { while(size--) write(*buffer++); } +#else +//encode SLIP +size_t SLIPEncodedBluetoothSerial::write(uint8_t b){ + if(b == eot){ + serial->write(slipesc); + return serial->write(slipescend); + } else if(b==slipesc) { + serial->write(slipesc); + return serial->write(slipescesc); + } else { + return serial->write(b); + } +} +size_t SLIPEncodedBluetoothSerial::write(const uint8_t *buffer, size_t size) { size_t result=0; while(size--) result = write(*buffer++); return result; } + +#endif + +void SLIPEncodedBluetoothSerial::begin(String name){ + serial->begin(name); +} +//SLIP specific method which begins a transmitted packet +void SLIPEncodedBluetoothSerial::beginPacket() { serial->write(eot); } + +//signify the end of the packet with an EOT +void SLIPEncodedBluetoothSerial::endPacket(){ + serial->write(eot); + +} + +void SLIPEncodedBluetoothSerial::flush(){ + serial->flush(); +} diff --git a/esp32_8_capacitive2OSC_Tetractys/SLIPEncodedBluetoothSerial.h b/esp32_8_capacitive2OSC_Tetractys/SLIPEncodedBluetoothSerial.h new file mode 100644 index 0000000..c7404ae --- /dev/null +++ b/esp32_8_capacitive2OSC_Tetractys/SLIPEncodedBluetoothSerial.h @@ -0,0 +1,62 @@ +/* +Extends the Serial class to encode SLIP over serial +*/ + +#ifndef SLIPEncodedBluetoothSerial_h +#define SLIPEncodedBluetoothSerial_h + + +#include "Arduino.h" +#include +#include "BluetoothSerial.h" + + +class SLIPEncodedBluetoothSerial: public Stream{ + +private: + enum erstate {CHAR, FIRSTEOT, SECONDEOT, SLIPESC } rstate; + + //the serial port used + BluetoothSerial * serial; + + +public: + + //the serial port used + SLIPEncodedBluetoothSerial(BluetoothSerial & ); + + + int available(); + int read(); + int peek(); + void flush(); + + //same as Serial.begin + void begin(String); + + //SLIP specific method which begins a transmitted packet + void beginPacket(); + + //SLIP specific method which ends a transmittedpacket + void endPacket(); + // SLIP specific method which indicates that an EOT was received + bool endofPacket(); + + +//the arduino and wiring libraries have different return types for the write function +#if defined(WIRING) || defined(BOARD_DEFS_H) + void write(uint8_t b); + void write(const uint8_t *buffer, size_t size); + +#else + //overrides the Stream's write function to encode SLIP + size_t write(uint8_t b); + size_t write(const uint8_t *buffer, size_t size); + + //using Print::write; +#endif + +}; + + +#endif diff --git a/esp32_8_capacitive2OSC_Tetractys/esp32_8_capacitive2OSC_Tetractys.ino b/esp32_8_capacitive2OSC_Tetractys/esp32_8_capacitive2OSC_Tetractys.ino new file mode 100644 index 0000000..24b44b0 --- /dev/null +++ b/esp32_8_capacitive2OSC_Tetractys/esp32_8_capacitive2OSC_Tetractys.ino @@ -0,0 +1,212 @@ + +// esp32 capacitive touch interface ///////////////////////////////////////////////// +// rob canning 2023 ///////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////// + +const int ledPin = 23; +const int shiftLedPin = 25; +const int loopLedPin = 26; + +const int threshold = 30; // set the threshold +int ledState = LOW; // the current state of the output pin +int shiftLedState = HIGH; // the current state of the output pin +int loopLedState = LOW; // the current state of the output pin + +//#include // Serial Peripheral Interface +#include // allows you to communicate with I2C / TWI devices + +// Wi-Fi SETTINGS ///////////// +#include +const char* ssid = "zavod rizoma_EXT"; +const char* password = "cermozise"; + +// BROADCAST TO ALL IP / port +const IPAddress castIp = IPAddress(192,168,0,255); // 255 FOR BROADCAST +const int port = 57120; // SUPERCOLLIDERS DEFAULT INCOMING OSC PORT +bool connected = false; + +#include +WiFiUDP udp; + +// OSC and serial communications //////////////////////////// + +#define SERIAL_OSC +#define WIFI_OSC +#define BT_OSC + +#include +#include +#include + +/* OSC MSG channels */ +OSCBundle bundle; + +// SERIAL + #ifdef BOARD_HAS_USB_SERIAL +#include +SLIPEncodedUSBSerial SLIPSerial( thisBoardsSerialUSB ); +#else +#include +SLIPEncodedSerial SLIPSerial(Serial); +#endif + +// Bluetooth //////////////////////////////// + +#ifdef BT_OSC +#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED) +#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it +#endif + +#include +#include "BluetoothSerial.h" +#include "SLIPEncodedBluetoothSerial.h" + +BluetoothSerial SerialBT; +SLIPEncodedBluetoothSerial SLIPBTSerial(SerialBT); +#endif + +////////////////////////////////////////// +// CAPACITIVE TOUCH SETUP + +byte keys[] = {32, 33, 27, 14, 12, 13, 4, 15}; +byte KEYLEN = 8; +byte pressed[] = {0, 0, 0, 0, 0, 0, 0, 0}; +byte lastTouchState[] = {0, 0, 0, 0, 0, 0, 0, 0}; +byte touchState[] = {0, 0, 0, 0, 0, 0, 0, 0}; +byte lastDebounceTime[] = {0, 0, 0, 0, 0, 0, 0, 0}; +unsigned long debounceDelay = 50; // the debounce time; increase if the output flickers +int THRESH = 30; // capacitive noise threshold + +/////////////////////////////////////////// + +void setup() { + pinMode(ledPin, OUTPUT); //Define ledPin as output + pinMode(shiftLedPin, OUTPUT); //Define ledPin as output + pinMode(loopLedPin, OUTPUT); //Define ledPin as output + digitalWrite(ledPin, ledState); + digitalWrite(shiftLedPin, shiftLedState); + digitalWrite(loopLedPin, loopLedState); + Serial.begin(115200); + WiFi.mode(WIFI_AP); + connectWiFi(); + + const String macAddress = WiFi.macAddress(); ; + + // I2C init + Serial.println("Starting up I2C"); + Wire.begin(); + //Wire.setClock(400000); // 400kHz I2C clock. Comment this line if having compilation difficulties + // + Serial.println("starting I2C (Wire.begin)..."); + +#ifdef SERIAL_OSC + SLIPSerial.begin(115200); // set this as high as you can reliably run on your platform +#endif + +#ifdef BT_OSC + SerialBT.begin("grimore"); +#endif + + // touch pads + Serial.println("setting INPUT_PULLUP for capacitive touch pins... "); + + for(int i = 0; i < KEYLEN; i++) { + pinMode(keys[i], INPUT_PULLUP); + } +} // setup ends ////////////////////////////////////////////////// + +// MAIN LOOP ///////////////////////////////////////////////////////// + +void loop() { + sendCapacitive(); +} + +// FUNCTIONS ///////////////////////////////////////////// + +void connectWiFi(){ + // Connect to Wi-Fi network with SSID and password + Serial.print("Connecting to "); + Serial.println(ssid); + WiFi.begin(ssid, password); + while (WiFi.status() != WL_CONNECTED) { + delay(500); + Serial.print("."); + } + + // Print local IP address and start web server + // Serial.println(""); + Serial.println("WiFi connected."); + Serial.println("IP address: "); + Serial.println(WiFi.localIP()); +} + +// detect touch events and send over OSC ////////////// + +void sendCapacitive(void){ + + for(int i = 0; i < KEYLEN; i++) { + // read the state of the touch pad + pressed[i] = touchRead(keys[i]); + Serial.println(pressed[i]); + + if (pressed[i] < threshold) { + pressed[i] = HIGH; + } else{ + pressed[i] = LOW; + } + + // If the pin is touched: + if (pressed[i] != lastTouchState[i]) { + // reset the debouncing timer + lastDebounceTime[i] = millis(); + } + + if ((millis() - lastDebounceTime[i]) > debounceDelay) { + // whatever the reading is at, it's been there for longer than the debounce + // delay, so take it as the actual current state: + + // if the touch state has changed: + if (pressed[i] != touchState[i]) { + touchState[i] = pressed[i]; + // Serial.println("-------------------------------------- "); + digitalWrite(ledPin, HIGH); // toggle the led on any touch + + // only toggle the LED if the new touch state is high + if (touchState[i] == HIGH) { + ledState = !ledState; + + OSCMessage msg("/touch"); + msg.add(WiFi.macAddress().c_str()); // mac address of sender + msg.add((int32_t)i); // send which sensor was touched + + #ifdef WIFI_OSC + udp.beginPacket(castIp, port); + //bundle.send(udp); + msg.send(udp); + udp.endPacket(); + #endif + + String cap = "val for key num: " + String(i) + " === " + String(pressed[i]); + Serial.println(""); Serial.println(cap); + } + + if (touchState[7] == HIGH) { + digitalWrite(loopLedPin, loopLedState); + loopLedState = !loopLedState; + } + if (touchState[8] == HIGH) { + digitalWrite(shiftLedPin, shiftLedState); + shiftLedState = !shiftLedState; + } + + } + } + + // set the LED: + digitalWrite(ledPin, ledState); + // save the reading. Next time through the loop, it'll be the lastTouchState: + lastTouchState[i] = pressed[i]; + + } + +} //////////////////