Merge ESP32 files of branch 'ESP32-checkpoint' into PORTX_HAL

DCCRMT.cpp

@@ -0,0 +1,205 @@
+/*
+ *  © 2021, Harald Barth.
+ *  
+ *  This file is part of DCC-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+#include "defines.h"
+#if defined(ARDUINO_ARCH_ESP32)
+#include "DIAG.h"
+#include "DCCRMT.h"
+#include "DCCWaveform.h" // for MAX_PACKET_SIZE
+#include "soc/gpio_sig_map.h"
+
+#define DATA_LEN(X) ((X)*9+1) // Each byte has one bit extra and we have one EOF marker
+
+#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(4,2,0)
+#error wrong IDF version
+#endif
+
+void setDCCBit1(rmt_item32_t* item) {
+  item->level0    = 1;
+  item->duration0 = DCC_1_HALFPERIOD;
+  item->level1    = 0;
+  item->duration1 = DCC_1_HALFPERIOD;
+}
+
+void setDCCBit0(rmt_item32_t* item) {
+  item->level0    = 1;
+  item->duration0 = DCC_0_HALFPERIOD;
+  item->level1    = 0;
+  item->duration1 = DCC_0_HALFPERIOD;
+}
+
+// special long zero to trigger scope
+void setDCCBit0Long(rmt_item32_t* item) {
+  item->level0    = 1;
+  item->duration0 = DCC_0_HALFPERIOD + DCC_0_HALFPERIOD/10;
+  item->level1    = 0;
+  item->duration1 = DCC_0_HALFPERIOD + DCC_0_HALFPERIOD/10;
+}
+
+void setEOT(rmt_item32_t* item) {
+  item->val = 0;
+}
+
+void IRAM_ATTR interrupt(rmt_channel_t channel, void *t) {
+  RMTChannel *tt = (RMTChannel *)t;
+  tt->RMTinterrupt();
+}
+
+RMTChannel::RMTChannel(byte pin, bool isMain) {
+  byte ch;
+  byte plen;
+  if (isMain) {
+    ch = 0;
+    plen = PREAMBLE_BITS_MAIN;
+  } else {
+    ch = 2;
+    plen = PREAMBLE_BITS_PROG;
+  }
+    
+  // preamble
+  preambleLen = plen+2; // plen 1 bits, one 0 bit and one EOF marker
+  preamble = (rmt_item32_t*)malloc(preambleLen*sizeof(rmt_item32_t));
+  for (byte n=0; n<plen; n++)
+    setDCCBit1(preamble + n);      // preamble bits
+#ifdef SCOPE
+  setDCCBit0Long(preamble + plen); // start of packet 0 bit long version
+#else
+  setDCCBit0(preamble + plen);     // start of packet 0 bit normal version
+#endif
+  setEOT(preamble + plen + 1);     // EOT marker
+
+  // idle
+  idleLen = 28;
+  idle = (rmt_item32_t*)malloc(idleLen*sizeof(rmt_item32_t));
+  if (isMain) {
+    for (byte n=0; n<8; n++)   // 0 to 7
+      setDCCBit1(idle + n);
+    for (byte n=8; n<18; n++)  // 8, 9 to 16, 17
+      setDCCBit0(idle + n);
+    for (byte n=18; n<26; n++) // 18 to 25
+      setDCCBit1(idle + n);
+  } else {
+    for (byte n=0; n<26; n++)  // all zero
+      setDCCBit0(idle + n);
+  }
+  setDCCBit1(idle + 26);     // end bit
+  setEOT(idle + 27);         // EOT marker
+
+  // data: max packet size today is 5 + checksum
+  maxDataLen = DATA_LEN(MAX_PACKET_SIZE);
+  data = (rmt_item32_t*)malloc(maxDataLen*sizeof(rmt_item32_t));
+  
+  rmt_config_t config;
+  // Configure the RMT channel for TX
+  bzero(&config, sizeof(rmt_config_t));
+  config.rmt_mode = RMT_MODE_TX;
+  config.channel = channel = (rmt_channel_t)ch;
+  config.clk_div = RMT_CLOCK_DIVIDER;
+  config.gpio_num = (gpio_num_t)pin;
+  config.mem_block_num = 2; // With longest DCC packet 11 inc checksum (future expansion)
+                            // number of bits needed is 22preamble + start +
+                            // 11*9 + extrazero + EOT = 124
+                            // 2 mem block of 64 RMT items should be enough
+
+  ESP_ERROR_CHECK(rmt_config(&config));
+  /*
+  // test: config another gpio pin
+  gpio_num_t gpioNum = (gpio_num_t)(pin-1);
+  PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[gpioNum], PIN_FUNC_GPIO);
+  gpio_set_direction(gpioNum, GPIO_MODE_OUTPUT);
+  gpio_matrix_out(gpioNum, RMT_SIG_OUT0_IDX, 0, 0);
+  */
+  
+  // NOTE: ESP_INTR_FLAG_IRAM is *NOT* included in this bitmask
+  ESP_ERROR_CHECK(rmt_driver_install(config.channel, 0, ESP_INTR_FLAG_LOWMED|ESP_INTR_FLAG_SHARED));
+
+  DIAG(F("Register interrupt on core %d"), xPortGetCoreID());
+
+  ESP_ERROR_CHECK(rmt_set_tx_loop_mode(channel, true));
+  rmt_register_tx_end_callback(interrupt, this);
+  rmt_set_tx_intr_en(channel, true);
+
+  DIAG(F("Starting channel %d signal generator"), config.channel);
+
+  // send one bit to kickstart the signal, remaining data will come from the
+  // packet queue. We intentionally do not wait for the RMT TX complete here.
+  //rmt_write_items(channel, preamble, preambleLen, false);
+  RMTprefill();
+  preambleNext = true;
+  dataReady = false;
+  RMTinterrupt();
+}
+
+void RMTChannel::RMTprefill() {
+  rmt_fill_tx_items(channel, preamble, preambleLen, 0);
+  rmt_fill_tx_items(channel, idle, idleLen, preambleLen-1);
+}
+
+const byte transmitMask[] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
+
+//bool RMTChannel::RMTfillData(const byte buffer[], byte byteCount, byte repeatCount=0) {
+int RMTChannel::RMTfillData(dccPacket packet) {
+  // dataReady: Signals to then interrupt routine. It is set when
+  // we have data in the channel buffer which can be copied out
+  // to the HW. dataRepeat on the other hand signals back to
+  // the caller of this function if the data has been sent enough
+  // times (0 to 3 means 1 to 4 times in total).
+  if (dataReady == true)
+    return 1000;
+  if (dataRepeat > 0) // we have still old work to do
+    return dataRepeat;
+  if (DATA_LEN(packet.length) > maxDataLen) {  // this would overun our allocated memory for data
+    DIAG(F("Can not convert DCC bytes # %d to DCC bits %d, buffer too small"), packet.length, maxDataLen);
+    return -1;                          // something very broken, can not convert packet
+  }
+
+  byte *buffer = packet.data;
+  
+  // convert bytes to RMT stream of "bits"
+  byte bitcounter = 0;
+  for(byte n=0; n<packet.length; n++) {
+    for(byte bit=0; bit<8; bit++) {
+      if (buffer[n] & transmitMask[bit])
+	setDCCBit1(data + bitcounter++);
+      else
+	setDCCBit0(data + bitcounter++);
+    }
+    setDCCBit0(data + bitcounter++); // zero at end of each byte
+  }
+  setDCCBit1(data + bitcounter-1);     // overwrite previous zero bit with one bit
+  setEOT(data + bitcounter++);         // EOT marker
+  dataLen = bitcounter;
+  dataReady = true;
+  dataRepeat = packet.repeat+1;         // repeatCount of 0 means send once
+  return 0;
+}
+
+void IRAM_ATTR RMTChannel::RMTinterrupt() {
+  //no rmt_tx_start(channel,true) as we run in loop mode
+  //preamble is always loaded at beginning of buffer
+  if (dataReady) {            // if we have new data, fill while preamble is running
+    rmt_fill_tx_items(channel, data, dataLen, preambleLen-1);
+    dataReady = false;
+  }
+  if (dataRepeat > 0)         // if a repeat count was specified, work on that
+    dataRepeat--;
+  return;
+}
+#endif //ESP32

DCCRMT.h

@@ -0,0 +1,61 @@
+/*
+ *  © 2021, Harald Barth.
+ *  
+ *  This file is part of DCC-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include <Arduino.h>
+#if defined(ARDUINO_ARCH_ESP32)
+#include "DCCPacket.h"
+#include "driver/rmt.h"
+#include "soc/rmt_reg.h"
+#include "soc/rmt_struct.h"
+
+// make calculations easy and set up for microseconds
+#define RMT_CLOCK_DIVIDER 80
+#define DCC_1_HALFPERIOD 58  //4640 // 1 / 80000000 * 4640 = 58us
+#define DCC_0_HALFPERIOD 100 //8000
+
+class RMTChannel {
+ public:
+  RMTChannel(byte pin, bool isMain);
+  void IRAM_ATTR RMTinterrupt();
+  void RMTprefill();
+  int RMTfillData(dccPacket packet);
+  //bool RMTfillData(const byte buffer[], byte byteCount, byte repeatCount);
+  
+  static RMTChannel mainRMTChannel;
+  static RMTChannel progRMTChannel;
+  
+ private:
+    
+  rmt_channel_t channel;
+  // 3 types of data to send, preamble and then idle or data
+  // if this is prog track, idle will contain reset instead
+  rmt_item32_t *idle;
+  byte idleLen;
+  rmt_item32_t *preamble;
+  byte preambleLen;
+  rmt_item32_t *data;
+  byte dataLen;
+  byte maxDataLen;
+  // flags 
+  volatile bool preambleNext = true;  // alternate between preamble and content
+  volatile bool dataReady = false;    // do we have real data available or send idle
+  volatile byte dataRepeat = 0;
+};
+#endif //ESP32

WifiESP32.cpp

@@ -0,0 +1,246 @@
+/*
+    © 2021, Harald Barth.
+
+    This file is part of CommandStation-EX
+
+    This is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    It is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include <vector>
+#include "defines.h"
+#if defined(ARDUINO_ARCH_ESP32)
+#include <WiFi.h>
+#include "WifiESP32.h"
+#include "DIAG.h"
+#include "RingStream.h"
+#include "CommandDistributor.h"
+/*
+#include "soc/rtc_wdt.h"
+#include "esp_task_wdt.h"
+*/
+
+#include "soc/timer_group_struct.h"
+#include "soc/timer_group_reg.h"
+void feedTheDog0(){
+  // feed dog 0
+  TIMERG0.wdt_wprotect=TIMG_WDT_WKEY_VALUE; // write enable
+  TIMERG0.wdt_feed=1;                       // feed dog
+  TIMERG0.wdt_wprotect=0;                   // write protect
+  // feed dog 1
+  //TIMERG1.wdt_wprotect=TIMG_WDT_WKEY_VALUE; // write enable
+  //TIMERG1.wdt_feed=1;                       // feed dog
+  //TIMERG1.wdt_wprotect=0;                   // write protect
+}
+
+/*
+void enableCoreWDT(byte core){
+  TaskHandle_t idle = xTaskGetIdleTaskHandleForCPU(core);
+  if(idle == NULL){
+    DIAG(F("Get idle rask on core %d failed"),core);
+  } else {
+    if(esp_task_wdt_add(idle) != ESP_OK){
+      DIAG(F("Failed to add Core %d IDLE task to WDT"),core);
+    } else {
+      DIAG(F("Added Core %d IDLE task to WDT"),core);
+    }
+  }
+}
+
+void disableCoreWDT(byte core){
+    TaskHandle_t idle = xTaskGetIdleTaskHandleForCPU(core);
+    if(idle == NULL || esp_task_wdt_delete(idle) != ESP_OK){
+      DIAG(F("Failed to remove Core %d IDLE task from WDT"),core);
+    }
+}
+*/
+
+static std::vector<WiFiClient> clients; // a list to hold all clients
+static WiFiServer *server = NULL;
+static RingStream *outboundRing = new RingStream(2048);
+static bool APmode = false;
+
+void wifiLoop(void *){
+  for(;;){
+    WifiESP::loop();
+  }
+}
+
+bool WifiESP::setup(const char *SSid,
+                    const char *password,
+                    const char *hostname,
+                    int port,
+                    const byte channel) {
+  bool havePassword = true;
+  bool haveSSID = true;
+  bool wifiUp = false;
+  uint8_t tries = 40;
+
+  // tests
+  //  enableCoreWDT(1);
+  //  disableCoreWDT(0);
+
+  const char *yourNetwork = "Your network ";
+  if (strncmp(yourNetwork, SSid, 13) == 0 || strncmp("", SSid, 13) == 0)
+    haveSSID = false;
+  if (strncmp(yourNetwork, password, 13) == 0 || strncmp("", password, 13) == 0)
+    havePassword = false;
+
+  if (haveSSID && havePassword) {
+    WiFi.mode(WIFI_STA);
+    WiFi.setAutoReconnect(true);
+    WiFi.begin(SSid, password);
+    while (WiFi.status() != WL_CONNECTED && tries) {
+      Serial.print('.');
+      tries--;
+      delay(500);
+    }
+    if (WiFi.status() == WL_CONNECTED) {
+      DIAG(F("Wifi STA IP %s"),WiFi.localIP().toString().c_str());
+      wifiUp = true;
+    } else {
+      DIAG(F("Could not connect to Wifi SSID %s"),SSid);
+    }
+  }
+  if (!haveSSID) {
+    // prepare all strings
+    String strSSID("DCC_");
+    String strPass("PASS_");
+    String strMac = WiFi.macAddress();
+    strMac.remove(0,9);
+    strMac.replace(":","");
+    strMac.replace(":","");
+    strSSID.concat(strMac);
+    strPass.concat(strMac);
+
+    WiFi.mode(WIFI_AP);
+    if (WiFi.softAP(strSSID.c_str(),
+		    havePassword ? password : strPass.c_str(),
+		    channel, false, 8)) {
+      DIAG(F("Wifi AP SSID %s PASS %s"),strSSID.c_str(),havePassword ? password : strPass.c_str());
+      DIAG(F("Wifi AP IP %s"),WiFi.softAPIP().toString().c_str());
+      wifiUp = true;
+      APmode = true;
+    } else {
+      DIAG(F("Could not set up AP with Wifi SSID %s"),strSSID.c_str());
+    }
+  }
+
+
+  if (!wifiUp) {
+    DIAG(F("Wifi setup all fail (STA and AP mode)"));
+    // no idea to go on
+    return false;
+  }
+  server = new WiFiServer(port); // start listening on tcp port
+  server->begin();
+  // server started here
+
+  //start loop task
+  if (pdPASS != xTaskCreatePinnedToCore(
+	wifiLoop, /* Task function. */
+	"wifiLoop",/* name of task.  */
+	10000,     /* Stack size of task */
+	NULL,      /* parameter of the task */
+	1,         /* priority of the task */
+	NULL,      /* Task handle to keep track of created task */
+	0)) {      /* pin task to core 0 */
+    DIAG(F("Could not create wifiLoop task"));
+    return false;
+  }
+
+  // report server started after wifiLoop creation
+  // when everything looks good
+  DIAG(F("Server up port %d"),port);
+  return true;
+}
+
+void WifiESP::loop() {
+  int clientId; //tmp loop var
+
+  // really no good way to check for LISTEN especially in AP mode?
+  if (APmode || WiFi.status() == WL_CONNECTED) {
+    if (server->hasClient()) {
+      // loop over all clients and remove inactive
+      for (clientId=0; clientId<clients.size(); clientId++){
+	// check if client is there and alive
+	if(!clients[clientId].connected()) {
+	  clients[clientId].stop();
+	  clients.erase(clients.begin()+clientId);
+	}
+      }
+      WiFiClient client;
+      while (client = server->available()) {
+	clients.push_back(client);
+	DIAG(F("New client %s"), client.remoteIP().toString().c_str());
+      }
+    }
+    // loop over all connected clients
+    for (clientId=0; clientId<clients.size(); clientId++){
+      if(clients[clientId].connected()) {
+	int len;
+	if ((len = clients[clientId].available()) > 0) {
+	  // read data from client
+	  byte cmd[len+1];
+	  for(int i=0; i<len; i++) {
+	    cmd[i]=clients[clientId].read();
+	  }
+	  cmd[len]=0;
+	  outboundRing->mark(clientId);
+	  CommandDistributor::parse(clientId,cmd,outboundRing);
+	  outboundRing->commit();
+	}
+      }
+    } // all clients
+
+    // something to write out?
+    clientId=outboundRing->peek();
+    if (clientId >= 0) {
+      if ((unsigned int)clientId > clients.size()) {
+	// something is wrong with the ringbuffer position
+	outboundRing->info();
+      } else {
+	// we have data to send in outboundRing
+	if(clients[clientId].connected()) {
+	  outboundRing->read(); // read over peek()
+	  int count=outboundRing->count();
+	  {
+	    char buffer[count+1];
+	    for(int i=0;i<count;i++) {
+	      int c = outboundRing->read();
+	      if (c >= 0)
+		buffer[i] = (char)c;
+	      else {
+		DIAG(F("Ringread fail at %d"),i);
+		break;
+	      }
+	    }
+	    buffer[count]=0;
+	    clients[clientId].write(buffer,count);
+	  }
+	}
+      }
+    }
+  } //connected
+
+  // when loop() is running on core0 we must
+  // feed the core0 wdt ourselves as yield()
+  // is not necessarily yielding to a low
+  // prio task. On core1 this is not a problem
+  // as there the wdt is disabled by the
+  // arduio IDE startup routines.
+  if (xPortGetCoreID() == 0)
+    feedTheDog0();
+  yield();
+}
+#endif //ESP32

WifiESP32.h

@@ -0,0 +1,39 @@
+/*
+ *  © 2021, Harald Barth.
+ *
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#if defined(ARDUINO_ARCH_ESP32)
+#ifndef WifiESP32_h
+#define WifiESP32_h
+
+#include "FSH.h"
+
+class WifiESP
+{
+
+public:
+  static bool setup(const char *wifiESSID,
+		    const char *wifiPassword,
+		    const char *hostname,
+		    const int port,
+		    const byte channel);
+  static void loop();
+private:
+};
+#endif //WifiESP8266_h
+#endif //ESP8266