Wippersnapper.h

Go to the documentation of this file.

#ifndef WIPPERSNAPPER_H
#define WIPPERSNAPPER_H

// Cpp STD
#include <math.h>

#include <vector>

// Nanopb dependencies
#include <nanopb/pb_common.h>
#include <nanopb/pb_decode.h>
#include <nanopb/pb_encode.h>
#include <pb.h>

#include <wippersnapper/description/v1/description.pb.h> // description.proto
#include <wippersnapper/signal/v1/signal.pb.h>           // signal.proto

// External libraries
#include "Adafruit_MQTT.h"      // MQTT Client
#include "Adafruit_SleepyDog.h" // Watchdog
#include "Arduino.h"            // Wiring
#include <SPI.h>                // SPI

// Wippersnapper API Helpers
#include "Wippersnapper_Boards.h"
#include "components/statusLED/Wippersnapper_StatusLED.h"
#include "provisioning/ConfigJson.h"

#define WS_DEBUG          
#define WS_PRINTER Serial 

// Define actual debug output functions when necessary.
#ifdef WS_DEBUG

#ifdef ARDUINO_ARCH_ESP8266
// ESP8266: Use F() macro to store string literals in Flash (PROGMEM) instead
// of RAM. This saves precious RAM on memory-constrained ESP8266 devices.
// NOTE: WS_DEBUG_PRINT/PRINTLN only accept string literals on ESP8266.
// Use WS_DEBUG_PRINTVAR/PRINTLNVAR for variables.
#define WS_DEBUG_PRINT(x)                                                      \
  { WS_PRINTER.print(F(x)); } 
#define WS_DEBUG_PRINTLN(x)                                                    \
  { WS_PRINTER.println(F(x)); } 
#else
// Other platforms: Standard variadic macros
#define WS_DEBUG_PRINT(...)                                                    \
  { WS_PRINTER.print(__VA_ARGS__); } 
#define WS_DEBUG_PRINTLN(...)                                                  \
  { WS_PRINTER.println(__VA_ARGS__); } 
#endif

// Variable printing macros - use for non-string-literal arguments
#define WS_DEBUG_PRINTVAR(...)                                                 \
  { WS_PRINTER.print(__VA_ARGS__); } 
#define WS_DEBUG_PRINTLNVAR(...)                                               \
  { WS_PRINTER.println(__VA_ARGS__); } 
#define WS_DEBUG_PRINTHEX(...)                                                 \
  { WS_PRINTER.print(__VA_ARGS__, HEX); } 

#else
#define WS_DEBUG_PRINT(...)                                                    \
  {} 
#define WS_DEBUG_PRINTLN(...)                                                  \
  {} 
#define WS_DEBUG_PRINTVAR(...)                                                 \
  {} 
#define WS_DEBUG_PRINTLNVAR(...)                                               \
  {} 
#define WS_DEBUG_PRINTHEX(...)                                                 \
  {} 
#define WS_DEBUG_HEAP(label)                                                   \
  {} 
#endif

#define WS_DELAY_WITH_WDT(timeout)                                             \
  {                                                                            \
    unsigned long start = millis();                                            \
    while (millis() - start < timeout) {                                       \
      delay(10);                                                               \
      yield();                                                                 \
      feedWDT();                                                               \
      if (millis() < start) {                                                  \
        start = millis(); /* if rollover */                                    \
      }                                                                        \
    }                                                                          \
  } 

/**************************************************************************/
/**************************************************************************/
#define RETRY_FUNCTION_UNTIL_TIMEOUT(func, result_type, result_var, condition, \
                                     timeout, interval, ...)                   \
  {                                                                            \
    unsigned long startTime = millis();                                        \
    while (millis() - startTime < timeout) {                                   \
      result_type result_var = func(__VA_ARGS__);                              \
      if (condition(result_var)) {                                             \
        break;                                                                 \
      }                                                                        \
      if (startTime > millis()) {                                              \
        startTime = millis(); /* if rollover */                                \
      }                                                                        \
      WS_DELAY_WITH_WDT(interval);                                             \
    }                                                                          \
  } 

// Wippersnapper pb helpers
#include <nanopb/ws_pb_helpers.h>

// Wippersnapper components
#include "components/analogIO/Wippersnapper_AnalogIO.h"
#include "components/digitalIO/Wippersnapper_DigitalGPIO.h"
#include "components/i2c/WipperSnapper_I2C.h"

// Includes for ESP32-only
#ifdef ARDUINO_ARCH_ESP32
#include "components/ledc/ws_ledc.h"
#include <Esp.h>
#endif

#include "components/display/controller.h"
#include "components/ds18x20/ws_ds18x20.h"
#include "components/pixels/ws_pixels.h"
#include "components/pwm/ws_pwm.h"
#include "components/servo/ws_servo.h"
#include "components/uart/ws_uart.h"

#if defined(USE_TINYUSB)
#include "provisioning/tinyusb/Wippersnapper_FS.h"
#endif

#if defined(USE_LITTLEFS)
#include "provisioning/littlefs/WipperSnapper_LittleFS.h"
#endif

#define WS_VERSION                                                             \
  "1.0.0-beta.127" 

// Reserved Adafruit IO MQTT topics
#define TOPIC_IO_THROTTLE "/throttle" 
#define TOPIC_IO_ERRORS "/errors"     

// Reserved Wippersnapper topics
#define TOPIC_WS "/wprsnpr/"      
#define TOPIC_INFO "/info/"       
#define TOPIC_SIGNALS "/signals/" 
#define TOPIC_I2C "/i2c"          
#define TOPIC_DISPLAY "/display"  
#define MQTT_TOPIC_PIXELS_DEVICE                                               \
  "/signals/device/pixel" 
#define MQTT_TOPIC_PIXELS_BROKER                                               \
  "/signals/broker/pixel" 


typedef enum {
  WS_IDLE = 0,               // Waiting for connection establishement
  WS_NET_DISCONNECTED = 1,   // Network disconnected
  WS_DISCONNECTED = 2,       // Disconnected from Adafruit IO
  WS_FINGERPRINT_UNKOWN = 3, // Unknown WS_SSL_FINGERPRINT

  WS_NET_CONNECT_FAILED = 10,  // Failed to connect to network
  WS_CONNECT_FAILED = 11,      // Failed to connect to Adafruit IO
  WS_FINGERPRINT_INVALID = 12, // Unknown WS_SSL_FINGERPRINT
  WS_AUTH_FAILED = 13, // Invalid Adafruit IO login credentials provided.
  WS_SSID_INVALID =
      14, // SSID is "" or otherwise invalid, connection not attempted

  WS_NET_CONNECTED = 20,           // Connected to Adafruit IO
  WS_CONNECTED = 21,               // Connected to network
  WS_CONNECTED_INSECURE = 22,      // Insecurely (non-SSL) connected to network
  WS_FINGERPRINT_UNSUPPORTED = 23, // Unsupported WS_SSL_FINGERPRINT
  WS_FINGERPRINT_VALID = 24,       // Valid WS_SSL_FINGERPRINT
  WS_BOARD_DESC_INVALID = 25,      // Unable to send board description
  WS_BOARD_RESYNC_FAILED = 26      // Board sync failure
} ws_status_t;

typedef enum {
  WS_MQTT_CONNECTED = 0,           // Connected
  WS_MQTT_INVALID_PROTOCOL = 1,    // Invalid mqtt protocol
  WS_MQTT_INVALID_CID = 2,         // Client id rejected
  WS_MQTT_SERVICE_UNAVALIABLE = 3, // Malformed user/pass
  WS_MQTT_INVALID_USER_PASS = 4,   // Unauthorized access to resource
  WS_MQTT_UNAUTHORIZED = 5,        // MQTT service unavailable
  WS_MQTT_THROTTLED = 6,           // Account throttled
  WS_MQTT_BANNED = 7               // Account banned
} ws_mqtt_status_t;

typedef enum {
  WS_BOARD_DEF_IDLE,
  WS_BOARD_DEF_SEND_FAILED,
  WS_BOARD_DEF_SENT,
  WS_BOARD_DEF_OK,
  WS_BOARD_DEF_INVALID,
  WS_BOARD_DEF_UNSPECIFIED
} ws_board_status_t;

typedef enum {
  FSM_NET_IDLE,
  FSM_NET_CONNECTED,
  FSM_MQTT_CONNECTED,
  FSM_NET_CHECK_MQTT,
  FSM_NET_CHECK_NETWORK,
  FSM_NET_ESTABLISH_NETWORK,
  FSM_NET_ESTABLISH_MQTT,
} fsm_net_t;

#ifdef ARDUINO_ARCH_RP2040
#define WS_WDT_TIMEOUT 8388 
#else
#define WS_WDT_TIMEOUT 60000 
#endif

#define WS_MAX_ALT_WIFI_NETWORKS 3 
/* MQTT Configuration */
#define WS_BROKER_KEEPALIVE_MS                                                 \
  11000 
#define WS_DEVICE_PING_MS                                                      \
  5000 

#define WS_MQTT_MAX_PAYLOAD_SIZE                                               \
  512 

class Wippersnapper_DigitalGPIO;
class Wippersnapper_AnalogIO;
class Wippersnapper_FS;
class WipperSnapper_LittleFS;
#ifdef ARDUINO_ARCH_ESP32
class ws_ledc;
#endif
class WipperSnapper_Component_I2C;
class ws_servo;
class ws_pwm;
class ws_ds18x20;
class ws_pixels;
class ws_uart;
class DisplayController;

/**************************************************************************/
/**************************************************************************/
class Wippersnapper {
public:
  Wippersnapper();
  virtual ~Wippersnapper();

  void provision();

  bool lockStatusNeoPixel; 
  bool lockStatusDotStar;  
  bool lockStatusLED;      
  float status_pixel_brightness =
      STATUS_PIXEL_BRIGHTNESS_DEFAULT; 

  virtual void set_user_key();
  virtual void set_ssid_pass(const char *ssid, const char *ssidPassword);
  virtual void set_ssid_pass();
  virtual bool check_valid_ssid();

  virtual void _connect();
  virtual void _disconnect();
  void connect();
  void disconnect();

  virtual void getMacAddr();
  virtual int32_t getRSSI();
  virtual void setupMQTTClient(const char *clientID);

  virtual ws_status_t networkStatus();
  ws_board_status_t getBoardStatus();

  bool generateDeviceUID();
  bool generateWSTopics();
  bool generateWSErrorTopics();

  // Registration API
  bool registerBoard();
  bool encodePubRegistrationReq();
  void decodeRegistrationResp(char *data, uint16_t len);
  void pollRegistrationResp();
  // Configuration API
  void publishPinConfigComplete();

  // run() loop
  ws_status_t run();
  void processPackets();
  void publish(const char *topic, uint8_t *payload, uint16_t bLen,
               uint8_t qos = 0);

  // Networking helpers
  void pingBroker();
  void runNetFSM();

  // WDT helpers
  void enableWDT(int timeoutMS = 0);
  void feedWDT();

  // Error handling helpers
  void haltError(String error,
                 ws_led_status_t ledStatusColor = WS_LED_STATUS_ERROR_RUNTIME,
                 int seconds_until_reboot = 25);
  void errorWriteHang(String error);

  // MQTT topic callbacks //
  // Decodes a signal message
  bool decodeSignalMsg(
      wippersnapper_signal_v1_CreateSignalRequest *encodedSignalMsg);

  // Encodes a pin event message
  bool
  encodePinEvent(wippersnapper_signal_v1_CreateSignalRequest *outgoingSignalMsg,
                 uint8_t pinName, int pinVal);

  // Pin configure message
  bool configureDigitalPinReq(wippersnapper_pin_v1_ConfigurePinRequest *pinMsg);
  bool configAnalogInPinReq(wippersnapper_pin_v1_ConfigurePinRequest *pinMsg);

  // I2C
  std::vector<WipperSnapper_Component_I2C *>
      i2cComponents; 
  WipperSnapper_Component_I2C *_i2cPort0 =
      NULL; 
  WipperSnapper_Component_I2C *_i2cPort1 =
      NULL; 
  bool _isI2CPort0Init =
      false; 
  bool _isI2CPort1Init =
      false; 

  uint8_t _buffer[WS_MQTT_MAX_PAYLOAD_SIZE]; 
  uint8_t
      _buffer_outgoing[WS_MQTT_MAX_PAYLOAD_SIZE]; 
  uint16_t bufSize; 
  ws_board_status_t _boardStatus =
      WS_BOARD_DEF_IDLE; 

  // TODO: We really should look at making these static definitions, not dynamic
  // to free up space on the heap
  Wippersnapper_DigitalGPIO *_digitalGPIO; 
  Wippersnapper_AnalogIO *_analogIO;       
  Wippersnapper_FS *_fileSystem; 
  WipperSnapper_LittleFS
      *_littleFS; 
  ws_pixels *_ws_pixelsComponent; 
  ws_pwm *_pwmComponent;          
  ws_servo *_servoComponent;      
  ws_ds18x20 *_ds18x20Component;  
  ws_uart *_uartComponent;        
  DisplayController
      *_displayController; 

  // TODO: does this really need to be global?
  uint8_t _macAddr[6];          
  char sUID[13];                
  const char *_airlift_version; 
  const char *_boardId;         
  Adafruit_MQTT *_mqtt;         
  secretsConfig _config; 
  networkConfig _multiNetworks[3]; 
  bool _isWiFiMulti = false; 
  // TODO: Does this need to be within this class?
  int32_t totalDigitalPins; 
  char *_topic_description = NULL; 
  char *_topic_signal_device = NULL;   
  char *_topic_signal_i2c_brkr = NULL; 
  char *_topic_signal_i2c_device = NULL;   
  char *_topic_signal_servo_brkr = NULL;   
  char *_topic_signal_servo_device = NULL; 
  char *_topic_signal_pwm_brkr =
      NULL; 
  char *_topic_signal_pwm_device =
      NULL; 
  char *_topic_signal_ds18_brkr = NULL; 
  char *_topic_signal_ds18_device = NULL;   
  char *_topic_signal_pixels_brkr = NULL;   
  char *_topic_signal_pixels_device = NULL; 
  char *_topic_signal_uart_brkr = NULL;     
  char *_topic_signal_uart_device = NULL;   
  char *_topic_signal_display_brkr =
      NULL; 
  char *_topic_signal_display_device =
      NULL; 
  wippersnapper_signal_v1_CreateSignalRequest
      _incomingSignalMsg; 
  wippersnapper_signal_v1_I2CRequest msgSignalI2C =
      wippersnapper_signal_v1_I2CRequest_init_zero; 

  // ds signal msg
  wippersnapper_signal_v1_Ds18x20Request msgSignalDS =
      wippersnapper_signal_v1_Ds18x20Request_init_zero; 

  // servo message
  wippersnapper_signal_v1_ServoRequest
      msgServo; 
  wippersnapper_signal_v1_PWMRequest msgPWM =
      wippersnapper_signal_v1_PWMRequest_init_zero; 

  // pixels signal message
  wippersnapper_signal_v1_PixelsRequest
      msgPixels; 

  wippersnapper_signal_v1_UARTRequest
      msgSignalUART; 

  wippersnapper_signal_v1_DisplayRequest
      msgSignalDisplay; 

  char *throttleMessage; 
  int throttleTime;      
  bool pinCfgCompleted = false; 
// enable LEDC if esp32
#ifdef ARDUINO_ARCH_ESP32
  ws_ledc *_ledc = nullptr; 
#endif

private:
  void _init();

protected:
  ws_status_t _status = WS_IDLE;   
  uint32_t _last_mqtt_connect = 0; 
  uint16_t _brokerKeepAliveIntervalSeconds =
      0; 
  uint32_t _prv_ping = 0;    
  uint32_t _prvKATBlink = 0; 
  // Device information
  const char *_deviceId; 
  char *_device_uid;     
  // MQTT topics
  char *_topic_description_status =
      NULL; 
  char *_topic_description_status_complete = NULL; 
  char *_topic_device_pin_config_complete =
      NULL;                        
  char *_topic_signal_brkr = NULL; 
  char *_err_topic = NULL;         
  char *_throttle_topic = NULL; 
  Adafruit_MQTT_Subscribe *_topic_description_sub; 
  Adafruit_MQTT_Publish *_topic_signal_device_pub; 
  Adafruit_MQTT_Subscribe *_topic_signal_brkr_sub; 
  Adafruit_MQTT_Subscribe
      *_topic_signal_i2c_sub; 
  Adafruit_MQTT_Subscribe
      *_topic_signal_servo_sub; 
  Adafruit_MQTT_Subscribe
      *_topic_signal_pwm_sub; 
  Adafruit_MQTT_Subscribe
      *_topic_signal_ds18_sub; 
  Adafruit_MQTT_Subscribe
      *_topic_signal_pixels_sub; 
  Adafruit_MQTT_Subscribe
      *_topic_signal_uart_sub; 
  Adafruit_MQTT_Subscribe *_topic_signal_display_sub; 
  Adafruit_MQTT_Subscribe
      *_err_sub; 
  Adafruit_MQTT_Subscribe
      *_throttle_sub; 
  wippersnapper_signal_v1_CreateSignalRequest
      _outgoingSignalMsg; 
};
extern Wippersnapper WS; 

#endif // ADAFRUIT_WIPPERSNAPPER_H