ESP32 Forum

Code: Select all

#include <Arduino.h>
#include "SdFat.h"


SdFat                   _sd;
File                    _myFile;


#define MAX_RECORDS                   100
#define MAX_COMBINED_OBD_DATA_LENGTH  200
#define MAX_RECORD_LENGTH             232 + MAX_COMBINED_OBD_DATA_LENGTH


uint32_t                _ulngRecordCount;
int volatile            _intInCount;
int volatile            _intOutCount;
char volatile           _bytDataArray[MAX_RECORDS][MAX_RECORD_LENGTH];
char                    _strTempSDcardData[MAX_RECORD_LENGTH];
char                    _strCombinedOBDdata[MAX_COMBINED_OBD_DATA_LENGTH];
bool volatile           _blnRecordLocked;
bool volatile           _blnStopLogging;
char                    _bytFileInUse;


int setupSDcard(void)
{
  uint32_t  cardSize;
  int       intSDcardStatus = 0;
  
  // Initialize at the highest speed supported by the board that is
  // not over 50 MHz. Try a lower speed if SPI errors occur.
  if (!_sd.begin(SS, SD_SCK_MHZ(20))) 
  {
    #ifdef SERIAL_DEBUG
    Serial.println(F("SD: Mount failed"));
    #endif
    return -1;
  }

  cardSize = _sd.card()->cardSize();
  if (cardSize == 0) 
  {
    #ifdef SERIAL_DEBUG
    Serial.println(F("SD: Cardsize failed"));
    #endif
    return -1;
  }
  
  switch (_sd.card()->type()) 
  {
    case SD_CARD_TYPE_SD1:
      #ifdef SERIAL_DEBUG
      Serial.println(F("SD: Type SD1"));
      #endif
    break;

    case SD_CARD_TYPE_SD2:
      #ifdef SERIAL_DEBUG
      Serial.println(F("SD: Type SD2"));
      #endif
    break;

    case SD_CARD_TYPE_SDHC:
      #ifdef SERIAL_DEBUG
      if (cardSize < 70000000) 
      {
        Serial.println(F("SD: Type SDHC"));
      } 
      else 
      {
        Serial.println(F("SD: Type SDXC"));
      }
      #endif
      break;
    
    default:
      intSDcardStatus = -2;      
  }
  
  if (intSDcardStatus == 0)
  {
    #ifdef SERIAL_DEBUG
    Serial.printf("SD: Size = %d BYTES\r\n", (uint32_t) (cardSize * 0.512));

    _sd.ls("/", LS_SIZE | LS_R );
    #endif
  }  
  return intSDcardStatus;
}


// This code runs on the 2nd processor core and handles writing to the SD card
void Task1Code(void *parameter)
{
  int   next;
  
  for (;;)
  {
    delay(1);
    
    // Only if the foreground loop() is not adding a new record
    if (_blnRecordLocked == false)
    {
      // If we are trying to stop logging then make sure we can't write any more records
      if (_blnStopLogging == true)
      {
        _blnRecordLocked = true;
      }
      
      // Run a circular buffer
      if (_intInCount != _intOutCount)
      {
        next = _intOutCount + 1;
        if (next >= MAX_RECORDS)
          next = 0;
        
        if (strlen((char *)&_bytDataArray[_intOutCount][0]) < MAX_RECORD_LENGTH)
          strcpy(_strTempSDcardData, (char *)&_bytDataArray[_intOutCount][0]);
        else
          strcpy(_strTempSDcardData, "TOO LONG\r\n");

        // This normally takes < 5mS, but occasionally (when it writes the buffer) it takes about 320mS !!!
        // This is why we run it in a seperate core so it can do it's own thing without holding anyone up
        _myFile.println(_strTempSDcardData);

        _intOutCount = next;
      }

      // The other core checks this flag when trying to stop logging
      // When we get here, the SD card has been fully written so allow the
      // foreground task on the other core to continue
      _blnStopLogging = false;
    }
  }
}


// I have read that the 'idle' task runs at priority 0 so create any other tasks with a higher one or else 'weirdness' may result???
// Setup() and Loop() run on core 1 at priority 1
// WiFi is handled by core 0 and runs at MAX_PRIORITY-1 (I think this equates to 24)
// Bluetooth is handled by core 0 and runs at priority 18
void createAtask(void)
{
  //                      Function   Name     Stack  I     P  Handle  Core
  // Stack is siize in words
  // I is task input parameter
  // P is priority 0 = lowest
  xTaskCreatePinnedToCore(Task1Code, "Task1", 10000, NULL, 1, &_task1, 0);  
}


void stopLogging(void)
{
  // Only if in use or paused
  if (_bytFileInUse == 'Y' || _bytFileInUse == 'P')
  {
    if (_sd.exists(_strFilename))
    {
      // Stop the process on the other core accessing the SD card
      _blnStopLogging = true;
      while (_blnStopLogging == true) ;

      _myFile.close();
      _bytFileInUse = 'N';
    }
  }  
}


void startLogging(void)
{
  // Only if not already logging
  if (_bytFileInUse == 'N')
  {
    // Reset the SD card writer engine
    _blnStopLogging = false;
    _intOutCount = _intInCount = 0;
    _blnRecordLocked = false; 
       
    _ulngRecordCount = 0;

		// NOTE I HAVE AN RTC DEVICE FITTED

    // We need to start a new file so update the date/time registers from the RTC
    //readDateTime();
    // We are limited to an 8.3 filename format so try to be as unique as we can...
    // YMMDDHHm.mss
    //sprintf(_strFilename, "%d%02d%02d%02d%d.%d%02d", getYears() % 10, getMon(), getDate(), getHour(), getMinute() / 10, getMinute() % 10, getSecond());
    // set date time callback function
    //SdFile::dateTimeCallback(dateTime);

		strcpy(_strFilename, "TEST.DAT");

    // Write my header data (I've removed the OBD calls)
    // O_WRITE | OCREAT is supposedly faster than FILE_WRITE
    _myFile = _sd.open(_strFilename, O_WRITE | O_CREAT);
    _myFile.print("Battery Volts : ");
    _myFile.print("OBD standards supported : ");
    _myFile.print("DTC codes : ");
    _myFile.print("VIN :");
    _myFile.print("Supported PIDS : ");
    _myFile.println("\r\n");
    
    _bytFileInUse = 'Y';
  }

  // If paused just continue logging
  if (_bytFileInUse == 'P')
  {
    _bytFileInUse = 'Y';
  }
}


void updateTheFile(void)
{
  char  strCompleteRecord[MAX_RECORD_LENGTH];
  
  if (SD.totalBytes() - SD.usedBytes() > 1000)
  {
    sprintf(strCompleteRecord, "ALL OF MY DATA"); 
    
    _ulngRecordCount++;
    
    if (strlen(strCompleteRecord) < MAX_RECORD_LENGTH)
    {
      int next;
      
      _blnRecordLocked = true;
      next = _intInCount + 1;
      if (next >= MAX_RECORDS)
      {
        next = 0;
      }
      if (next != _intOutCount)
      {
        strcpy((char *)&_bytDataArray[_intInCount][0], strCompleteRecord);
        _intInCount = next;
      }
      _blnRecordLocked = false;
    }
  }  
}


void setup() 
{
  _ulngRecordCount = 0;
  _bytFileInUse = 'N';
  _intOutCount = _intInCount = 0;
  _blnRecordLocked = false;
  _blnStopLogging = false;

  // Get the SD card task running
  createAtask();

  setupSDcard()
  
  startLogging();
}


void loop() 
{
  if (_bytFileInUse == 'Y')
  {
    // I call this every 100mS
    updateTheFile();
  }
}