boolean MP3Player::mp3PlayCallback() { if(filesize==0 &&PLAY==true) { return false; } else if(filesize>0 &&PLAY==true) { if(k>=BUF_SIZE) { //if buffer emptied refill buffer //word res= myFile.read(AudioBuf, BUF_SIZE); //reset counter k=0; } if(STA013_DATREQ()) // if STA013 request data { STA013_CSH(); //enable STA013 SPI.transfer(AudioBuf[k]); //send data STA013_CSL(); //disable STA013 k++; filesize--; //counting down } return true; } else return false; }
void readSettings() { int n,cc; char ch, buff[24]; char buff2[80]; unsigned int ndx=0; int read=0; if (!settingsFile.open(&root, settingsFileName, O_READ)) { console.printf("DBG: Creating New Settings File\r\n"); console.flush(); writeSettings(); return; } console.printf("DBG: Opened Settings File: %s\r\n",settingsFileName); settingsFile.seekSet(0); while ((read=settingsFile.read(buff, sizeof(buff))) > 0) { //console.printf("DBG: READ %d\r\n",read); console.flush(); for (cc=0; cc < read ; cc++) { ch=buff[cc]; //console.putChar(ch); console.flush(); buff2[ndx]=ch; if (ndx<MAX_INPUT_LINE) {ndx++;} if (ch=='\n'){//console.putChar('\r'); if(ndx) { ndx--; // eat the newline. } buff2[ndx]='\0'; //console.puts(buff2); if ((ndx>4) && buff2[3]=='!') {//fix this when the files are better buff2[3]='\0'; n=lookupIndex(buff2); switch (n) { case _NPW_: networkSetPassword(buff2+4); break; case _NJN_: Watchdog_Reset(); networkJoin(buff2 +4); break; case _PKY_: strncpy(pachubeKey, buff2+4, MAX_PATCHUBE_KEY_LENGHT-1); break; case _PFD_: strncpy(pachubeFeed, buff2+4, MAX_PATCHUBE_FEED_LENGHT-1); break; default: break; } } ndx=0; } } } console.printf("DBG: Finished with Settings File: %s\r\n",settingsFileName); settingsFile.close(); }
int WiFiCmdRobot::WiFiSendPicture (int16_t n) { int ret=SUCCESS; int16_t nbytes; uint8_t buf[PAYLOAD_SIZE]; char filename[12+1]; Serial.print("n: "); Serial.println(n); // Open the file sprintf(filename, "PICT%02d.jpg", n); if (!FilePicture.open(&root, filename, O_READ)) return FILE_OPEN_ERROR; Serial.print("Open file: "); Serial.println(filename); // read from the file until there's nothing else in it: while ((nbytes = FilePicture.read(buf, sizeof(buf))) > 0 && ret == SUCCESS) { for (unsigned int idx = 0; idx<nbytes;idx++) { tcpClient.print(buf[idx]); } }// while //Close file if (!FilePicture.close()) return FILE_CLOSE_ERROR; return SUCCESS; }
// grafix has to be stored at /gfx/ int speedo_disp::sd2ssd(char filename[10],int frame){ send_command(0x15); send_command(0x00); send_command(0x7F); send_command(0x75); send_command(0x00); send_command(0x3F); SdFile root; SdFile file; SdFile subdir; root.openRoot(&pSD->volume); if(!subdir.open(&root, "gfx", O_READ)) { return 1; }; if(!file.open(&subdir, filename, O_READ)) { return 2; }; unsigned long frame_seeker=(unsigned long)frame*64*64; if(!file.seekSet(frame_seeker)) { return 3; }; // ein bild ist 64*64 Byte groß, da wir 64 lines zu je 64*2*4 Bit Breite haben uint8_t buf[65]; //int n; //while ((n = file.read(buf, sizeof(byte)*64)) > 0) { for (int zeile=0; (file.read(buf, sizeof(byte)*64)>0) && zeile<64; zeile++ ) { for(int j=0;j<64;j++){ send_char(buf[j]); }; }; file.close(); subdir.close(); root.close(); return 0; };
void AtMegaWebServer::send_file(SdFile& file) { size_t size; while ((size = file.read(buffer, sizeof(buffer))) > 0) { if (!client_.connected()) { break; } client_.write((uint8_t*)buffer, size); } }
void TinyWebServer::send_file(SdFile& file) { char _buf[512]; size_t size; while ((size = file.read(_buf, sizeof(_buf))) > 0) { if (!client_.connected()) { break; } write((uint8_t*)_buf, size); } }
void loop() { uint32_t t; double r; Serial.println("Type any character to start"); while (!Serial.available()) SPARK_WLAN_Loop(); while (Serial.available()) Serial.read(); // open or create file - truncate existing file. if (!file.open(&root, "BENCH.DAT", O_CREAT | O_TRUNC | O_RDWR)) { error("open failed"); } // fill buf with known data for (uint16_t i = 0; i < (BUF_SIZE-2); i++) { buf[i] = 'A' + (i % 26); } buf[BUF_SIZE-2] = '\r'; buf[BUF_SIZE-1] = '\n'; Serial.print("File size "); Serial.print(FILE_SIZE_MB); Serial.println(" MB"); uint32_t n = FILE_SIZE/sizeof(buf); Serial.println("Starting write test. Please wait up to a minute"); // do write test t = millis(); for (uint32_t i = 0; i < n; i++) { if (file.write(buf, sizeof(buf)) != sizeof(buf)) { error("write failed"); } } t = millis() - t; file.sync(); r = (double)file.fileSize()/t; Serial.print("Write "); Serial.print(r); Serial.println(" kB/sec"); Serial.println(); Serial.println("Starting read test. Please wait up to a minute"); // do read test file.rewind(); t = millis(); for (uint32_t i = 0; i < n; i++) { if (file.read(buf, sizeof(buf)) != sizeof(buf)) { error("read failed"); } } t = millis() - t; r = (double)file.fileSize()/t; Serial.print("Read "); Serial.print(r); Serial.println(" kB/sec"); Serial.println("Done"); file.close(); }
void HAL::importEEPROM() { if (eepromFile.isOpen()) eepromFile.close(); if (!eepromFile.open("eeprom.bin", O_RDWR | O_CREAT | O_SYNC) || eepromFile.read(virtualEeprom, EEPROM_BYTES) != EEPROM_BYTES) { Com::printFLN(Com::tOpenFailedFile, "eeprom.bin"); } else { Com::printFLN("EEPROM read from sd card."); } EEPROM::readDataFromEEPROM(true); }
void setup(void) { Serial.begin(BPS_115200); Serial.println(); PgmPrintln("Type any character to start"); while (!Serial.available()); //PgmPrint("FreeRam: "); //Serial.println(FreeRam()); // initialize the SD card at SPI_HALF_SPEED to avoid bus errors with // breadboards. use SPI_FULL_SPEED for better performance. if (!card.init(SPI_HALF_SPEED)) error("card.init failed"); // initialize a FAT volume if (!volume.init(&card)) error("volume.init failed"); // open the root directory if (!root.openRoot(&volume)) error("openRoot failed"); strcpy_P(buf, PSTR("APPEND.TXT")); // open for read if (!from.open(&root, buf, O_READ)) { PgmPrint("Can't open "); Serial.println(buf); PgmPrintln("Run the append example to create the file."); error("from.open failed"); } strcpy_P(buf, PSTR("ACOPY.TXT")); // create if needed, truncate to zero length, open for write if (!copy.open(&root, buf, O_CREAT | O_TRUNC | O_WRITE)) { error("copy.open failed"); } // count for printing periods uint16_t p = 0; int16_t n; while ((n = from.read(buf, sizeof(buf))) > 0) { if (copy.write(buf, n) != n) error("write failed"); // print progress periods if (!(p++ % 25)) Serial.print('.'); if (!(p % 500)) Serial.println(); } Serial.println(); if (n != 0) error ("read"); // force write of directory entry and last data if (!copy.close()) error("copy.close failed"); PgmPrintln("Copy done."); }
static void ServeFile(FILE * stream_file, const char * fname, SdFile & theFile, EthernetClient & client) { freeMemory(); const char * ext; for (ext=fname + strlen(fname); ext>fname; ext--) if (*ext == '.') { ext++; break; } if (ext > fname) { if (strcmp(ext, "jpg") == 0) ServeHeader(stream_file, 200, "OK", true, "image/jpeg"); else if (strcmp(ext, "gif") == 0) ServeHeader(stream_file, 200, "OK", true, "image/gif"); else if (strcmp(ext, "css") == 0) ServeHeader(stream_file, 200, "OK", true, "text/css"); else if (strcmp(ext, "js") == 0) ServeHeader(stream_file, 200, "OK", true, "application/javascript"); else if (strcmp(ext, "ico") == 0) ServeHeader(stream_file, 200, "OK", true, "image/x-icon"); else ServeHeader(stream_file, 200, "OK", true); } else ServeHeader(stream_file, 200, "OK", true); #ifdef ARDUINO flush_sendbuf(client); #else fflush(stream_file); #endif while (theFile.available()) { int bytes = theFile.read(sendbuf, 512); if (bytes <= 0) break; client.write((uint8_t*) sendbuf, bytes); } }
void setup(void) { Serial.begin(9600); Serial.println(); Serial.println("type any character to start"); while (!Serial.available()); Serial.println(); // initialize the SD card at SPI_HALF_SPEED to avoid bus errors with // breadboards. use SPI_FULL_SPEED for better performance. if (!card.init(SPI_HALF_SPEED)) error("card.init failed"); // initialize a FAT volume if (!volume.init(&card)) error("volume.init failed"); // open the root directory if (!root.openRoot(&volume)) error("openRoot failed"); // open a file if (file.open(&root, "PRINT00.TXT", O_READ)) { Serial.println("Opened PRINT00.TXT"); } else if (file.open(&root, "WRITE00.TXT", O_READ)) { Serial.println("Opened WRITE00.TXT"); } else { error("file.open failed"); } Serial.println(); // copy file to serial port int16_t n; uint8_t buf[7];// nothing special about 7, just a lucky number. while ((n = file.read(buf, sizeof(buf))) > 0) { for (uint8_t i = 0; i < n; i++) Serial.print(buf[i]); } /* easier way int16_t c; while ((c = file.read()) > 0) Serial.print((char)c); */ Serial.println("\nDone"); }
idigi_callback_status_t iDigiFileSystem::app_process_file_read(idigi_file_request_t * const request_data, idigi_file_data_response_t * const response_data) { idigi_callback_status_t status = idigi_callback_continue; SdFile *file = (SdFile *) request_data->handle; int const result = file->read(response_data->data_ptr, response_data->size_in_bytes); if (result < 0) { APP_DEBUG("read %p req %d, returned err %d\n", (void *) file, response_data->size_in_bytes, result); response_data->error->error_status = idigi_file_unspec_error; goto done; } APP_DEBUG("read %p req %d, returned %d\n", (void *) file, response_data->size_in_bytes, result); response_data->size_in_bytes = result; done: return status; }
boolean MP3Player::Setup_STA013(void) { byte buf[2]; if (!myFile.open("sta013.cfg", O_READ)) { #if DEBUG sd.errorHalt("cfg file error"); #endif return false; } #if DEBUG Serial.println("setting STA013 from cfgfile"); #endif while (myFile.available()) { buf[0]=byte (myFile.read()); buf[1]=byte (myFile.read()); I2C_Write(buf[0], buf[1]); // Serial.write(buf[0]); // Serial.write(buf[1]); } while(!myFile.close()) { #if DEBUG Serial.println("close cfg file.."); #endif } #if DEBUG Serial.println("Setup STA013 Register Done.."); #endif return true; }
boolean SD_ReadFile(const char *filename) { uint32_t t_arrival = millis(); boolean retVal = false; sdf.chdir(); if (!file.open(filename, O_READ)) { sdf.errorHalt("opening FILE for read failed"); } else { uint32_t len = file.fileSize(); uint8_t index = 0; for(uint32_t i=0; i< len; i++) { int intData = file.read(); char byteData; int base = 10u; //itoa(intData,&byteData,base); // Convert to ASCII buffer[index] = (uint8_t)intData;//byteData; if(index < 63u) { index++; } else { usb_rawhid_send(buffer, 100u); index = 0; } } file.close(); uint32_t t_exit = millis() - t_arrival; buffer[62] = (uint8_t)((t_exit & 0x000000FF)>>8); buffer[63] = (uint8_t)t_exit; usb_rawhid_send(buffer,100u); } }
int UTFT_SdRaw::pan(int dispx, int dispy, int sx, int sy, unsigned long offsetx, unsigned long offsety, unsigned long sizex, unsigned long sizey, char *filename, bool iswap) { char buffer[2*sx]; int cx, cy, cp; word temp, result; unsigned long temp1,temp2; temp1=sizex*2; temp2=offsetx*2; if (dataFile.open(filename)) { cbi(_UTFT->P_CS, _UTFT->B_CS); cx=0; cy=0; result=sx; if (_UTFT->orient==PORTRAIT) { _UTFT->setXY(dispx, dispy, dispx+sx-1, dispy+sy-1); } for(int n=0;n<sy;n++) { dataFile.seekSet(((n+offsety)*temp1)+temp2); result=dataFile.read(&buffer,2*sx); if (_UTFT->orient==PORTRAIT) { for (int i=0; i<result; i+=2) { if(iswap==1) { _UTFT->LCD_Write_DATA(buffer[i+1],buffer[i]); } else { _UTFT->LCD_Write_DATA(buffer[i],buffer[i+1]); } } } else { cp=0; while (cp<result) { if (((result-cp)/2)<(sx-cx)) { _UTFT->setXY(dispx+cx, dispy+cy, dispx+cx+((result-cp)/2)-1, dispy+cy); for (int i=(result-cp)-2; i>=0; i-=2) { if(iswap==1) { _UTFT->LCD_Write_DATA(buffer[cp+i+1],buffer[cp+i]); } else { _UTFT->LCD_Write_DATA(buffer[cp+i],buffer[cp+i+1]); } } cx+=((result-cp)/2); cp=result; } else { _UTFT->setXY(dispx+cx, dispy+cy, dispx+sx-1, dispy+cy); for (int i=sx-cx-1; i>=0; i--) { if(iswap==1) { _UTFT->LCD_Write_DATA(buffer[cp+(i*2)+1],buffer[cp+(i*2)]); } else { _UTFT->LCD_Write_DATA(buffer[cp+(i*2)],buffer[cp+(i*2)+1]); } } cp+=(sx-cx)*2; cx=0; cy++; } } } } dataFile.close(); _UTFT->setXY(0,0,_UTFT->getDisplayXSize()-1,_UTFT->getDisplayYSize()-1); sbi(_UTFT->P_CS, _UTFT->B_CS); return 0; } else { return 99; } }
void loop() { if(count >=500) { led2 = !led2; digitalWrite(redLEDpin, led2); count = 0; } count +=1; char clientline[BUFSIZ]; char *filename; int image = 0; int index = 0; Client client = server.available(); if (client) { boolean current_line_is_blank = true; index = 0; while (client.connected()) { if (client.available()) { char c = client.read(); if (c != '\n' && c != '\r') { clientline[index] = c; index++; if (index >= BUFSIZ) index = BUFSIZ -1; continue; } clientline[index] = 0; filename = 0; Serial.println(clientline); if (strstr(clientline, "GET /?") != 0) { if (!filename) filename = clientline + 5; { Serial.println(filename); int a=atoi(&filename[1]); Serial.println(a); int pin_num=0; int on_off=0; switch (a) { case 10 pin_num=1; on_off=LOW; break; case 11 pin_num=1; on_off=HIGH; break; case 20 pin_num=2; on_off=LOW; break; case 21 pin_num=2; on_off=HIGH; break; case 30 pin_num=3; on_off=LOW; break; case 31 pin_num=3; on_off=HIGH; break; case 40 pin_num=4; on_off=LOW; break; case 41 pin_num=4; on_off=HIGH; break; case 50 pin_num=5; on_off=LOW; break; case 51 pin_num=5; on_off=HIGH; break; case 60 pin_num=6; on_off=LOW; break; case 61 pin_num=6; on_off=HIGH; break; case 70 pin_num=7; on_off=LOW; break; case 71 pin_num=7; on_off=HIGH; break; case 80 pin_num=8; on_off=LOW; break; case 81 pin_num=8; on_off=HIGH; break; } if(pin_num!=0) { Serial.print("Pin:"); Serial.print(pin_num); Serial.print(" State:"); Serial.print(on_off); digitalWrite(pin_num, on_off); } } } if (strstr(clientline, "GET / ") != 0) { filename = rootFileName; } if (strstr(clientline, "GET /") != 0) { if (!filename) filename = clientline + 5; (strstr(clientline, " HTTP"))[0] = 0; Serial.println(filename); if (! file.open(&root, filename, O_READ)) { client.println("HTTP/1.1 4041 Not Found"); client.println("Content-Type: text/html"); client.println(); client.println("<h2>Error 4041</h2>"); client.println("<s2>The file does not exist.<s2>"); client.println(""); break; } Serial.println("Opened!"); //File types client.println("HTTP/1.1 200 OK"); if (strstr(filename, ".htm") != 0) client.println("Content-Type: text/html"); else if (strstr(filename, ".css") != 0) client.println("Content-Type: text/css"); else if (strstr(filename, ".png") != 0) client.println("Content-Type: image/png"); else if (strstr(filename, ".jpg") != 0) client.println("Content-Type: image/jpeg"); else if (strstr(filename, ".gif") != 0) client.println("Content-Type: image/gif"); else if (strstr(filename, ".3gp") != 0) client.println("Content-Type: video/mpeg"); else if (strstr(filename, ".pdf") != 0) client.println("Content-Type: application/pdf"); else if (strstr(filename, ".js") != 0) client.println("Content-Type: application/x-javascript"); else if (strstr(filename, ".xml") != 0) client.println("Content-Type: application/xml"); else client.println("Content-Type: text"); client.println(); int16_t c; while ((c = file.read()) >= 0) { //Serial.print((char)c); //Prints all HTML code to serial (For debuging) client.print((char)c); //Prints all HTML code for web page } //Hit counter math if(units >= 2) { hits ++; units = 0; } units +=1; //End hit counter math client.print("<html><body>"); //HTML code starts here client.print("<P align=\"center\">"); client.print("Hits since reset: <b>"); client.print(hits); //Print hits to client client.print("</b><br>"); photocellReading = analogRead(photocellPin); client.print("Light reading: "); client.print(photocellReading); //Prints light reading to client // A few threshholds if (photocellReading < 10) { client.print(" - Dark"); } else if (photocellReading < 200) { client.print(" - Dim"); } else if (photocellReading < 500) { client.print(" - Light"); } else if (photocellReading < 800) { client.print(" - Bright"); } else { client.print(" - Very bright"); } client.print("</p></body></html>"); //HTML code ends here //End hit counter and light value file.close(); } else { client.println("HTTP/1.1 4042 Not Found"); client.println("Content-Type: text/html"); client.println(); client.println("<h2>Error 4042</h2>"); client.println(""); } break; } } digitalWrite(greenLEDandBEEP, HIGH); delay(1); digitalWrite(greenLEDandBEEP, LOW); client.stop(); }
/* * create enough files to force a cluster to be allocated to dir. */ void dirAllocTest(SdFile &dir) { char buf[13], name[13]; SdFile file; uint16_t n; uint32_t size = dir.fileSize(); // create files and write name to file for (n = 0; ; n++){ // make file name sprintf(name, "%u.TXT", n); // open start time uint32_t t0 = millis(); if (!file.open(&dir, name, O_WRITE | O_CREAT | O_EXCL)) { error("open for write failed"); } // open end time and write start time uint32_t t1 = millis(); // write file name to file file.print(name); if (!file.close()) error("close write"); // write end time uint32_t t2 = millis(); PgmPrint("WR "); Serial.print(n); Serial.print(' '); // print time to create file Serial.print(t1 - t0); Serial.print(' '); // print time to write file Serial.println(t2 - t1); // directory size will change when a cluster is added if (dir.fileSize() != size) break; } // read files and check content for (uint16_t i = 0; i <= n; i++) { sprintf(name, "%u.TXT", i); // open start time uint32_t t0 = millis(); if (!file.open(&dir, name, O_READ)) { error("open for read failed"); } // open end time and read start time uint32_t t1 = millis(); int16_t nr = file.read(buf, 13); if (nr < 5) error("file.read failed"); // read end time uint32_t t2 = millis(); // check file content if (strlen(name) != (uint16_t)nr || strncmp(name, buf, nr)) { error("content compare failed"); } if (!file.close()) error("close read failed"); PgmPrint("RD "); Serial.print(i); Serial.print(' '); // print open time Serial.print(t1 - t0); Serial.print(' '); // print read time Serial.println(t2 - t1); } }
void loop() { unsigned long tick = millis(); long diff = tick - lastTick; avgTickDelay = expAvg(avgTickDelay, diff); lastTick = tick; if (printTicks > printTicksI) { Serial.print("tick delay: "); Serial.print(diff); Serial.println("ms"); } // Radio tick. radio->tick(); // Send helo. diff = tick - lastSent; if ((lastAck < lastSent && diff > MAX_SEND_WAIT) || diff > MIN_SEND_WAIT ) { avgSendDelay = expAvg(avgSendDelay, diff); lastSent = tick; if (printTicks > printTicksI) { printTicksI++; Serial.print("send delay: "); Serial.print(diff); Serial.println("ms"); } if (sendInfx) { Message msg("he"); radio->send(&msg); } else { Message msg("lo"); radio->send(&msg); } sendInfx = !sendInfx; } // Update metrics. tick = millis(); if (tick - lastUpdate > UPDATE_WAIT) { memcpy(&mLast, &m, sizeof(metrics)); lastUpdate = tick; lastVcc = readVcc(); sinceLastAck = (int) ((lastUpdate - lastAck) / 1000L); if (sinceLastAck < 0) { #ifdef DEBUG Serial.println("sinceLastAck less than 0"); Serial.print("round(("); Serial.print(lastUpdate); Serial.print(" - "); Serial.print(lastAck); Serial.print(") / 1000.0) = "); Serial.println(sinceLastAck); #endif sinceLastAck = 0; } if (lastAck + TIMEOUT_WAIT < lastSent) { lastRoundtrip = NO_READING_INT; lastRssi = NO_READING_INT; } writeLog(); } // Pipeline tick. pipe->tick(); // Serial commands. if (Serial.available()) { String cmd = Serial.readStringUntil('\n'); if (cmd[0] == 'D') { dataFile.close(); if (!dataFile.open(root, logFilename, O_READ)) { Serial.println(); Serial.println("Could not open file for reading"); return; } uint32_t offset; long cmdOffset = cmd.substring(1).toInt(); if (cmdOffset < 0) { offset = dataFile.fileSize() + cmdOffset; } else { offset = cmdOffset; } dataFile.seekSet(offset); char buf[128]; int16_t read; bool firstRead = true; do { read = dataFile.read(buf, 127); buf[read] = 0; if (firstRead && read > 0) { firstRead = false; char *firstNewline = strchr(buf, '\n'); Serial.print(++firstNewline); } else { Serial.print(buf); } } while (read > 0); Serial.println(); dataFile.close(); } else if (cmd[0] == 'L') { printCardInfo(); } else if (cmd[0] == 'I') { Serial.print(F("Average tick delay: ")); Serial.print(avgTickDelay); Serial.println(F("ms")); Serial.print(F("Average send delay: ")); Serial.print(avgSendDelay); Serial.println(F("ms")); Serial.print(F("RAM free: ")); Serial.print(freeRam()); Serial.println(F(" bytes")); printTicks = (int) cmd.substring(1).toInt(); printTicksI = 0; } else if (cmd[0] == 'G') { Serial.print(F("Location: ")); Serial.print(m.latitude, 6); Serial.print(F(",")); Serial.println(m.longitude, 6); } else if (cmd[0] == 'U') { Message msg("up"); radio->send(&msg); } else if (cmd[0] == 'F') { if (m.logging != MODULE_ENABLED) { Serial.println(F("Requesting to enable logging")); } else { Serial.println(F("Requesting to disable logging")); } Message msg("tl"); radio->send(&msg); } else if (cmd[0] == 'T') { Serial.print(F("Remote data logging is ")); Serial.println(m.logging == MODULE_ENABLED ? "enabled" : "disabled"); } } }
void setup() { int logNo; char configLineBuffer[LINE_BUFFER_MAX]; spi.begin(SPI_281_250KHZ, MSBFIRST, 0); pinMode(GRN_LED,OUTPUT); pinMode(ORN_LED,OUTPUT); pinMode(RED_LED,OUTPUT); digitalWrite(GRN_LED,HIGH); digitalWrite(ORN_LED,LOW); digitalWrite(RED_LED,LOW); iwdg_init(IWDG_PRE_256, WATCHDOG_TIMEOUT); Watchdog_Reset(); if (!card.init(&spi)) { //if (!card.init()) { console.printf("FTL: card.init failed"); } delay(100); // initialize a FAT volume if (!volume.init(&card)) { console.printf("FTL: volume.init failed"); } // open the root directory if (!root.openRoot(&volume)) ;//SerialUSB.println("FTL: openRoot failed"); for (logNo=0; (!logOpened) && logNo<512; logNo++) { Watchdog_Reset(); //int snprintf(char *str, size_t size, const char *format, ...); snprintf(logFileName,15,"LOG%03d.TXT",logNo); if (file.open(&root, logFileName, O_READ)) { //SerialUSB.print("DBG: Exists :"); SerialUSB.println(logFileName); file.close(); } else if (file.open(&root, logFileName, O_CREAT|O_READ|O_WRITE)) { //SerialUSB.print("DBG: New File:"); SerialUSB.println(logFileName); logOpened=true; file.sync(); file.close(); file.open(&root,logFileName,O_WRITE|O_READ); while (file.read(configLineBuffer,LINE_BUFFER_MAX)) { } file.sync(); } } //if (!logOpened) SerialUSB.println("FTL: openRoot failed"); digitalWrite(GRN_LED,LOW); digitalWrite(RED_LED,HIGH); readSettings(); console.printf("LSV:" BOM_VERSION "\r\n"); console.printf("NST: %s\r\n",networkStatus()?"CONNECTED":"NOT CONNECTED"); digitalWrite(ORN_LED,HIGH); digitalWrite(RED_LED,networkStatus()?HIGH:LOW); }
void writeGPSLog(uint32_t gpstime, int32_t latitude, int32_t longitude, int32_t altitude) { #else void writeGPSLog(int32_t latitude, int32_t longitude, int32_t altitude) { #endif if (f.SDCARD == 0) return; if (gps_data.open(GPS_LOG_FILENAME, O_WRITE | O_CREAT | O_APPEND)) { #ifdef UBLOX gps_data.print(gpstime); gps_data.write(','); #endif gps_data.print(latitude); gps_data.write(','); gps_data.print(longitude); gps_data.write(','); gps_data.print(altitude); gps_data.println(); gps_data.close(); } else { return; } } void writePLogToSD() { if (f.SDCARD == 0) return; plog.checksum = calculate_sum((uint8_t*)&plog, sizeof(plog)); if (permanent.open(PERMANENT_LOG_FILENAME, O_WRITE | O_CREAT | O_TRUNC)) { permanent.print(F("arm=")); permanent.println(plog.arm); permanent.print(F("disarm=")); permanent.println(plog.disarm); permanent.print(F("start=")); permanent.println(plog.start); permanent.print(F("armed_time=")); permanent.println(plog.armed_time); permanent.print(F("lifetime=")); permanent.println(plog.lifetime, DEC); permanent.print(F("failsafe=")); permanent.println(plog.failsafe); permanent.print(F("i2c=")); permanent.println(plog.i2c); permanent.print(F("running=")); permanent.println(plog.running, DEC); permanent.print(F("checksum=")); permanent.println(plog.checksum, DEC); permanent.print(F("debug=")); permanent.print(debug[0]); permanent.print(F(",")); permanent.print(debug[1]); permanent.print(F(",")); permanent.print(debug[2]); permanent.print(F(",")); permanent.println(debug[3]); permanent.println(); permanent.close(); } else { return; } } void fillPlogStruct(char* key, char* value) { if (strcmp(key, "arm") == 0) sscanf(value, "%u", &plog.arm); if (strcmp(key, "disarm") == 0) sscanf(value, "%u", &plog.disarm); if (strcmp(key, "start") == 0) sscanf(value, "%u", &plog.start); if (strcmp(key, "armed_time") == 0) sscanf(value, "%lu", &plog.armed_time); if (strcmp(key, "lifetime") == 0) sscanf(value, "%lu", &plog.lifetime); if (strcmp(key, "failsafe") == 0) sscanf(value, "%u", &plog.failsafe); if (strcmp(key, "i2c") == 0) sscanf(value, "%u", &plog.i2c); if (strcmp(key, "running") == 0) sscanf(value, "%hhu", &plog.running); if (strcmp(key, "checksum") == 0) sscanf(value, "%hhu", &plog.checksum); } void readPLogFromSD() { if (f.SDCARD == 0) return; SdFile myfile; char key[12]; char value[32]; char* tabPtr = key; int c; uint8_t i = 0; if (myfile.open(PERMANENT_LOG_FILENAME, O_READ)) { while (myfile.available()) { c = myfile.read(); switch ((char)c) { case ' ': break; case '=': *tabPtr = '\0'; tabPtr = value; break; case '\n': *tabPtr = '\0'; tabPtr = key; i = 0; fillPlogStruct(key, value); memset(key, '\0', sizeof(key)); memset(value, '\0', sizeof(value)); break; default: i++; if (i <= 12) { *tabPtr = (char)c; tabPtr++; } break; } } } else return; if (calculate_sum((uint8_t*)&plog, sizeof(plog)) != plog.checksum) { #if defined(BUZZER) alarmArray[7] = 3; blinkLED(9, 100, 3); #endif // force load defaults plog.arm = plog.disarm = plog.start = plog.failsafe = plog.i2c = 11; plog.running = 1; plog.lifetime = plog.armed_time = 3; writePLogToSD(); } }
int UTFT_SdRaw::load(int x, int y, int sx, int sy, char *filename, int bufmult, bool iswap) { char buf[(2*bufmult)*sx]; int cx, cy, cp; word result; if (dataFile.open(filename)) { cbi(_UTFT->P_CS, _UTFT->B_CS); cx=0; cy=0; result=bufmult*sx; if (_UTFT->orient==PORTRAIT) { _UTFT->setXY(x, y, x+sx-1, y+sy-1); } for(int n=0;n<sy;n+=bufmult) { result=dataFile.read(&buf,(2*bufmult)*sx); if (_UTFT->orient==PORTRAIT) { for (int i=0; i<result; i+=2) { if(iswap==1) { _UTFT->LCD_Write_DATA(buf[i+1],buf[i]); } else { _UTFT->LCD_Write_DATA(buf[i],buf[i+1]); } } } else { cp=0; while (cp<result) { if (((result-cp)/2)<(sx-cx)) { _UTFT->setXY(x+cx, y+cy, x+cx+((result-cp)/2)-1, y+cy); for (int i=(result-cp)-2; i>=0; i-=2) { if(iswap==1) { _UTFT->LCD_Write_DATA(buf[cp+i+1],buf[cp+i]); } else { _UTFT->LCD_Write_DATA(buf[cp+i],buf[cp+i+1]); } } cx+=((result-cp)/2); cp=result; } else { _UTFT->setXY(x+cx, y+cy, x+sx-1, y+cy); for (int i=sx-cx-1; i>=0; i--) { if(iswap) { _UTFT->LCD_Write_DATA(buf[cp+(i*2)+1],buf[cp+(i*2)]); } else { _UTFT->LCD_Write_DATA(buf[cp+(i*2)],buf[cp+(i*2)+1]); } } cp+=(sx-cx)*2; cx=0; cy++; } } } } dataFile.close(); _UTFT->setXY(0,0,_UTFT->getDisplayXSize()-1,_UTFT->getDisplayYSize()-1); sbi(_UTFT->P_CS, _UTFT->B_CS); return 0; } else { return 99; } }
int robot_Send_Picture (uint8_t n) { uint16_t param[MAX_PARAMS]; uint8_t paramlen = 0; uint8_t msg[MSG_SIZE_MAX]; uint8_t msg_len = 0; uint8_t tag [MAX_TAGS]; uint16_t value [MAX_TAGS]; uint8_t nbtags; char filename[12+1]; uint16_t nbytes = 0; uint8_t buf[PAYLOAD_SIZE]; int ret = SUCCESS; Serial.println("Start robot_Send_Picture"); // Open picture file sprintf(filename, "PICT%d.jpg", n); if (!FilePicture.open(&root, filename, O_READ)) return FILE_OPEN_ERROR; Serial.println("open ok "); //Send the Picture message param[0] = (uint16_t)n; param[1] = (uint16_t)FilePicture.fileSize(); paramlen = 2; ret = IOTSerial.IOTSsend(1, PICTURE, param, paramlen); //Read the message replied to be sure that the client is ready to receive the picture ret = IOTSerial.IOTSread(1, msg, &msg_len); Serial.print("Call IOTSread 1, ret: "); Serial.print(ret); Serial.print(", msg_len: "); Serial.println((int)msg_len); if (ret != SUCCESS) { Serial.println("error IOTSread"); ret = IOTSerial.IOTSflush(1); return 0; } //Decode the message IOTSerial.IOTSgetTags(msg, tag, value, &nbtags); // parse the response Serial.print("Call IOTSgetTags, nbtags: "); Serial.println((int)nbtags); if (nbtags < 1) return -1; Serial.print("tag[0]: ");Serial.println((int)tag[0],HEX); if (tag[0]!= TAG_CMDID) return -2; Serial.print("tag[1]: "); Serial.println((int)tag[1]); if (tag[1]!= TAG_RESP) return -3; Serial.print("value[1]: "); Serial.println((int)value[1]); if (value[1] == RESP_KO) return -4; if (value[1] != RESP_OK) return -5; // read from the file until there's nothing else in it: while ((nbytes = FilePicture.read(buf, sizeof(buf))) > 0 && ret == SUCCESS) { for (uint16_t i = 0;i<nbytes;i++) { ret = IOTSerial.IOTSRawsend(1, buf [i]); } }// while //Close file if (!FilePicture.close()) return FILE_CLOSE_ERROR; Serial.println("End OK robot_IOT"); return SUCCESS; }
void setup() { Serial.begin(BPS_115200); PgmPrintln("Type any character to start"); while (!Serial.available()); // PgmPrint("Free RAM: "); /// Serial.println(FreeRam()); // initialize the SD card at SPI_FULL_SPEED for best performance. // try SPI_HALF_SPEED if bus errors occur. if (!card.init(SPI_FULL_SPEED)) error("card.init failed"); // initialize a FAT volume if (!volume.init(&card)) error("volume.init failed!"); PgmPrint("Type is FAT"); Serial.println(volume.fatType(), DEC); if (!root.openRoot(&volume)) error("openRoot failed"); // open or create file - truncate existing file. if (!file.open(&root, "BENCH.DAT", O_CREAT | O_TRUNC | O_RDWR)) { error("open failed"); } // fill buf with known data for (uint16_t i = 0; i < (BUF_SIZE-2); i++) { buf[i] = 'A' + (i % 26); } buf[BUF_SIZE-2] = '\r'; buf[BUF_SIZE-1] = '\n'; PgmPrint("File size "); Serial.print(FILE_SIZE_MB); PgmPrintln(" MB"); PgmPrintln("Starting write test. Please wait up to a minute"); // do write test uint32_t n = FILE_SIZE/sizeof(buf); uint32_t t = millis(); for (uint32_t i = 0; i < n; i++) { if (file.write(buf, sizeof(buf)) != sizeof(buf)) { error("write failed"); } } t = millis() - t; file.sync(); double r = (double)file.fileSize()/t; PgmPrint("Write "); Serial.print(r); PgmPrintln(" KB/sec"); Serial.println(); PgmPrintln("Starting read test. Please wait up to a minute"); // do read test file.rewind(); t = millis(); for (uint32_t i = 0; i < n; i++) { if (file.read(buf, sizeof(buf)) != sizeof(buf)) { error("read failed"); } } t = millis() - t; r = (double)file.fileSize()/t; PgmPrint("Read "); Serial.print(r); PgmPrintln(" KB/sec"); PgmPrintln("Done"); }
void setup() { Serial.begin(BPS_115200); Serial.println("> type any char to start"); while (!Serial.available()); Serial.println(); if (!card.init(SPI_HALF_SPEED)) Serial.println("> card.init failed"); else Serial.println("> card.init passed"); // spi.end(); SD_SPI.begin(SPI_HIGH_CLOCK, MSBFIRST, 0); delay(100); // initialize a FAT volume if (!volume.init(&card,1)) Serial.println("> volume.init failed"); else Serial.println("> volume.init passed"); // open the root directory if (!root.openRoot(&volume)) Serial.println("> openRoot failed"); else Serial.println("> openRoot passed"); // open a file if (file.open(&root, "Read.txt", O_READ)) { Serial.println("> Opened Read.txt"); Serial.println("> Reading ..."); Serial.println(); for(int i=0; i<15; i++) Serial.print((char)file.read()); Serial.println(""); } else { Serial.println("file.open failed"); } Serial.println(); Serial.println("> Reading remained data..."); Serial.println(); int16_t n; uint8_t buf[7];// nothing special about 7, just a lucky number. while ((n = file.read(buf, sizeof(buf))) > 0) { for (uint8_t i = 0; i < n; i++) Serial.print((char)buf[i]); } /* easier way int16_t c; while ((c = file.read()) > 0) Serial.print((char)c); */ file.close(); Serial.println("\n> Done"); SD_SPI.end(); }