Arduino BluetoothSerial crash after streaming data for a period, especially on interrupt.

[joshbrew]

Hardware:

Board: LOLIN32 V1.0.0
Core Installation version: 1.0.1
IDE name: Arduino IDE
Flash Frequency: 80MHz
PSRAM enabled: ?
Upload Speed: 921600
Computer OS: Win 10 and Android

Description:

Describe your problem here
Am trying to sync a phone with a bluetooth serial stream. I've gotten the stream working in BLE but could not read the write bytes on the ESP32 correctly in the UART example when I tried writing to it. So I switched to SerialBT which is more simple for my needs, but now I'm getting periodic crashing after streaming for a few minutes, especially when trying to interrupt. Ironically it seems to happen only at slower Bluetooth update rates. I have a light sensor and an ADS1115 on the 5V pins which might be causing a power draw issue but this was no issue with BLE.

Could this also be related to the speed at which my receiver is reading bytes? I've been testing an app and it's not well optimized and can lag behind, but that doesn't explain to me why it doesn't crash at higher rates than the app can keep up with.

Sketch: (leave the backquotes for code formatting)

//Change the code below by your sketch
#include "BluetoothSerial.h"

#include <Wire.h>
#include <Adafruit_ADS1015.h>
//#include <ArduinoJson.h>
 
BluetoothSerial SerialBT;

int count = 0;
bool sensorEnabled = false;
bool adcEnabled = false;
bool usbSerialEnabled = false;

char received;
//char ratioBuf[6], adcBuf[6];

// HEG VARIABLES
bool DEBUG = false;
bool VIEW_ADC_VALUE = false;
bool SEND_DUMMY_VALUE = false;

// PUT IR IN 13, RED IN 12
const int IR = 13;
const int RED = 12;
const int LED = 5; // Lolin32V1.0.0 LED on Pin 5
int16_t adc0; // Resulting 16 bit integer

//Setup ADS1115
Adafruit_ADS1115 ads;

float Voltage = 0.0;
float range = 32767; // 16 bit ADC (15 bits of range minus one)
float gain = 0.256; // +/- V
float bits2mv = gain / range;

//Signal flags
bool first_led = false; // Bool to alternate LEDS
bool badSignal = false;
bool signalDetermined = false;

//Counters
int ticks0, ticks1, ticks2, ticks3, ticks4 = 0;

//Scoring variables
long redValue = 0;
long irValue = 0;
float redavg = 0;
float iravg = 0;
float ratio = 0;
float baseline = 0;

float score = 0;

float p1, p2 = 0;
float v1, v2 = 0;
float accel = 0;

float ratioAvg, adcAvg, posAvg, velAvg, accelAvg;
//float scoreAvg;

//Timing variables
unsigned long startMillis;
unsigned long currentMillis;
unsigned long ledMillis;
unsigned long BLEMillis;

//Make sure these divide without remainders for best results
const unsigned long ledRate = 50; // LED flash rate (ms)
const unsigned long sampleRate = 2; // ADC read rate (ms). ADS1115 has a max of 860sps or 1/860 * 1000 ms or 1.16ms
const unsigned long samplesPerRatio = 50; // Number of samples per LED to accumulate before making a measurement. Time = 2*samples*sampleRate
const unsigned long BTRate = 333; // Bluetooth notify rate (ms). Min rate should be 10ms, however it will crash if your device cannot read fast enough as the buffer won't flush.

void startADS() {
  // Begin ADS
  ads.begin();
  ads.setGain(GAIN_SIXTEEN);

  //ads.setGain(GAIN_TWOTHIRDS);  // 2/3x gain +/- 6.144V  1 bit = 3mV (default)
  //ads.setGain(GAIN_ONE);     // 1x gain   +/- 4.096V  1 bit = 2mV
  //ads.setGain(GAIN_TWO);     // 2x gain   +/- 2.048V  1 bit = 1mV
  //ads.setGain(GAIN_FOUR);    // 4x gain   +/- 1.024V  1 bit = 0.5mV
  //ads.setGain(GAIN_EIGHT);   // 8x gain   +/- 0.512V  1 bit = 0.25mV
  //ads.setGain(GAIN_SIXTEEN); // 16x gain  +/- 0.256V  1 bit = 0.125mV
  //Start timers
  startMillis = millis();
  ledMillis = millis();
}

void commandESP32(char received){
  if(received == 't'){
    sensorEnabled = true;
    digitalWrite(LED,LOW);
  }
  if(received == 'f'){
    sensorEnabled = false;
    digitalWrite(LED,HIGH); 
    digitalWrite(RED,LOW);
    digitalWrite(IR,LOW); 
  }
  if(received == 'u'){
    usbSerialEnabled = true;
  }
  if(received == 'b') {
    usbSerialEnabled = false;
  }
  delay(2000);
}

void setup() {
  //Serial.begin(115200);
  
  pinMode(IR, OUTPUT);
  pinMode(RED, OUTPUT);
  //LOLIN32 ONLY
  pinMode(LED,OUTPUT);
  digitalWrite(LED,HIGH);
  
  SerialBT.begin("My_HEG");
  BLEMillis = millis();
}

void core_program() {
  if(sensorEnabled == true) {
    if(adcEnabled == false) {
      startADS();
      adcEnabled = true;
    }

    currentMillis = millis();
        
    if(currentMillis - startMillis >= sampleRate) {
  
      // read the analog in value:
      adc0 = ads.readADC_SingleEnded(0);
      //Voltage = (adc0 * bits2mv);
      
      // print the results to the Serial Monitor:
      if (VIEW_ADC_VALUE == true) {
        //Serial.println("ADC Value: ");
        //Serial.println(adc0);
        //Serial.println("\tVoltage: "); 
        //Serial.println(Voltage,7);
      }
      if (DEBUG == false) {
        if(adc0 >= 7000) { // The gain is high but anything over 7000 is most likely not a valid signal
          //Serial.println("\nBad Read ");
          badSignal = true;
    
          //Temp: reset baseline on bad read
          signalDetermined = false;
          baseline = 0;
    
          ticks0 = 0; // Reset counter
          ticks1 = 0;
          ticks2 = 0;
          redValue = 0; // Reset values
          irValue = 0;
        }
        else {
          badSignal = false;
          if(signalDetermined == false){
            ticks0++;
            if(ticks0 > 500) { // Wait for 500 samples of good signal before getting baseline
              // IR IN 12, RED IN 13
              if((ticks1 < 500) && (ticks2 < 500)) { // Accumulate samples for baseline
                if(first_led == true) { // RED
                  redValue += adc0;
                  ticks1++;
                }
                else { // IR
                  irValue += adc0;
                  ticks2++;
                }
                //Serial.println("\nGetting Baseline. . .");
              }
              else {
                signalDetermined = true;
                redavg = redValue / ticks1;
                iravg = irValue / ticks2;
    
                baseline = redavg / iravg; // Set baseline ratio
                ticks0 = 0; // Reset counters
                ticks1 = 0;
                ticks2 = 0;
                redValue = 0; // Reset values
                irValue = 0;
                
                //Uncomment this
                //Serial.println("\tBaseline R: ");
                //Serial.print(baseline,4);
              }
            }
          }
          else {
            ticks0++;
            if(first_led == true) { // RED
              redValue += adc0;
              ticks1++;
            }
            else { // IR
              irValue += adc0;
              ticks2++;
            }
            if((ticks2 > samplesPerRatio) && (ticks1 > samplesPerRatio)) { // Accumulate 50 samples per LED before taking reading
              redavg = redValue / ticks1; // Divide value by number of samples accumulated
              iravg = irValue / ticks2;
              ratio = redavg / iravg; // Get ratio
              ratioAvg += ratio;
              
              p1 = p2;
              p2 = ratio - baseline; // Position
              posAvg += p2;
              
              //v1 = v2;
              //v2 = (p2 - p1) * ticks0 * 0.001; // Velocity in ms
              //velAvg += v2;
              
              //accel = (v2 - v1) * ticks0 * 0.001; // Acceleration in ms^2
              //accelAvg += accel;
              
              //score += ratio-baseline; // Simple scoring method
              //scoreAvg += score;
              
              /*
              Serial.print("\tBaseline R: ");
              Serial.print(baseline,4);
              //Serial.print("\tRed: ");
              //Serial.print(redavg);
              //Serial.print("\tIR: ");
              //Serial.print(iravg);
              Serial.print("\tCurrent R: ");
              Serial.print(ratio,4);
              Serial.print("\trPosition: ");
              Serial.print(p2,4);
              Serial.print("\trVelocity: ");
              Serial.print(v2,4);
              Serial.print("\trAcceleration: ");
              Serial.print(accel,4);
              Serial.print("\trScore: ");
              Serial.print(score);
              Serial.print("\n");
              */
              ticks0 = 0; //Reset Counters
              ticks1 = 0;
              ticks2 = 0;
              ticks3++;
              redValue = 0; //Reset values to get next average
              irValue = 0;
              
            }
          }
        }
        
        startMillis = currentMillis;
      }
    }
  
    // Switch LEDs back and forth.
    // PUT IR IN 13, AND RED IN 12
    if(currentMillis - ledMillis >= ledRate) {
      if(first_led == false) {
        digitalWrite(RED,HIGH);
        digitalWrite(IR,LOW);
        first_led = true;
      }
      else {
        digitalWrite(RED,LOW);
        digitalWrite(IR,HIGH);
        first_led = false;
      }
      ledMillis = currentMillis;
    }
    
    adcAvg += adc0;
    ticks4++;
 }
}

void bluetooth() {
  while(SerialBT.available()){
    received = SerialBT.read();
    //Serial.println(received);
    SerialBT.println(received);
    commandESP32(received);
  }
  
  if(currentMillis - BLEMillis >= BTRate) { //SerialBT bitrate: ?/s. 100ms works, 50ms does causes hangups (which the LED flashes will reflect) - need better buffering.
     
      adcAvg = adcAvg / ticks4;
      /*
      char adcString[10], txString[40]; //Should be faster.
      dtostrf(adcAvg, 1, 0, adcString); 
      strcpy(txString,adcString);
      */
      
      if(ticks3 > 0) {
        ratioAvg = ratioAvg / ticks3;
        posAvg = posAvg / ticks3;
        
        //velAvg = velAvg / ticks3;
        //accelAvg = accelAvg / tick3;
        
        //scoreAvg = scoreAvg / ticks3;
        /*
        char ratioString[10], posString[10];

        dtostrf(ratioAvg, 1, 5, ratioString);
        dtostrf(posAvg, 1, 5, posString);
        
        strcat(txString,",");
        strcat(txString,ratioString);
        strcat(txString,",");
        strcat(txString,posString);
        
        SerialBT.println(txString);
        */
        SerialBT.println(String(adcAvg,0) + "," + String(ratioAvg,4) + "," + String(posAvg,4));
      }
      else {
        //strcat(txString,",WAIT");
        //SerialBT.println(txString);
        SerialBT.println(String(adcAvg,0) + ",WAIT");
      }
      
      //String strToSend = "{ratio:"+String(ratioAvg)+",adc:"+String(adc)+"}";
      //SerialBT.write((uint8_t*) buffer, strToSend*sizeof(int32_t)); //Faster to use a binary buffer
      //SerialBT.println(count);
      //count++;
      
      ratioAvg = 0;
      posAvg = 0;
      adcAvg = 0;
      adc0 = 0;
      ticks3 = 0;
      ticks4 = 0;

      BLEMillis = currentMillis;
      //Serial.println(ESP.getFreeHeap());
    }
  delay(1); //1 ms delay
}

void loop() {
  core_program();
  bluetooth();
}

Debug Messages:

The following is my heap size, it seems steady for a bit then starts to drop. At that point when I interrupt it causes a reboot.

90212
90184
90188
90212
90184
90188
90188
90188
90188
90212
90188
90188
90188
90188
90212
90184
90184
90184
90188
90184
90212
90184
90212
90212
90184
90188
90188
90188
90184
90188
90184
90212
90188
90184
90184
90184
90184
90212
90188
90212
90188
90212
90188
90184
90188
...
89460
89412
89384
89060
89284
89140
88824
89092
89036
88968
89052
88996
88928
88872
89044
88988
88932
88868
88808
88756
ASSERT_PARAM(512 0), in rwbt.c at line 273
Guru Meditation Error: Core 0 panic'ed (Interrupt wdt timeout on CPU0)
Core 0 register dump:
PC : 0x40085841 PS : 0x00060434 A0 : 0x800892bc A1 : 0x3ffc05b0
A2 : 0x00000001 A3 : 0x00000000 A4 : 0x00000000 A5 : 0x60008054
A6 : 0x3ffc1030 A7 : 0x60008050 A8 : 0x80085841 A9 : 0x3ffc0590
A10 : 0x00000004 A11 : 0x00000000 A12 : 0x6000804c A13 : 0xffffffff
A14 : 0x00000000 A15 : 0xfffffffc SAR : 0x00000004 EXCCAUSE: 0x00000005
EXCVADDR: 0x00000000 LBEG : 0x40085779 LEND : 0x40085780 LCOUNT : 0x00000000
Core 0 was running in ISR context:
EPC1 : 0x40089aae EPC2 : 0x00000000 EPC3 : 0x00000000 EPC4 : 0x40085841

Backtrace: 0x40085841:0x3ffc05b0 0x400892b9:0x3ffc05d0 0x4008994b:0x3ffc05f0 0x40081f45:0x3ffc0610 0x40089aab:0x00000000

Core 1 register dump:
PC : 0x4017e1ce PS : 0x00060f34 A0 : 0x8008e46a A1 : 0x3ffd1de0
A2 : 0x00000008 A3 : 0x00000001 A4 : 0x00000000 A5 : 0x3ffd1910
A6 : 0x00000000 A7 : 0x00000001 A8 : 0x3ffc829c A9 : 0x3ffc8260
A10 : 0x00000000 A11 : 0x00000001 A12 : 0x8008c8c8 A13 : 0x3ffd1ce0
A14 : 0x00000000 A15 : 0x3ffd1aa0 SAR : 0x00000000 EXCCAUSE: 0x00000005
EXCVADDR: 0x00000000 LBEG : 0x00000000 LEND : 0x00000000 LCOUNT : 0x00000000

Backtrace: 0x4017e1ce:0x3ffd1de0 0x4008e467:0x3ffd1e00

Rebooting...
ets Jun 8 2016 00:22:57

rst:0xc (SW_CPU_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0018,len:4
load:0x3fff001c,len:808
load:0x40078000,len:6084
load:0x40080000,len:6696
entry 0x400802e4
92620

[joshbrew]

Decoding 13 results
0x40085841: r_assert_param at ?? line ?
0x40085779: r_assert_param at ?? line ?
0x40085780: r_assert_param at ?? line ?
0x40089aae: btdm_bb_isr at intc.c line ?
0x40085841: r_assert_param at ?? line ?
0x40085841: r_assert_param at ?? line ?
0x400892b9: r_rwbt_isr at ?? line ?
0x4008994b: r_rwbtdm_isr_wrapper at intc.c line ?
0x40081f45: _xt_lowint1 at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/freertos/xtensa_vectors.S line 1105
0x40089aab: btdm_bb_isr at intc.c line ?
0x4017e1ce: __cxa_guard_dummy at ?? line ?
0x4017e1ce: __cxa_guard_dummy at ?? line ?
0x4008e467: prvIdleTask at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/freertos/tasks.c line 3564

[joshbrew]

Another stack trace:
0x40085841: r_assert_param at ?? line ?
0x40085779: r_assert_param at ?? line ?
0x40085780: r_assert_param at ?? line ?
0x40089aae: btdm_bb_isr at intc.c line ?
0x40085841: r_assert_param at ?? line ?
0x40085841: r_assert_param at ?? line ?
0x400892b9: r_rwbt_isr at ?? line ?
0x4008994b: r_rwbtdm_isr_wrapper at intc.c line ?
0x40081f45: _xt_lowint1 at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/freertos/xtensa_vectors.S line 1105
0x40089aab: btdm_bb_isr at intc.c line ?
0x4017e1fa: esp_vApplicationWaitiHook at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/esp32/freertos_hooks.c line 66
0x4017e1fa: esp_vApplicationWaitiHook at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/esp32/freertos_hooks.c line 66
0x4008e467: prvIdleTask at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/freertos/tasks.c line 3564

[joshbrew]

Another note, my heap size doubled when I changed my bluetooth transmit rate from 333 to 100ms. Wtf lol

[copercini]

Interrupt wdt timeout on CPU0 means that you should feed the WDT timer on loops, calling feedLoopWDT(); or delay(10); with 10 or more

[joshbrew]

Thank you for the assist

So should I change the 1ms delay to 10 or change it to feedLoopWDT(). I have some processes that are running at 2ms intervals so I also need to desynchronize then if my delay is longer, unless I just have that delay after a SerialBT print call. I'm working on a biofeedback device that relies on the ADC running pretty fast.

[joshbrew]

Okay, fix: changed the delay after the BTserial send to 10ms, and I have a 1ms delay in the main loop for good measure, now my heap at slower response rates is restored and there are no more crashes so far