void MP3Player::Halt()
{
Timer1.detachInterrupt();
PLAY=false;
while(!myFile.close())
{
#if DEBUG
Serial.println("close audio file");
#endif
}
//AMPSHUTDOWN();
#if DEBUG
Serial.println("finish");
#endif
delayMicroseconds(100000);
name = "";
if(isPlayAll)
PlayTrack("",0,"");
}
int wcs(const char *oname)
{
// char name[PATHLEN];
// strcpy(name, oname);
Eofseen = 0;
// vpos = 0;
switch (wctxpn(oname)) {
case ERROR:
return ERROR;
case ZSKIP:
return OK;
}
// ++Filcnt;
if(!Zmodem && wctx(fout.fileSize())==ERROR)
return ERROR;
return 0;
}
void setup() {
Serial.begin(115200);
while (!Serial.available()) SPARK_WLAN_Loop();
while (Serial.available()) Serial.read();
// initialize the SD card at SPI_FULL_SPEED for best performance.
// try SPI_HALF_SPEED if bus errors occur.
// Initialize HARDWARE SPI with user defined chipSelect
if (!card.init(SPI_FULL_SPEED, chipSelect)) error("card.init failed");
// Initialize SOFTWARE SPI
//if (!card.init(mosiPin, misoPin, clockPin, chipSelect)) error("card.init failed");
// initialize a FAT volume
if (!volume.init(&card)) error("volume.init failed!");
Serial.print("Type is FAT");
Serial.println(volume.fatType(), DEC);
if (!root.openRoot(&volume)) error("openRoot failed");
}
void printCardInfo() {
Serial.print(F("Data logging is "));
if (disableLogging) {
Serial.println(F("DISABLED"));
} else {
Serial.println(F("ENABLED"));
}
Serial.println();
Serial.print("\nCard type: ");
switch (card.type()) {
case SD_CARD_TYPE_SD1:
Serial.println("SD1");
break;
case SD_CARD_TYPE_SD2:
Serial.println("SD2");
break;
case SD_CARD_TYPE_SDHC:
Serial.println("SDHC");
break;
default:
Serial.println("Unknown");
}
Serial.print("\nVolume type is FAT");
Serial.println(volume.fatType(), DEC);
unsigned long volumesize;
volumesize = volume.blocksPerCluster();
volumesize *= volume.clusterCount();
volumesize /= 2;
volumesize /= 1024;
Serial.print("Volume size: ");
Serial.print(volumesize, DEC);
Serial.println("MB");
Serial.println("name\tdate\tsize");
root.ls(LS_R | LS_DATE | LS_SIZE);
Serial.println();
}
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.");
}
void setupLog() {
if (!card.init(SPI_HALF_SPEED, SD_CS)) {
Serial.println(F("No SD card inserted, disabling data logger."));
disableLogging = true;
}
if (!disableLogging && !volume.init(card)) {
Serial.println(F("Unable to initialize SD volume"));
disableLogging = true;
}
if (!disableLogging && !root.openRoot(volume)) {
Serial.println(F("Unable to open volume root"));
disableLogging = true;
}
#ifdef DEBUG
printCardInfo();
#endif
if (!disableLogging) {
openLog();
}
}
void SD_ListFiles(void)
{
Serial.begin(9600);
while (!Serial) {}
delay(1000);
Serial.println();
while (file.openNext(sdf.vwd(), O_READ)) {
file.printFileSize(&Serial);
Serial.write(' ');
file.printModifyDateTime(&Serial);
Serial.write(' ');
file.printName(&Serial);
if (file.isDir()) {
// Indicate a directory.
Serial.write('/');
}
Serial.println();
file.close();
}
}
void writeSettings() {
char wrtBuffer[80];
if (!settingsFile.open(&root, settingsFileName, O_WRITE|O_CREAT)) {
// bitch.... ();
return;
}
console.printf("DBG: Opened Settings File: %s\r\n",settingsFileName);
snprintf(wrtBuffer,80,"NPW!%s\n",networkPassword);
settingsFile.write(wrtBuffer,strlen(wrtBuffer));
snprintf(wrtBuffer,80,"NJN!%s\n",networkSSID);
settingsFile.write(wrtBuffer,strlen(wrtBuffer));
snprintf(wrtBuffer,80,"PKY!%s\n",pachubeKey);
settingsFile.write(wrtBuffer,strlen(wrtBuffer));
snprintf(wrtBuffer,80,"PFD!%s\n",pachubeFeed);
settingsFile.write(wrtBuffer,strlen(wrtBuffer));
settingsFile.close();
console.printf("DBG: Closing Settings File: %s\r\n",settingsFileName);
}
/*
* 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);
}
}
bool open(char* fileName) {
// Create LDxxxx.CSV for the lowest value of x.
#ifdef SDCARD
uint16_t i = 0;
do {
fileName[2] = (i/1000) % 10 + '0';
fileName[3] = (i/100) % 10 + '0';
fileName[4] = (i/10) % 10 + '0';
fileName[5] = i % 10 + '0';
i++;
}
while(sd.exists(fileName));
if(!file.open(fileName, O_CREAT | O_WRITE | O_EXCL)) {
// error_P("file open");
return false;
}
file.clearWriteError();
// write data header
file.print("time (s)");
#endif
Serial.print("v");
Serial.println(FIRMWARE_VERSION);
Serial.print("File: ");
Serial.println(fileName);
// write data header
Serial.print("time (s)");
/* We are no longer using the junction temperature in our data output.
// write data header
file.print("time (s), ambient");
Serial.print("time (s), ambient");
switch(temperatureUnit) {
case TEMPERATURE_UNITS_C:
file.print(" (C)");
Serial.print(" (C)");
break;
case TEMPERATURE_UNITS_F:
file.print(" (F)");
Serial.print(" (F)");
break;
case TEMPERATURE_UNITS_K:
file.print(" (K)");
Serial.print(" (K)");
break;
}*/
for (uint8_t i = 0; i < SENSOR_COUNT; i++) {
#ifdef SDCARD
file.print(", temp_");
file.print(i, DEC);
#endif
Serial.print(", temp_");
Serial.print(i, DEC);
switch(temperatureUnit) {
case TEMPERATURE_UNITS_C:
#ifdef SDCARD
file.print(" (C)");
#endif
Serial.print(" (C)");
break;
case TEMPERATURE_UNITS_F:
#ifdef SDCARD
file.print(" (F)");
#endif
Serial.print(" (F)");
break;
case TEMPERATURE_UNITS_K:
#ifdef SDCARD
file.print(" (K)");
#endif
Serial.print(" (K)");
break;
}
}
#ifdef SDCARD
file.println();
file.flush();
#endif
Serial.println();
#ifdef SDCARD
return (file.getWriteError() == false);
#else
return true;
#endif
}
void close() {
#ifdef SDCARD
file.close();
#endif
}
namespace sd {
#ifdef SDCARD
SdFat sd;
SdFile file;
#endif
uint32_t syncTime = 0; // time of last sync(), in millis()
//void error_P(const char* str) {
// Serial.print("error: ");
// Serial.print(str);
//
// // Stop the SD card
// close();
//}
void init() {
close();
#ifdef SDCARD
if (!sd.begin(SD_CS, SPI_FULL_SPEED)) {
// error_P("card.init");
return;
}
#endif
}
bool open(char* fileName) {
// Create LDxxxx.CSV for the lowest value of x.
#ifdef SDCARD
uint16_t i = 0;
do {
fileName[2] = (i/1000) % 10 + '0';
fileName[3] = (i/100) % 10 + '0';
fileName[4] = (i/10) % 10 + '0';
fileName[5] = i % 10 + '0';
i++;
}
while(sd.exists(fileName));
if(!file.open(fileName, O_CREAT | O_WRITE | O_EXCL)) {
// error_P("file open");
return false;
}
file.clearWriteError();
// write data header
file.print("time (s)");
#endif
Serial.print("v");
Serial.println(FIRMWARE_VERSION);
Serial.print("File: ");
Serial.println(fileName);
// write data header
Serial.print("time (s)");
/* We are no longer using the junction temperature in our data output.
// write data header
file.print("time (s), ambient");
Serial.print("time (s), ambient");
switch(temperatureUnit) {
case TEMPERATURE_UNITS_C:
file.print(" (C)");
Serial.print(" (C)");
break;
case TEMPERATURE_UNITS_F:
file.print(" (F)");
Serial.print(" (F)");
break;
case TEMPERATURE_UNITS_K:
file.print(" (K)");
Serial.print(" (K)");
break;
}*/
for (uint8_t i = 0; i < SENSOR_COUNT; i++) {
#ifdef SDCARD
file.print(", temp_");
file.print(i, DEC);
#endif
Serial.print(", temp_");
Serial.print(i, DEC);
switch(temperatureUnit) {
case TEMPERATURE_UNITS_C:
#ifdef SDCARD
file.print(" (C)");
#endif
Serial.print(" (C)");
break;
case TEMPERATURE_UNITS_F:
#ifdef SDCARD
file.print(" (F)");
#endif
Serial.print(" (F)");
break;
case TEMPERATURE_UNITS_K:
#ifdef SDCARD
file.print(" (K)");
#endif
Serial.print(" (K)");
break;
}
}
#ifdef SDCARD
file.println();
file.flush();
#endif
Serial.println();
#ifdef SDCARD
return (file.getWriteError() == false);
#else
return true;
#endif
}
void close() {
#ifdef SDCARD
file.close();
#endif
}
bool log(char* message) {
// TODO: Test if file is open first
// log time to file
#ifdef SDCARD
file.println(message);
#endif
sync(false);
#ifdef SDCARD
return (file.getWriteError() == false);
#else
return true;
#endif
}
void sync(boolean force) {
// TODO: Test if file is open first?
//don't sync too often - requires 2048 bytes of I/O to SD card
if (!force && (millis() - syncTime) < SYNC_INTERVAL) {
return;
}
syncTime = millis();
#ifdef SDCARD
file.flush();
#endif
}
} // namespace sd
void logData(char *data) {
int n;
n=file.write(data,strlen(data));
console.printf("DBG: Logging (%d)'%s'",n,data);
file.sync();
}
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 web::ProcessWebClients()
{
// listen for incoming clients
EthernetClient client = m_server->available();
if (client)
{
bool bReset = false;
#ifdef ARDUINO
FILE stream_file;
FILE * pFile = &stream_file;
setup_sendbuf();
fdev_setup_stream(pFile, stream_putchar, NULL, _FDEV_SETUP_WRITE);
stream_file.udata = &client;
#else
FILE * pFile = fdopen(client.GetSocket(), "w");
#endif
freeMemory();
trace(F("Got a client\n"));
//ShowSockStatus();
KVPairs key_value_pairs;
char sPage[35];
if (!ParseHTTPHeader(client, &key_value_pairs, sPage, sizeof(sPage)))
{
trace(F("ERROR!\n"));
ServeError(pFile);
}
else
{
trace(F("Page:%s\n"), sPage);
//ShowSockStatus();
if (strcmp(sPage, "bin/setSched") == 0)
{
if (SetSchedule(key_value_pairs))
{
if (GetRunSchedules())
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/setZones") == 0)
{
if (SetZones(key_value_pairs))
{
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/delSched") == 0)
{
if (DeleteSchedule(key_value_pairs))
{
if (GetRunSchedules())
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/setQSched") == 0)
{
if (SetQSched(key_value_pairs))
{
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/settings") == 0)
{
if (SetSettings(key_value_pairs))
{
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/manual") == 0)
{
if (ManualZone(key_value_pairs))
{
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/run") == 0)
{
if (RunSchedules(key_value_pairs))
{
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/factory") == 0)
{
ResetEEPROM();
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else if (strcmp(sPage, "bin/reset") == 0)
{
ServeHeader(pFile, 200, "OK", false);
bReset = true;
}
else if (strcmp(sPage, "json/schedules") == 0)
{
JSONSchedules(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/zones") == 0)
{
JSONZones(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/settings") == 0)
{
JSONSettings(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/state") == 0)
{
JSONState(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/schedule") == 0)
{
JSONSchedule(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/wcheck") == 0)
{
JSONwCheck(key_value_pairs, pFile);
}
#ifdef LOGGING
else if (strcmp(sPage, "json/logs") == 0)
{
JSONLogs(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/tlogs") == 0)
{
JSONtLogs(key_value_pairs, pFile);
}
#endif
else if (strcmp(sPage, "ShowSched") == 0)
{
freeMemory();
ServeSchedPage(pFile);
}
else if (strcmp(sPage, "ShowZones") == 0)
{
freeMemory();
ServeZonesPage(pFile);
}
else if (strcmp(sPage, "ShowEvent") == 0)
{
ServeEventPage(pFile);
}
else if (strcmp(sPage, "ReloadEvent") == 0)
{
ReloadEvents(true);
ServeEventPage(pFile);
}
else
{
if (strlen(sPage) == 0)
strcpy(sPage, "index.htm");
// prepend path
memmove(sPage + 5, sPage, sizeof(sPage) - 5);
memcpy(sPage, "/web/", 5);
sPage[sizeof(sPage)-1] = 0;
trace(F("Serving Page: %s\n"), sPage);
SdFile theFile;
if (!theFile.open(sPage, O_READ))
Serve404(pFile);
else
{
if (theFile.isFile())
ServeFile(pFile, sPage, theFile, client);
else
Serve404(pFile);
theFile.close();
}
}
}
#ifdef ARDUINO
flush_sendbuf(client);
// give the web browser time to receive the data
delay(1);
#else
fflush(pFile);
fclose(pFile);
#endif
// close the connection:
client.stop();
if (bReset)
sysreset();
}
}
void handleConsoleInput() {
uint8_t retval;
uint8_t index=0;
uint8_t ch='0';
SdFile finger;
switch (console.keyValue()) {
case _DIR_:
console.printf("SOD:\r\n");
root.ls(LS_DATE | LS_SIZE);
console.printf("EOD:\r\n");
break;
case _LSV_:
console.printf("LSV:" BOM_VERSION "\r\n");
break;
case _TYP_:
typeFile(console.arguments());
break;
case _NSC_:
console.printf("SOD:\r\n");
retval=networkScan();
console.printf("EOD:\r\n");
console.printf("\nDBG: found=%d\r\n",retval);
break;
case _NJN_:
//console.printf("SOD:\r\n");
retval=networkJoin(console.arguments());
//console.printf("EOD:\r\n");
console.printf("\nDBG: joined=%s\r\n",retval?"TRUE":"FALSE");
break;
case _NPW_:
//console.printf("SOD:\r\n");
retval=networkSetPassword(console.arguments());
//console.printf("EOD:\r\n");
console.printf("\nDBG: pwd set=%s\r\n",retval?"TRUE":"FALSE");
break;
case _NST_:
retval=networkStatus();
console.printf("NST: %s\r\n",retval?"CONNECTED":"NOT CONNECTED");
break;
case _FMT_: // there really should be some REALLY do you mean this here but.....
root.openRoot(&volume);
if (finger.open(&root, ".", O_WRITE|O_READ)) {
console.printf("\nDBG: Opened / \r\n");
finger.rmRfStar();
} else {
console.printf("\nDBG: FAIL \r\n");
}
break;
case _TPT_:
toPachube(1, console.arguments());
break;
case _TX2_:
radio.printf("%s",console.arguments());
index=0;
// delay(1000);
while (radio.available()) {
inBuffer[index++]=ch=radio.read();
if( index>= 99 || ((ch== '\n') || ch !='\r')) {
inBuffer[index]='\0';
console.puts(inBuffer);
index=0;
delay(100);
}
}
inBuffer[index]='\0';
console.puts(inBuffer);
console.puts((char *) "\r\n");
break;
// set to one to test output for.
#if 1
case _TS1_: toPachube(0, console.arguments()); break;
case _TS2_: toPachube(1, console.arguments()); break;
case _TS3_: toPachube(2, console.arguments()); break;
case _TS4_: toPachube(3, console.arguments()); break;
case _TS5_: toPachube(4, console.arguments()); break;
case _FAN_: toPachube(5, console.arguments()); break;
case _CHL_: toPachube(6, console.arguments()); break;
case _STC_: toPachube(7, console.arguments()); break;
#endif
case _PKY_:
strncpy(pachubeKey, console.arguments(), MAX_PATCHUBE_KEY_LENGHT-1);
stripcrlf(pachubeKey);
break;
case _PFD_:
strncpy(pachubeFeed, console.arguments(), MAX_PATCHUBE_FEED_LENGHT-1);
stripcrlf(pachubeFeed);
break;
case _SGT_ :
readSettings();
break;
case _SSV_ :
writeSettings();
break;
default:
console.printf("DBG: forwarding (%s) to device\r\n",console.key());
device.puts(console.line());
//device.puts("\r\n");
break;
}
}
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 writeLog() {
if (disableLogging) {
return;
}
if (!dataFile.isOpen()) {
if (!dataFile.open(root, logFilename, O_WRITE | O_APPEND)) {
#ifdef DEBUG
Serial.println(F("Could not open file for writing"));
#endif
disableLogging = true;
return;
}
}
// Local sensor readings
logFileSize += dataFile.print(lastUpdate);
logFileSize += dataFile.print(F("\t"));
logFileSize += dataFile.print(sinceLastAck);
logFileSize += dataFile.print(F("\t"));
logFileSize += dataFile.print(lastVcc);
logFileSize += dataFile.print(F("\t"));
if (validReadingi(lastRoundtrip)) {
logFileSize += dataFile.print(lastRoundtrip);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingi(lastRssi)) {
logFileSize += dataFile.print(lastRssi);
}
logFileSize += dataFile.print(F("\t"));
// Remote sensor readings
if (validReadingi(m.vcc)) {
logFileSize += dataFile.print(m.vcc);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingi(m.rssi)) {
logFileSize += dataFile.print(m.rssi);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingi(m.vibration)) {
logFileSize += dataFile.print(m.vibration);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.altitudeGps)) {
logFileSize += dataFile.print(m.altitudeGps);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.altitude)) {
logFileSize += dataFile.print(m.altitude);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.temp)) {
logFileSize += dataFile.print(m.temp);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.temp2)) {
logFileSize += dataFile.print(m.temp2);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.latitude)) {
logFileSize += dataFile.print(m.latitude, 6);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.longitude)) {
logFileSize += dataFile.print(m.longitude, 6);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.accelX)) {
logFileSize += dataFile.print(m.accelX);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.accelY)) {
logFileSize += dataFile.print(m.accelY);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.accelZ)) {
logFileSize += dataFile.print(m.accelZ);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.magX)) {
logFileSize += dataFile.print(m.magX);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.magY)) {
logFileSize += dataFile.print(m.magY);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.magZ)) {
logFileSize += dataFile.print(m.magZ);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.gyroX)) {
logFileSize += dataFile.print(m.gyroX);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.gyroY)) {
logFileSize += dataFile.print(m.gyroY);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.gyroZ)) {
logFileSize += dataFile.print(m.gyroZ);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.accel2X)) {
logFileSize += dataFile.print(m.accel2X);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.accel2Y)) {
logFileSize += dataFile.print(m.accel2Y);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.accel2Z)) {
logFileSize += dataFile.print(m.accel2Z);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.mag2X)) {
logFileSize += dataFile.print(m.mag2X);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.mag2Y)) {
logFileSize += dataFile.print(m.mag2Y);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.mag2Z)) {
logFileSize += dataFile.print(m.mag2Z);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.gyro2X)) {
logFileSize += dataFile.print(m.gyro2X);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.gyro2Y)) {
logFileSize += dataFile.print(m.gyro2Y);
}
logFileSize += dataFile.print(F("\t"));
if (validReadingf(m.gyro2Z)) {
logFileSize += dataFile.print(m.gyro2Z);
}
logFileSize += dataFile.println(F("\t"));
dataFile.sync();
if (logFileSize >= logFileMax) {
dataFile.close();
rotateLog();
openLog();
}
}
void LogTemps(){
if (!file.open(root, filename, O_CREAT | O_APPEND | O_WRITE)) {
//error(“open”);
}
// write values to the file
sensorsa.requestTemperatures();
sensorsb.requestTemperatures();
sensorsc.requestTemperatures();
sensorsd.requestTemperatures();
file.print(now() );
file.print("|");
file.print(sensorsa.getTempCByIndex(0));
file.print("|");
file.print(sensorsb.getTempCByIndex(0));
file.print("|");
file.print(sensorsc.getTempCByIndex(0));
file.print("|");
file.print(sensorsd.getTempCByIndex(0));
file.print("\n");
if (!file.close() || file.writeError){
// error(“close/write”);
}
}
void CardReader::openFile(char* name, bool read, bool replace_current/*=true*/, bool lcd_status/*=true*/) {
if (!cardOK) return;
if (file.isOpen()) { //replacing current file by new file, or subfile call
if (!replace_current) {
if (file_subcall_ctr > SD_PROCEDURE_DEPTH - 1) {
ECHO_LMV(ER, MSG_SD_MAX_DEPTH, SD_PROCEDURE_DEPTH);
kill(PSTR(MSG_KILLED));
return;
}
ECHO_SMV(DB, "SUBROUTINE CALL target:\"", name);
ECHO_M("\" parent:\"");
//store current filename and position
getAbsFilename(filenames[file_subcall_ctr]);
ECHO_V(filenames[file_subcall_ctr]);
ECHO_EMV("\" pos", sdpos);
filespos[file_subcall_ctr] = sdpos;
file_subcall_ctr++;
}
else {
ECHO_LMV(DB, "Now doing file: ", name);
}
file.close();
}
else { // opening fresh file
file_subcall_ctr = 0; // resetting procedure depth in case user cancels print while in procedure
ECHO_LMV(DB, "Now fresh file: ", name);
}
sdprinting = false;
SdFile myDir;
curDir = &root;
char *fname = name;
char *dirname_start, *dirname_end;
if (name[0] == '/') {
dirname_start = &name[1];
while (dirname_start > 0) {
dirname_end = strchr(dirname_start, '/');
if (dirname_end > 0 && dirname_end > dirname_start) {
char subdirname[FILENAME_LENGTH];
strncpy(subdirname, dirname_start, dirname_end - dirname_start);
subdirname[dirname_end - dirname_start] = 0;
ECHO_EV(subdirname);
if (!myDir.open(curDir, subdirname, O_READ)) {
ECHO_MV(MSG_SD_OPEN_FILE_FAIL, subdirname);
ECHO_C('.');
return;
}
else {
//ECHO_EM("dive ok");
}
curDir = &myDir;
dirname_start = dirname_end + 1;
}
else { // the remainder after all /fsa/fdsa/ is the filename
fname = dirname_start;
//ECHO_EM("remainder");
//ECHO_EV(fname);
break;
}
}
}
else { //relative path
curDir = &workDir;
}
if (read) {
if (file.open(curDir, fname, O_READ)) {
filesize = file.fileSize();
ECHO_MV(MSG_SD_FILE_OPENED, fname);
ECHO_EMV(MSG_SD_SIZE, filesize);
sdpos = 0;
ECHO_EM(MSG_SD_FILE_SELECTED);
getfilename(0, fname);
if(lcd_status) lcd_setstatus(longFilename[0] ? longFilename : fname);
}
else {
ECHO_MV(MSG_SD_OPEN_FILE_FAIL, fname);
ECHO_PGM(".\n");
}
}
else { //write
if (!file.open(curDir, fname, O_CREAT | O_APPEND | O_WRITE | O_TRUNC)) {
ECHO_MV(MSG_SD_OPEN_FILE_FAIL, fname);
ECHO_PGM(".\n");
}
else {
saving = true;
ECHO_EMV(MSG_SD_WRITE_TO_FILE, name);
if(lcd_status) lcd_setstatus(fname);
}
}
}
/**
* Dive into a folder and recurse depth-first to perform a pre-set operation lsAction:
* LS_Count - Add +1 to nrFiles for every file within the parent
* LS_GetFilename - Get the filename of the file indexed by nrFiles
* LS_SerialPrint - Print the full path of each file to serial output
*/
void CardReader::lsDive(const char *prepend, SdFile parent, const char * const match/*=NULL*/) {
dir_t p;
uint8_t cnt = 0;
// Read the next entry from a directory
while (parent.readDir(p, longFilename) > 0) {
// If the entry is a directory and the action is LS_SerialPrint
if (DIR_IS_SUBDIR(&p) && lsAction != LS_Count && lsAction != LS_GetFilename) {
// Get the short name for the item, which we know is a folder
char lfilename[FILENAME_LENGTH];
createFilename(lfilename, p);
// Allocate enough stack space for the full path to a folder, trailing slash, and nul
boolean prepend_is_empty = (prepend[0] == '\0');
int len = (prepend_is_empty ? 1 : strlen(prepend)) + strlen(lfilename) + 1 + 1;
char path[len];
// Append the FOLDERNAME12/ to the passed string.
// It contains the full path to the "parent" argument.
// We now have the full path to the item in this folder.
strcpy(path, prepend_is_empty ? "/" : prepend); // root slash if prepend is empty
strcat(path, lfilename); // FILENAME_LENGTH-1 characters maximum
strcat(path, "/"); // 1 character
// Serial.print(path);
// Get a new directory object using the full path
// and dive recursively into it.
SdFile dir;
if (!dir.open(parent, lfilename, O_READ)) {
if (lsAction == LS_SerialPrint) {
ECHO_LMV(ER, MSG_SD_CANT_OPEN_SUBDIR, lfilename);
}
}
lsDive(path, dir);
// close() is done automatically by destructor of SdFile
}
else {
char pn0 = p.name[0];
if (pn0 == DIR_NAME_FREE) break;
if (pn0 == DIR_NAME_DELETED || pn0 == '.') continue;
if (longFilename[0] == '.') continue;
if (!DIR_IS_FILE_OR_SUBDIR(&p)) continue;
filenameIsDir = DIR_IS_SUBDIR(&p);
if (!filenameIsDir && (p.name[8] != 'G' || p.name[9] == '~')) continue;
switch (lsAction) {
case LS_Count:
nrFiles++;
break;
case LS_SerialPrint:
createFilename(filename, p);
ECHO_V(prepend);
ECHO_EV(filename);
break;
case LS_GetFilename:
createFilename(filename, p);
if (match != NULL) {
if (strcasecmp(match, filename) == 0) return;
}
else if (cnt == nrFiles) return;
cnt++;
break;
}
}
} // while readDir
}
void setup()
{
bool loginit(false);
bool sdinit(false);
bool dbinit(false);
uint8_t tlpins[] = { INNER_LIGHTS_PINS, OUTER_LIGHTS_PINS };
Serial.begin( BAUDRATE );
#ifdef VERBOSE
delay(10);
Serial.print(CMNT);
for( char c = 0; c < 79; ++c ) Serial.print('>');
Serial.println();
#endif
I2c.begin();
I2c.timeOut(1000);
g_display.init(); // calls Wire.begin()
g_display.print( freeMemory() );
g_loop.init( PIN_INNERLOOP, PIN_OUTERLOOP, LOOP_ACTIVE );
setup433();
g_codeready = false;
g_code = 0;
#ifdef USE_IOEXTENDER_OUTPUTS
g_outputs.set(0xff);
#else
{
uint8_t all_output_pins[8] = { ALL_RAW_OUTPUT_PINS };
g_outputs.init(all_output_pins, RELAY_OFF);
}
#endif
if((sdinit = g_sd.begin( SS, SPI_HALF_SPEED ))) {
if( !(loginit = g_logger.init()) )
Serial.println(F("Logger fail"));
} else
Serial.println(F("SD fail"));
dbinit = g_db.init();
g_display.print( ' ' );
g_display.print( sdinit );
g_display.print( ' ' );
g_display.print( loginit );
g_display.print( ' ' );
g_display.print( dbinit );
//runlight
for( uint8_t pin = 0; pin < sizeof(tlpins) + 3; ++pin ) {
if(pin < sizeof(tlpins)) {
g_outputs.set( tlpins[pin], RELAY_ON);
}
if(pin > 2)
g_outputs.set(tlpins[pin-3], RELAY_OFF);
delay(150);
}
if( !loginit )
{
delay(100);
for( int i = 0; i < 3; ++i ) {
g_outputs.set( PIN_IN_RED, RELAY_ON );
g_outputs.set( PIN_OUT_RED, RELAY_ON );
delay( 500 );
g_outputs.set( PIN_IN_RED, RELAY_OFF );
g_outputs.set( PIN_OUT_RED, RELAY_OFF );
delay( 500 );
}
}
g_clk.init( DS3231_INTCN );
g_timevalid = updatedt();
#ifdef VERBOSE
Serial.print(CMNT);
Serial.println(F("DS3231 init done."));
#endif
g_logger.log( logwriter::INFO, g_time, F("Reset") );
g_display.clear();
if(sdinit)
{
SdFile f;
if(f.open("IMPORT"))
{
f.close();
g_display.print(F("IMPORTING "));
uint16_t imported(importdb(0, 1023));
if(imported != (uint16_t) -1) {
g_display.print(imported);
g_sd.remove("IMPORT");
} else
g_display.print(F("FAIL"));
delay(2000);
g_display.clear();
}
}
#ifdef VERBOSE
Serial.print(CMNT);
for( char c = 0; c < 79; ++c ) Serial.print('<');
Serial.println();
#endif
}
void CardReader::openFile(char* name, bool read, bool replace_current/*=true*/) {
if (!cardOK) return;
if (file.isOpen()) { //replacing current file by new file, or subfile call
if (!replace_current) {
if (file_subcall_ctr > SD_PROCEDURE_DEPTH - 1) {
SERIAL_ERROR_START;
SERIAL_ERRORPGM("trying to call sub-gcode files with too many levels. MAX level is:");
SERIAL_ERRORLN(SD_PROCEDURE_DEPTH);
kill();
return;
}
SERIAL_ECHO_START;
SERIAL_ECHOPGM("SUBROUTINE CALL target:\"");
SERIAL_ECHO(name);
SERIAL_ECHOPGM("\" parent:\"");
//store current filename and position
getAbsFilename(filenames[file_subcall_ctr]);
SERIAL_ECHO(filenames[file_subcall_ctr]);
SERIAL_ECHOPGM("\" pos");
SERIAL_ECHOLN(sdpos);
filespos[file_subcall_ctr] = sdpos;
file_subcall_ctr++;
}
else {
SERIAL_ECHO_START;
SERIAL_ECHOPGM("Now doing file: ");
SERIAL_ECHOLN(name);
}
file.close();
}
else { //opening fresh file
file_subcall_ctr = 0; //resetting procedure depth in case user cancels print while in procedure
SERIAL_ECHO_START;
SERIAL_ECHOPGM("Now fresh file: ");
SERIAL_ECHOLN(name);
}
sdprinting = false;
SdFile myDir;
curDir = &root;
char *fname = name;
char *dirname_start, *dirname_end;
if (name[0] == '/') {
dirname_start = &name[1];
while(dirname_start > 0) {
dirname_end = strchr(dirname_start, '/');
//SERIAL_ECHO("start:");SERIAL_ECHOLN((int)(dirname_start - name));
//SERIAL_ECHO("end :");SERIAL_ECHOLN((int)(dirname_end - name));
if (dirname_end > 0 && dirname_end > dirname_start) {
char subdirname[FILENAME_LENGTH];
strncpy(subdirname, dirname_start, dirname_end - dirname_start);
subdirname[dirname_end - dirname_start] = 0;
SERIAL_ECHOLN(subdirname);
if (!myDir.open(curDir, subdirname, O_READ)) {
SERIAL_PROTOCOLPGM(MSG_SD_OPEN_FILE_FAIL);
SERIAL_PROTOCOL(subdirname);
SERIAL_PROTOCOLCHAR('.');
return;
}
else {
//SERIAL_ECHOLN("dive ok");
}
curDir = &myDir;
dirname_start = dirname_end + 1;
}
else { // the remainder after all /fsa/fdsa/ is the filename
fname = dirname_start;
//SERIAL_ECHOLN("remainder");
//SERIAL_ECHOLN(fname);
break;
}
}
}
else { //relative path
curDir = &workDir;
}
if (read) {
if (file.open(curDir, fname, O_READ)) {
filesize = file.fileSize();
SERIAL_PROTOCOLPGM(MSG_SD_FILE_OPENED);
SERIAL_PROTOCOL(fname);
SERIAL_PROTOCOLPGM(MSG_SD_SIZE);
SERIAL_PROTOCOLLN(filesize);
sdpos = 0;
SERIAL_PROTOCOLLNPGM(MSG_SD_FILE_SELECTED);
getfilename(0, fname);
lcd_setstatus(longFilename[0] ? longFilename : fname);
}
else {
SERIAL_PROTOCOLPGM(MSG_SD_OPEN_FILE_FAIL);
SERIAL_PROTOCOL(fname);
SERIAL_PROTOCOLCHAR('.');
}
}
else { //write
if (!file.open(curDir, fname, O_CREAT | O_APPEND | O_WRITE | O_TRUNC)) {
SERIAL_PROTOCOLPGM(MSG_SD_OPEN_FILE_FAIL);
SERIAL_PROTOCOL(fname);
SERIAL_PROTOCOLCHAR('.');
}
else {
saving = true;
SERIAL_PROTOCOLPGM(MSG_SD_WRITE_TO_FILE);
SERIAL_PROTOCOLLN(name);
lcd_setstatus(fname);
}
}
}
void CardReader::openFile(char* name,bool read)
{
if(!cardOK)
return;
file.close();
sdprinting = false;
SdFile myDir;
curDir=&root;
char *fname=name;
char *dirname_start,*dirname_end;
if(name[0]=='/')
{
dirname_start=strchr(name,'/')+1;
while(dirname_start>0)
{
dirname_end=strchr(dirname_start,'/');
//SERIAL_ECHO("start:");SERIAL_ECHOLN((int)(dirname_start-name));
//SERIAL_ECHO("end :");SERIAL_ECHOLN((int)(dirname_end-name));
if(dirname_end>0 && dirname_end>dirname_start)
{
char subdirname[13];
strncpy(subdirname, dirname_start, dirname_end-dirname_start);
subdirname[dirname_end-dirname_start]=0;
SERIAL_ECHOLN(subdirname);
if(!myDir.open(curDir,subdirname,O_READ))
{
SERIAL_PROTOCOLPGM(MSG_SD_OPEN_FILE_FAIL);
SERIAL_PROTOCOL(subdirname);
SERIAL_PROTOCOLLNPGM(".");
return;
}
else
{
//SERIAL_ECHOLN("dive ok");
}
curDir=&myDir;
dirname_start=dirname_end+1;
}
else // the reminder after all /fsa/fdsa/ is the filename
{
fname=dirname_start;
//SERIAL_ECHOLN("remaider");
//SERIAL_ECHOLN(fname);
break;
}
}
}
else //relative path
{
curDir=&workDir;
}
if(read)
{
if (file.open(curDir, fname, O_READ))
{
filesize = file.fileSize();
SERIAL_PROTOCOLPGM(MSG_SD_FILE_OPENED);
SERIAL_PROTOCOL(fname);
SERIAL_PROTOCOLPGM(MSG_SD_SIZE);
SERIAL_PROTOCOLLN(filesize);
sdpos = 0;
SERIAL_PROTOCOLLNPGM(MSG_SD_FILE_SELECTED);
LCD_MESSAGE(fname);
}
else
{
SERIAL_PROTOCOLPGM(MSG_SD_OPEN_FILE_FAIL);
SERIAL_PROTOCOL(fname);
SERIAL_PROTOCOLLNPGM(".");
}
}
else
{ //write
if (!file.open(curDir, fname, O_CREAT | O_APPEND | O_WRITE | O_TRUNC))
{
SERIAL_PROTOCOLPGM(MSG_SD_OPEN_FILE_FAIL);
SERIAL_PROTOCOL(fname);
SERIAL_PROTOCOLLNPGM(".");
}
else
{
saving = true;
SERIAL_PROTOCOLPGM(MSG_SD_WRITE_TO_FILE);
SERIAL_PROTOCOLLN(name);
LCD_MESSAGE(fname);
}
}
}
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();
}
void CardReader::lsDive(const char *prepend,SdFile parent)
{
dir_t p;
uint8_t cnt=0;
while (parent.readDir(p, longFilename) > 0)
{
if( DIR_IS_SUBDIR(&p) && lsAction!=LS_Count && lsAction!=LS_GetFilename) // hence LS_SerialPrint
{
char path[13*2];
char lfilename[13];
createFilename(lfilename,p);
path[0]=0;
if(strlen(prepend)==0) //avoid leading / if already in prepend
{
strcat(path,"/");
}
strcat(path,prepend);
strcat(path,lfilename);
strcat(path,"/");
//Serial.print(path);
SdFile dir;
if(!dir.open(parent,lfilename, O_READ))
{
if(lsAction==LS_SerialPrint)
{
SERIAL_ECHO_START;
SERIAL_ECHOLN(MSG_SD_CANT_OPEN_SUBDIR);
SERIAL_ECHOLN(lfilename);
}
}
lsDive(path,dir);
//close done automatically by destructor of SdFile
}
else
{
if (p.name[0] == DIR_NAME_FREE) break;
if (p.name[0] == DIR_NAME_DELETED || p.name[0] == '.'|| p.name[0] == '_') continue;
if ( p.name[0] == '.')
{
if ( p.name[1] != '.')
continue;
}
if (!DIR_IS_FILE_OR_SUBDIR(&p)) continue;
filenameIsDir=DIR_IS_SUBDIR(&p);
if(!filenameIsDir)
{
if(p.name[8]!='G') continue;
if(p.name[9]=='~') continue;
}
//if(cnt++!=nr) continue;
createFilename(filename,p);
if(lsAction==LS_SerialPrint)
{
SERIAL_PROTOCOL(prepend);
SERIAL_PROTOCOLLN(filename);
}
else if(lsAction==LS_Count)
{
nrFiles++;
}
else if(lsAction==LS_GetFilename)
{
if(cnt==nrFiles)
return;
cnt++;
}
}
}
}
void CardReader::removeFile(char* name)
{
if(!cardOK)
return;
file.close();
sdprinting = false;
SdFile myDir;
curDir=&root;
char *fname=name;
char *dirname_start,*dirname_end;
if(name[0]=='/')
{
dirname_start=strchr(name,'/')+1;
while(dirname_start>0)
{
dirname_end=strchr(dirname_start,'/');
//SERIAL_ECHO("start:");SERIAL_ECHOLN((int)(dirname_start-name));
//SERIAL_ECHO("end :");SERIAL_ECHOLN((int)(dirname_end-name));
if(dirname_end>0 && dirname_end>dirname_start)
{
char subdirname[13];
strncpy(subdirname, dirname_start, dirname_end-dirname_start);
subdirname[dirname_end-dirname_start]=0;
SERIAL_ECHOLN(subdirname);
if(!myDir.open(curDir,subdirname,O_READ))
{
SERIAL_PROTOCOLPGM("open failed, File: ");
SERIAL_PROTOCOL(subdirname);
SERIAL_PROTOCOLLNPGM(".");
return;
}
else
{
//SERIAL_ECHOLN("dive ok");
}
curDir=&myDir;
dirname_start=dirname_end+1;
}
else // the reminder after all /fsa/fdsa/ is the filename
{
fname=dirname_start;
//SERIAL_ECHOLN("remaider");
//SERIAL_ECHOLN(fname);
break;
}
}
}
else //relative path
{
curDir=&workDir;
}
if (file.remove(curDir, fname))
{
SERIAL_PROTOCOLPGM("File deleted:");
SERIAL_PROTOCOL(fname);
sdpos = 0;
}
else
{
SERIAL_PROTOCOLPGM("Deletion failed, File: ");
SERIAL_PROTOCOL(fname);
SERIAL_PROTOCOLLNPGM(".");
}
}
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;
}
}
File SDClass::open(const char *filepath, uint8_t mode) {
/*
Open the supplied file path for reading or writing.
The file content can be accessed via the `file` property of
the `SDClass` object--this property is currently
a standard `SdFile` object from `sdfatlib`.
Defaults to read only.
If `write` is true, default action (when `append` is true) is to
append data to the end of the file.
If `append` is false then the file will be truncated first.
If the file does not exist and it is opened for writing the file
will be created.
An attempt to open a file for reading that does not exist is an
error.
*/
int pathidx;
// do the interative search
SdFile parentdir = getParentDir(filepath, &pathidx);
// no more subdirs!
filepath += pathidx;
if (! filepath[0]) {
// it was the directory itself!
return File(parentdir, "/");
}
// Open the file itself
SdFile file;
// failed to open a subdir!
if (!parentdir.isOpen())
return File();
// there is a special case for the Root directory since its a static dir
if (parentdir.isRoot()) {
if ( ! file.open(SD.root, filepath, mode)) {
// failed to open the file :(
return File();
}
// dont close the root!
} else {
if ( ! file.open(parentdir, filepath, mode)) {
return File();
}
// close the parent
parentdir.close();
}
if (mode & (O_APPEND | O_WRITE))
file.seekSet(file.fileSize());
return File(file, filepath);
}
void setup()
{
Serial.begin(BPS_115200);
PgmPrintln("Type any character to start");
while (!Serial.available());
Serial.print("\nInitializing SD card...");
// On the Ethernet Shield, CS is pin 4. It's set as an output by default.
// Note that even if it's not used as the CS pin, the hardware SS pin
// (10 on most Arduino boards, 53 on the Mega) must be left as an output
// or the SD library functions will not work.
//pinMode(10, OUTPUT); // change this to 53 on a mega
// we'll use the initialization code from the utility libraries
// since we're just testing if the card is working!
if (!card.init(SPI_HALF_SPEED, chipSelect)) {
Serial.println("initialization failed. Things to check:");
Serial.println("* is a card is inserted?");
Serial.println("* Is your wiring correct?");
Serial.println("* did you change the chipSelect pin to match your shield or module?");
return;
} else {
Serial.println("Wiring is correct and a card is present.");
}
// print the type of card
Serial.print("\nCard type: ");
switch(card.type()) {
case SD_CARD_TYPE_SD1:
Serial.println("SD1");
break;
case SD_CARD_TYPE_SD2:
Serial.println("SD2");
break;
case SD_CARD_TYPE_SDHC:
Serial.println("SDHC");
break;
default:
Serial.println("Unknown");
}
// Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32
if (!volume.init(card)) {
Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");
return;
}
// print the type and size of the first FAT-type volume
uint32_t volumesize;
Serial.print("\nVolume type is FAT");
Serial.println(volume.fatType(), DEC);
Serial.println();
volumesize = volume.blocksPerCluster(); // clusters are collections of blocks
volumesize *= volume.clusterCount(); // we'll have a lot of clusters
volumesize *= 512; // SD card blocks are always 512 bytes
Serial.print("Volume size (bytes): ");
Serial.println(volumesize);
Serial.print("Volume size (Kbytes): ");
volumesize /= 1024;
Serial.println(volumesize);
Serial.print("Volume size (Mbytes): ");
volumesize /= 1024;
Serial.println(volumesize);
Serial.println("\nFiles found on the card (name, date and size in bytes): ");
root.openRoot(volume);
// list all files in the card with date and size
root.ls(LS_R | LS_DATE | LS_SIZE);
}
