/*
ECG measurement Project:
- Sensing two ADC values,
- Analog files being logged on sd card
Time A-B A B
*/
//Including Libraries
#include <ADC.h>
#include <string.h>
#include <Time.h>
#include <SdFat.h>
#include <SdFatUtil.h>
#include <BufferedWriter.h>
SdFat sd;
SdFile myFile;
//Teensy 3.1 has the LED on pin 13
const int ledPin = 13;
const int readPin0 = A2; //ADC read A2
const int readPin1 = A3; //ADC read A3
const int chipSelect = SS;
//char filename[] = "00000000.txt";
#define SD_CHIP_SELECT 10 // SD chip select pin
#define error(s) sd.errorHalt_P(PSTR(s))
#define FILE_BASE_NAME "CHOP" //Can be max size of 5 character, XXXXX000.BIN DOS 8.3 format
#define TMP_FILE_NAME "TMP_LOG.BIN"
const uint8_t BASE_NAME_SIZE = sizeof(FILE_BASE_NAME) - 1;
const uint32_t FILE_BLOCK_COUNT = 500UL; //500=250kb 1 block=512bytes
const uint32_t ERASE_SIZE = 262144L;
uint32_t bgnBlock, endBlock;
uint8_t* pCache;
char binName[13] = FILE_BASE_NAME "000.BIN";
ADC *adc = new ADC(); // adc object
ADC::Sync_result result;
float ADCvalue_0 = ADC_ERROR_VALUE;
float ADCvalue_1 = ADC_ERROR_VALUE;
float SDBuffer [128];
int count = 0;
uint32_t bn = 1; //block number
int startTime; //to reset milli count at each recording
//Interval Timer
IntervalTimer timer0;
char c=0;
//------------------------------------------------------------------------------
/*
* User provided date time callback function.
* See SdFile::dateTimeCallback() for usage.
*/
void dateTime(uint16_t* date, uint16_t* time) {
// User gets date and time from GPS or real-time
// clock in real callback function
time_t now();
// return date using FAT_DATE macro to format fields
*date = FAT_DATE(year(), month(), day());
// return time using FAT_TIME macro to format fields
*time = FAT_TIME(hour(), minute(), second());
}
void createFile(){
bn=1; //reset block count
count=0;
// Find unused file name.
if (BASE_NAME_SIZE > 5) {
}
while (sd.exists(binName)) {
if (binName[BASE_NAME_SIZE + 2] != '9') {
binName[BASE_NAME_SIZE + 2]++; //changed from +1 since now 0-999 instead of 0-99
}
else {
binName[BASE_NAME_SIZE + 2] = '0';
//binName[BASE_NAME_SIZE + 1]++;
if (binName[BASE_NAME_SIZE+1] == '9') {
binName[BASE_NAME_SIZE + 1] = '0';
binName[BASE_NAME_SIZE ]++;
}
else{
if (binName[BASE_NAME_SIZE] == '9') ;
binName[BASE_NAME_SIZE + 1]++;
}
}
}
// Serial.println(binName);
// delete old log file
if (sd.exists(TMP_FILE_NAME)) {
if (!sd.remove(TMP_FILE_NAME)) ;
}
// create new file
myFile.close();
if (!myFile.createContiguous(sd.vwd(),
TMP_FILE_NAME, 512 * FILE_BLOCK_COUNT));
// get address of file on SD
if (!myFile.contiguousRange(&bgnBlock, &endBlock));
// use SdFat's internal buffer
pCache = (uint8_t*)sd.vol()->cacheClear();
if (pCache == 0);
memset(pCache, '0', 512);
// flash erase all data in file
uint32_t bgnErase = bgnBlock;
uint32_t endErase;
while (bgnErase < endBlock) {
endErase = bgnErase + ERASE_SIZE;
if (endErase > endBlock) endErase = endBlock;
if (!sd.card()->erase(bgnErase, endErase)) ;
bgnErase = endErase + 1;
}
}
time_t getTeensy3Time()
{
return Teensy3Clock.get();
}
void setup() {
Serial.begin(115200);
setSyncProvider(getTeensy3Time);
SdFile::dateTimeCallback(dateTime);
pinMode(ledPin, OUTPUT);
pinMode(readPin0, INPUT); //Read analog signal pin1
pinMode(readPin1, INPUT); //Read analog signal pin2
//Set ADC (Averaging and Resolution)
adc->setAveraging(32); // set number of averages
adc->setResolution(12); // set bits of resolution
// it can be ADC_VERY_LOW_SPEED, ADC_LOW_SPEED, ADC_MED_SPEED, ADC_HIGH_SPEED_16BITS, ADC_HIGH_SPEED or ADC_VERY_HIGH_SPEED
//try low/med speed since load cell has high impedence
adc->setConversionSpeed(ADC_HIGH_SPEED); // change the conversion speed
// it can be ADC_VERY_LOW_SPEED, ADC_LOW_SPEED, ADC_MED_SPEED, ADC_HIGH_SPEED or ADC_VERY_HIGH_SPEED
adc->setSamplingSpeed(ADC_HIGH_SPEED); // change the sampling speed
//adc->enableCompare(1.0/3.3*adc->getMaxValue(ADC_0), 0, ADC_0); // measurement will be ready if value < 1.0V
// adc->enableCompareRange(1.0*adc->getMaxValue(ADC_0)/3.3, 2.0*adc->getMaxValue(ADC_0)/3.3, 0, 1, ADC_0); // ready if value lies out of [1.0,2.0] V
adc->setAveraging(32, ADC_1); // set number of averages
adc->setResolution(12, ADC_1); // set bits of resolution
adc->setConversionSpeed(ADC_HIGH_SPEED, ADC_1); // change the conversion speed
adc->setSamplingSpeed(ADC_HIGH_SPEED, ADC_1); // change the sampling speed
// always call the compare functions after changing the resolution!
// adc->enableCompare(1.0/3.3*adc->getMaxValue(ADC_1), 0, ADC_1); // measurement will be ready if value < 1.0V
// adc->enableCompareRange(1.0*adc->getMaxValue(ADC_1)/3.3, 2.0*adc->getMaxValue(ADC_1)/3.3, 0, 1, ADC_1); // ready if value lies out of [1.0,2.0] V
// Initialize SdFat or print a detailed error message and halt
// Use half speed like the native library.
// change to SPI_FULL_SPEED for more performance.
if (!sd.begin(chipSelect, SPI_FULL_SPEED)) sd.initErrorHalt();
createFile();
}
void loop() {
//not sure how you start/stop data collection
//Example using serial input
if (Serial.available()) {
c = Serial.read();
if(c=='r') { // Start recording
if (!sd.card()->writeStart(bgnBlock, FILE_BLOCK_COUNT))Serial.println("Recording") ;
//digitalWrite(LED,ledValue);//Turn LED on to indicate recording if you want
timer0.begin(timerCallback0, 40000); //start timer 4000=250sps
startTime=millis();
} else if(c=='s') { // stop recording
stopRecording();
}
}
delay(1);
}
void stopRecording(){
timer0.end(); //Turn off timer to stop SD card write
if (!sd.card()->writeStop())Serial.println("Stopped");
// Truncate file if recording stopped early.
if (bn != FILE_BLOCK_COUNT) {
if (!myFile.truncate(512L * bn)) ;
}
binaryToCsv();
if (!myFile.rename(sd.vwd(), binName)) ;
createFile();
}
void timerCallback0(){
result = adc->analogSynchronizedRead(readPin0, readPin1);
float ADCvalue_0 = result.result_adc0*3.3/adc->adc0->getMaxValue();
float ADCvalue_1 = result.result_adc1*3.3/adc->adc1->getMaxValue();
if (count < 128){ //since using float values, 128x4=512bytes
//Conversion issue fixed, so don't need code commented out below
// && (result.result_adc0 !=ADC_ERROR_VALUE) && (result.result_adc1 !=ADC_ERROR_VALUE)
SDBuffer[count] = millis()-startTime; //if you don't get a start time, then will be time since program started
SDBuffer[count+1] = ADCvalue_0-ADCvalue_1;
SDBuffer[count+2] = ADCvalue_0;
SDBuffer[count+3] = ADCvalue_1;
Serial.print("Time: ");
Serial.print(SDBuffer[count]);
Serial.print("\t");
Serial.print("A-B: ");
Serial.print(SDBuffer[count+1],DEC);
Serial.print("\t");
Serial.print("A: ");
Serial.print(SDBuffer[count+2],DEC);
Serial.print("\t");
Serial.print("B: ");
Serial.println(SDBuffer[count+3],DEC);
count = count + 4;//move index 4 positions for next values
}
if (count== 128){
noInterrupts();
memcpy(pCache, &SDBuffer, 512);
if (!sd.card()->writeData((uint8_t*)pCache)) ;
bn++; //increment block number
count = 0;
memset(pCache, '0', 512);
interrupts();
}
}
void binaryToCsv() {
uint8_t lastPct = 0;
float buf[128]; //changed to float
//metadata_t* pm;
uint32_t t0 = millis();
uint32_t syncCluster = 0;
SdFile csvFile;
char csvName[13];
BufferedWriter bw;
if (!myFile.isOpen()) {
Serial.println(F("No current binary file"));
return;
}
myFile.rewind();
// create a new csvFile
strcpy(csvName, binName);
strcpy_P(&csvName[BASE_NAME_SIZE + 3], PSTR(".CSV"));
if (!csvFile.open(csvName, O_WRITE | O_CREAT | O_TRUNC)) {
error("open csvFile failed");
}
Serial.println();
Serial.print(F("Writing: "));
Serial.print(csvName);
Serial.println(F(" - type any character to stop"));
//pm = (metadata_t*)&buf;
bw.init(&csvFile);
bw.putStr_P(PSTR("Time,")); //Write header at top of file
bw.putStr_P(PSTR("A-B,"));
bw.putStr_P(PSTR("A,"));
bw.putStr_P(PSTR("B"));
bw.putCRLF();
uint32_t tPct = millis();
while (!Serial.available() && myFile.read(&buf, 512) == 512) {
uint16_t i;
//read 512 bytes of data here ie:128 samples
for (i = 0; i < 128; i++) {
bw.putNum(buf[i],6); //Change 4 to what ever level of decimals you want
if((i + 1)%4) { //since 4 data points, it put a comma between 3 points and on the 4th,send a carrige return
bw.putChar(',');
} else {
bw.putCRLF();
}
}
if (csvFile.curCluster() != syncCluster) {
bw.writeBuf();
csvFile.sync();
syncCluster = csvFile.curCluster();
}
//looks like code to print out % done
if ((millis() - tPct) > 1000) {
uint8_t pct = myFile.curPosition()/(myFile.fileSize()/100);
if (pct != lastPct) {
tPct = millis();
lastPct = pct;
Serial.print(pct, DEC);
Serial.println('%');
}
}
if (Serial.available()) break;
}
bw.writeBuf();
csvFile.close();
Serial.print(F("Done: "));
Serial.print(0.001*(millis() - t0));
Serial.println(F(" Seconds"));
}
