void loop() { if (Serial.available()) if (mySerial.available()) mySerial.println(Serial.read()); Serial.write(mySerial.read()); }
void loop() { sendMsg = ""; recvMsg = ""; while (Serial.available()) { sendMsg += (char)Serial.read(); delay(2); } if(sendMsg.length() > 0) { mySerial1.println(sendMsg); Serial.print("I send: "); Serial.println(sendMsg); } while (mySerial2.available()) { recvMsg += (char)mySerial2.read(); delay(2); } if(recvMsg.length() > 0) { Serial.print("I recv: "); Serial.println(recvMsg); } //delay(20); }
void loop() // run over and over { if (mySerial.available()) Serial.write(mySerial.read()); if (Serial.available()) mySerial.write(Serial.read()); }
boolean readRFID() { //if (RFID.available()) RFID.flush(); digitalWrite(RFID_ENABLE, LOW); // Activate the RFID reader for (byte i = 0; i < RFID_LENGTH; i++) rfidCode[i] = 0; if (RFID.available()) { int val = RFID.read(); Serial.print(val); if (val == RFID_START_CHAR) { RFID.readBytes(rfidCode, RFID_LENGTH); Serial.print("RFID Read: "); Serial.println(rfidCode); digitalWrite(RFID_ENABLE, HIGH); // deactivate the RFID reader for a moment so it will not flood RFID.flush(); // clear the buffer delay(1500); // wait for a bit return true; } } return false; }
void loop() // run over and over { int i = 0; bool found = false; raw_packet com; while(usb.available()){ found = true; if(i < 8){ com.raw[i] = usb.read(); } else{ break; } i++; } if(!found){ return; } packet curpacket = com.nice; if(curpacket.cmd = 1){ usb.print("hi"); usb.print("\n"); } }
void toSerial() { while(gprsSerial.available()!=0) { Serial.write(gprsSerial.read()); } }
/* This function sets the name of an RN-42 module name should be an up to 20-character value. It MUST BE TERMINATED by a \r character */ uint8_t makeyMateClass::setName(char * name) { if (bluetooth.available()) bluetooth.flush(); // Get rid of any characters in the buffer, we'll need to check it fresh bluetooth.print("SN,"); for (int i=0; i<20; i++) { if (name[i] != '\r') bluetooth.write(name[i]); else break; } bluetooth.write('\r'); delay(BLUETOOTH_RESPONSE_DELAY); bluetoothReceive(rxBuffer); /* Double check the setting, output results in Serial monitor */ bluetooth.flush(); bluetooth.print("GN"); bluetooth.write('\r'); delay(BLUETOOTH_RESPONSE_DELAY); Serial.print("Name set to: "); while (bluetooth.available()) Serial.write(bluetooth.read()); return bluetoothCheckReceive(rxBuffer, "AOK", 3); }
String sendData(String command, const int timeout, boolean debug) { String response = ""; esp8266.print(command); // send the read character to the esp8266 long int time = millis(); while( (time+timeout) > millis()) { while(esp8266.available()) { // The esp has data so display its output to the serial window char c = esp8266.read(); // read the next character. response+=c; } } if(debug) { Serial.print(response); } return response; }
/* sendPacket() is called by just about every other member function. It calculates some CRC bytes, then sends the message string. If a response is requested, it'll return that in the response array. Otherwise that and the responseLength variable should be 0. If you're using a bluetooth module that's not the RN-42, this'd be the place to modify. */ void SFE_MetaWatch::sendPacket(unsigned char * data, int length, unsigned char * response, int responseLength) { int crc = ComputeCRC(data, length - 2); // Get the crc values for our string data[length-1] = (crc & 0xFF00) >> 8; // LSB goes first data[length-2] = crc & 0xFF; // the MSB // If you want a response, let's flush out the bt buffer first. if (responseLength > 0) bt.flush(); // Send the data out to the BlueSMiRF for (int i=0; i<length; i++) { bt.write(data[i]); } // If a response was requested, read that into the response array. if (responseLength > 0) { delay(BLUETOOTH_RESPONSE_DELAY); int i=0; while (bt.available() && (i < responseLength)) { response[i++] = bt.read(); } } }
void ncArduinoPollGetData() { int c; while (mySerial.available() > 0) { c = mySerial.read(); byteStreamToPackageStream((unsigned char) c); } }
void setupBlueToothConnection() { blueToothSerial.begin(38400); blueToothSerial.print("\r\n+STWMOD=1\r\n"); blueToothSerial.print("\r\n+STNA=SeeedBTMaster\r\n"); blueToothSerial.print("\r\n+STAUTO=0\r\n"); delay(2000); blueToothSerial.flush(); blueToothSerial.print("\r\n+INQ=1\r\n"); Serial.println("inquiring"); delay(2000); char recvChar; /* while(1){ //this part is for auto detecting and connecting to a slave but something is wrong with the parsing of the address, use this to print out the address and then put it in manulely below if(blueToothSerial.available()){ recvChar = blueToothSerial.read(); recvBuf += recvChar; nameIndex = recvBuf.indexOf(slaveName); if ( nameIndex != -1 ){ addrIndex = (recvBuf.indexOf(retSymb,(nameIndex - retSymb.length()- 18) ) + retSymb.length()); slaveAddr = recvBuf.substring(addrIndex, nameIndex); break; } } }*/ connectCmd += slaveAddr; connectCmd += "\r\n"; int connectOK = 0; Serial.print("Connecting to slave:"); Serial.print(slaveAddr); Serial.println(slaveName); do{ blueToothSerial.print("/*put slave address here*/"); recvBuf = ""; while(1){ if(blueToothSerial.available()){ recvChar = blueToothSerial.read(); recvBuf += recvChar; if(recvBuf.indexOf("CONNECT:OK") != -1){ connectOK = 1; Serial.println("Connected!"); blueToothSerial.print("Connected!"); break; }else if(recvBuf.indexOf("CONNECT:FAIL") != -1){ Serial.println("Connect again!"); break; } } } }while(0 == connectOK); }
/* This function will attempt a connection to the stored remote address The first time you connect the the RN-42 HID, the master device will need to initiate the connection. The first time a connection is made the bluetooth address of the master device will be stored on the RN-42. If no remote address is stored, a connection will not be made. */ uint8_t makeyMateClass::connect() { freshStart(); // Get the module disconnected, and out of command mode while (!enterCommandMode()) { // Enter command mode delay(BLUETOOTH_RESPONSE_DELAY); } delay(BLUETOOTH_RESPONSE_DELAY); bluetooth.flush(); /* get the remote address and print it in the serial monitor */ bluetooth.print("GR"); // Get the remote address bluetooth.write('\r'); delay(BLUETOOTH_RESPONSE_DELAY); if (bluetooth.peek() == 'N') // Might say "No remote address stored */ { // (bluetooth address is hex values only, so won'te start with 'N'. Serial.println("Can't connect. No paired device!"); bluetooth.flush(); bluetooth.print("---"); // exit command mode bluetooth.write('\r'); return 0; // No connect is attempted } else if (bluetooth.available() == 0) { // If we can't communicate with the module at all, print error Serial.println("ERROR!"); return 0; // return error } /* otherwise print the address we're trying to connect to */ Serial.print("Attempting to connect to: "); while (bluetooth.available()) Serial.write(bluetooth.read()); /* Attempt to connect */ bluetooth.print("C"); // The connect command bluetooth.write('\r'); delay(BLUETOOTH_RESPONSE_DELAY); while (bluetooth.available()) Serial.write(bluetooth.read()); // Should print "TRYING" return 1; }
String read() { String msg = ""; while (bluetoothModule->available() > 0) { char c = (char)bluetoothModule->read(); if(c != '\n') msg += c; } return msg; }
void loop() { SoftwareSerial RFID = SoftwareSerial(rxPin,txPin); RFID.begin(RFID_SPEED); digitalWrite(LED,LOW); if((val = RFID.read()) == 10) { // check for header bytesread = 0; while(bytesread<10) { // read 10 digit code val = RFID.read(); if((val == 10)||(val == 13)) { // if header or stop bytes before the 10 digit reading break; // stop reading } code[bytesread] = val; // add the digit bytesread++; // ready to read next digit } // if 10 digit read is complete if(bytesread == 10) { strCode.clear(); strCode.append(code); if( strCode.equals(strOldCode.getChars()) ) { // nop }else{ Serial.print(code); // print the TAG code digitalWrite(LED,HIGH); strOldCode = strCode; MsTimer2::start(); // Timer start } } bytesread = 0; delay(WAIT_INTERVAL); // wait for a second } }
void loop() { if(esp8266.available()) // check if the esp is sending a message { /* while(esp8266.available()) { // The esp has data so display its output to the serial window char c = esp8266.read(); // read the next character. Serial.write(c); } */ if(esp8266.find("+IPD,")) { delay(1000); int connectionId = esp8266.read()-48; // subtract 48 because the read() function returns // the ASCII decimal value and 0 (the first decimal number) starts at 48 String webpage = "<h1>Hello</h1><h2>World!</h2><button>LED1</button>"; String cipSend = "AT+CIPSEND="; cipSend += connectionId; cipSend += ","; cipSend +=webpage.length(); cipSend +="\r\n"; sendData(cipsend,1000,DEBUG); sendData(webpage,1000,DEBUG); webpage="<button>LED2</button>"; cipSend = "AT+CIPSEND="; cipSend += connectionId; cipSend += ","; cipSend +=webpage.length(); cipSend +="\r\n"; sendData(cipsend,1000,DEBUG); sendData(webpage,1000,DEBUG); String closeCommand = "AT+CIPCLOSE="; closeCommand+=connectionId; // append connection id closeCommand+="\r\n"; sendData(closeCommand,3000,DEBUG); } } }
void sport_check(void) { if (s_mode == SERIAL_RX) { while (sportSerial.available() && (s_mode == SERIAL_RX)) { const int data = sportSerial.read(); if (data < 0) { break; } sport_byte_received(static_cast<uint8_t>(data)); } } else { sport_set_serial(SERIAL_RX); } }
/****************** cMsgBytes Send a byte array message, expect an ACK */ int LoRaModem::cMsgBytes(uint8_t * bytes, int16_t length) { _LoRaSerial.read(); _LoRaSerial.print("AT+CMSGHEX=\""); do { prnt("%02x", *bytes++); } while (--length); _LoRaSerial.println("\""); if (_checkresponse(".+ACK Received.+CMSGHEX: Done")) { return 1; } return 0; };
void loop() { if (GPRS.available()) // if date is comming from software serial port { while(GPRS.available()) // reading data into char array { buffer[count++]=GPRS.read(); // writing data into array if(count == 64) break; } Serial.write(buffer,count); // if no data transmission ends, write buffer to hardware serial port clearBufferArray(); // call clear BufferArray function to clear the storage data from the array count = 0; // set counter of while loop to zero } if (Serial.available()) // if data is available on hardware serial port ==> data is comming from PC or notebook GPRS.write(Serial.read()); // write it to the GPRS shield }
/* This function reads all available characters on the bluetooth RX line into the dest array. It'll exit on either timeout, or if the 0x0A (new line) character is received. */ uint8_t makeyMateClass::bluetoothReceive(char * dest) { int timeout = 1000; char c; int i = 0; while ((--timeout > 0) && (c != 0x0A)) { if (bluetooth.available()) { c = bluetooth.read(); if (c != 0x0D) dest[i++] = c; timeout = 1000; // reset timeout } } return timeout; }
/* This function will set the RN-42 into HID mode, from SPP mode. Requires a reboot to take effect! */ uint8_t makeyMateClass::setHIDMode(void) { if (bluetooth.available()) bluetooth.flush(); // Get rid of any characters in the buffer, we'll need to check it fresh bluetooth.print("S~,6"); // Bluetooth HID Mode bluetooth.write('\r'); delay(BLUETOOTH_RESPONSE_DELAY); bluetoothReceive(rxBuffer); /* Double check the setting, output results in Serial monitor */ bluetooth.flush(); bluetooth.print("G~"); bluetooth.write('\r'); delay(BLUETOOTH_RESPONSE_DELAY); Serial.print("Profile set to: "); while (bluetooth.available()) Serial.write(bluetooth.read()); return bluetoothCheckReceive(rxBuffer, "AOK", 3); }
/* This function can send one of the 5 special configuration commands: 0: Disable all special commands 4: Disable reading values of GPIO3 and 6 on power-up. 16: Configure firmware to optimize for low-latency transfers. 128: Allow for fast reconnect. 256: Set 2-stop bit mode on UART. Most of these are not recommended, but the low-latency is useful. */ uint8_t makeyMateClass::setSpecialConfig(uint8_t num) { if (bluetooth.available()) bluetooth.flush(); // Get rid of any characters in the buffer, we'll need to check it fresh bluetooth.print("SQ,"); // SQ sets special config bluetooth.print(num); // Should print ASCII decimal vaule bluetooth.write('\r'); delay(BLUETOOTH_RESPONSE_DELAY); // Response will go to software serial buffer bluetoothReceive(rxBuffer); /* Double check the setting, output results in Serial monitor */ bluetooth.flush(); bluetooth.print("GQ"); bluetooth.write('\r'); delay(BLUETOOTH_RESPONSE_DELAY); Serial.print("Special Config set to: "); while (bluetooth.available()) Serial.write(bluetooth.read()); return bluetoothCheckReceive(rxBuffer, "AOK", 3); }
/* This function enables or disables authentication (pincode pairing) Two options are available for Authmode: 0: Disabled 1: Enabled */ uint8_t makeyMateClass::setAuthentication(uint8_t authMode) { if (bluetooth.available()) bluetooth.flush(); // Get rid of any characters in the buffer, we'll need to check it fresh bluetooth.print("SA,"); // SA sets the authentication bluetooth.print(authMode); // Should print ASCII vaule bluetooth.write('\r'); delay(BLUETOOTH_RESPONSE_DELAY); // Response will go to software serial buffer bluetoothReceive(rxBuffer); /* Double check the setting, output results in Serial monitor */ bluetooth.flush(); bluetooth.print("GA"); bluetooth.write('\r'); delay(BLUETOOTH_RESPONSE_DELAY); Serial.print("Authentication Mode set to: "); while (bluetooth.available()) Serial.write(bluetooth.read()); return bluetoothCheckReceive(rxBuffer, "AOK", 3); }
/* This function enables low power SNIFF mode. Send a 4-byte string as the sleepConfig variable "0000" = disabled e.g.: "0050" = Wake up every 50ms "8xxx" = Enables deep sleep mode */ uint8_t makeyMateClass::setSleepMode(char * sleepConfig) { if (bluetooth.available()) bluetooth.flush(); // Get rid of any characters in the buffer, we'll need to check it fresh bluetooth.print("SW,"); // SW sets the sniff mode bluetooth.print(sleepConfig); // Should print ASCII vaule bluetooth.write('\r'); delay(BLUETOOTH_RESPONSE_DELAY); // Response will go to software serial buffer bluetoothReceive(rxBuffer); /* Double check the setting, output results in Serial monitor */ bluetooth.flush(); bluetooth.print("GW"); bluetooth.write('\r'); delay(BLUETOOTH_RESPONSE_DELAY); Serial.print("Deep Sleep Mode set to: "); while (bluetooth.available()) Serial.write(bluetooth.read()); return bluetoothCheckReceive(rxBuffer, "AOK", 3); }
/* echoMode() will set up an echo interface betwen bluetooth and the Arduino hardware serial This is mostly useful if you're having trouble connecting from the BlueSMiRF to MetaWatch. Anything sent to the Arduino's hardware serial (e.g. entered into the Serial Monitor) will be echoed out to the software serial (bluetooth module). ANything sent to the bluetooth module will be echoed out of the Arduino's hardware serial (e.g. visible in the Serial monitor). It's not recommended to try to send message packets to the watch using this echo mode (unless you're some kind of genius CRC calculator). To exit echo mode, type ~~~. */ void SFE_MetaWatch::echoMode() { int c; int tildeCount = 0; Serial.println("Echo mode. Press ~~~ to escape."); while(tildeCount < 3) { if (bt.available()) { c = bt.peek(); Serial.write(bt.read()); if (c == '~') tildeCount++; } if (Serial.available()) { c = Serial.peek(); bt.write(Serial.read()); if (c == '~') tildeCount++; } } Serial.println("Exiting echo mode..."); }
/* freshStart() attempts to get the module into a known state from any of these 3 possible states: 1) Connected - Sending 0 will disconnect the module, then we'll put it into command mode 2) Disconnected - In this case, we'll just get it into command mode 3) Disconnected, already in Command Mode - Sending 0 makes the module unresponsive until an undefined \r\n's are sent. I can't find any reason for this in the RN-42 User manual Once this function has completed, the RN-42 should be disconnected, in non-command mode */ void makeyMateClass::freshStart(void) { int timeout = 1000; // timeout, in the rare case the module is unresponsive bluetooth.write((uint8_t) 0); // Disconnects, if connected delay(BLUETOOTH_RESPONSE_DELAY); bluetooth.flush(); // delete buffer contents bluetooth.print("$$$"); // Command mode string do // This gets the module out of state 3 { // continuously send \r until there is a response, usually '?' bluetooth.write('\r'); Serial.print("-"); // Debug info for how many \r's required to get a respsonse } while ((!bluetooth.available()) && (timeout-- > 0)); while (bluetooth.available()) Serial.write(bluetooth.read()); delay(BLUETOOTH_RESPONSE_DELAY); bluetooth.flush(); // delay and flush the receive buffer bluetooth.print("---"); // exit command mode bluetooth.write('\r'); delay(BLUETOOTH_RESET_DELAY); // longer delay bluetooth.flush(); // Flush the receive buffer }
uint8_t EV3_Setup(uint8_t port, uint8_t type) // Sets up the sensor to data mode { if(port == PORT_1){ // PORT_1 DDRC |= 0x04; // Set the Rx pin as output DDRC &= 0xFE; uint8_t mode; // Calculate the mode as a number if(type < TYPE_SENSOR_EV3_COLOR_M0) mode = type - TYPE_SENSOR_EV3_US_M0; else if(type < TYPE_SENSOR_EV3_GYRO_M0) mode = type - TYPE_SENSOR_EV3_COLOR_M0; else if(type < TYPE_SENSOR_EV3_INFRARED_M0) mode = type - TYPE_SENSOR_EV3_GYRO_M0; else if(type < TYPE_SENSOR_EV3_INFRARED_M5+1) mode = type - TYPE_SENSOR_EV3_INFRARED_M0; else mode = 0; data16[0] = dat16[type-43]; sets[0] = setsd[type-43]; sensor1.begin(2400); // Start SoftwareSerial at base Baud rate sensor1.write(BYTE_ACK); // Write ACK setupDone=false; while(!setupDone){ if(sensor1.available()){ // Check if data is available if(sensor1.read() == BYTE_ACK){ // if an ACK Byte was read delay(1); sensor1.write(BYTE_ACK); // Write 2 ACKs (because, sometimes SoftwareSerial might not write the data properly) delay(1); sensor1.write(BYTE_ACK); sensor1.end(); sensor1.flush(); sensor1.begin(57600); // Try to read at higher baud rate delay(10); if((sensor1.read() & CMD_MASK) == CMD_DATA){ // If the sensor had entered Data Mode sensor1.write(BYTE_NACK); // Write NACK at higher baud rate setupDone=true; // quit setup } else { // if corrupt data or no data was received, go back to base baud rate sensor1.end(); sensor1.begin(2400); } } } } sensor1.write(BYTE_NACK); // Keep the sensor in Data mode if(mode != 0){ // If a mode other than 0 is required, write the mode datas sensor1.write(CMD_SELECT); sensor1.write(mode); sensor1.write(check(0x00,CMD_SELECT,mode)); } sensor1.write(BYTE_NACK); } else{ // PORT_2 DDRC |= 0x08; DDRC &= 0xFD; uint8_t mode; if(type < TYPE_SENSOR_EV3_COLOR_M0) mode = type - TYPE_SENSOR_EV3_US_M0; else if(type < TYPE_SENSOR_EV3_GYRO_M0) mode = type - TYPE_SENSOR_EV3_COLOR_M0; else if(type < TYPE_SENSOR_EV3_INFRARED_M0) mode = type - TYPE_SENSOR_EV3_GYRO_M0; else if(type < TYPE_SENSOR_EV3_INFRARED_M5+1) mode = type - TYPE_SENSOR_EV3_INFRARED_M0; else mode = 0; data16[1] = dat16[type-43]; sets[1] = setsd[type-43]; sensor2.begin(2400); sensor2.write(BYTE_ACK); setupDone=false; while(!setupDone){ if(sensor2.available()){ if(sensor2.read() == BYTE_ACK){ delay(1); sensor2.write(BYTE_ACK); delay(1); sensor2.write(BYTE_ACK); sensor2.end(); sensor2.flush(); sensor2.begin(57600); delay(10); if((sensor2.read() & CMD_MASK) == CMD_DATA){ sensor2.write(BYTE_NACK); setupDone=true; } else { sensor2.end(); sensor2.begin(2400); } } } } sensor2.write(BYTE_NACK); if(mode != 0){ sensor2.write(CMD_SELECT); sensor2.write(mode); sensor2.write(check(0x00,CMD_SELECT,mode)); } sensor2.write(BYTE_NACK); } return 0; }
long EV3_Update(uint8_t port) { if( port == PORT_1 ){ sensor1.write(BYTE_NACK); // To keep the sensor in data mode if(sensor1.available()) { se = sensor1.read(); // Read the first CMD byte if ( (se & CMD_MASK) == CMD_DATA ){ // if it is data ret = 0; byte chk = 0xff^se; // Checksum for(byte n=0 ; n < sets[0] ; n++ ){ // read all sets l[n] = sensor1.read(); m[n] = (data16[0])? sensor1.read() : 0; chk = chk^l[n]^m[n]; ret = (ret<<(data16[0]?16:8)) ; ret |= (m[n]<<8) | l[n] ; } if (sensor1.read() == chk){ // if the checksum is matched, return data return ret; } else { sensor1.flush(); // else flush return -2; } } } sensor1.write(BYTE_NACK); /* sensor1.end(); sensor1.begin(2400); sensor1.write(0x04); sensor1.end(); sensor1.begin(57600); */ return -4; } else if( port == PORT_2 ){ sensor2.write(BYTE_NACK); if(sensor2.available()){ se = sensor2.read(); if ( (se & CMD_MASK) == CMD_DATA ){ ret = 0; byte chk = 0xff^se; for(byte n=0 ; n < sets[1] ; n++ ){ l[n] = sensor2.read(); m[n] = (data16[1])? sensor2.read() : 0; chk = chk^l[n]^m[n]; ret = (ret<<(data16[1]?16:8)); ret |= (m[n]<<8) | l[n] ; } if (sensor2.read() == chk){ return ret; } else { sensor2.flush(); return -2; } } } sensor2.write(BYTE_NACK); /* sensor2.end(); sensor2.begin(2400); sensor2.write(0x04); sensor2.end(); sensor2.begin(57600); */ return -4; } return -6; }
void loop() { if (mySerial.available()) Serial.write(mySerial.read()); if (Serial.available()) mySerial.write(Serial.read()); }
void loop() { //Serial.print(F("Free RAM1:")); Serial.println(freeRam()); // Check secret button but = !digitalRead(ON_PIN); if(but){ Serial.println(F("Button pressed")); secret_button(); } bool GPS_debug = 0; unsigned long t = millis(); while (ss.available() > 0 || t + 1100 < millis()){ gps.encode(ss.read()); GPS_debug = 1; } if (GPS_debug) { Serial.println(F("GPS received")); GPS_debug = 0; } sats_fix = gps.satellites.value(); hdop = gps.hdop.value(); position_lat = gps.location.lat(); position_lon = gps.location.lng(); //target = 3; // debug distance = gps.distanceBetween(position_lat, position_lon, target_lat[target], target_lon[target]); //distance = 4; // debug static int sim, ok; #ifdef SIMULATION if (but == 1){ sim = 1; delay (1000); } else { sim = 0; lcd.setCursor(14, 1); lcd.print(target); } if (distance > 30 && sim == 0){ #else if (distance > 30) { #endif lcd_target(lcd, target, distance, sats_fix); } else { #ifdef BUTTON_FOR_NEXT_STEP wait finish; finish.set_time(2500); finish.set_steps(2); lcd.setCursor(0, 0); if(finish.step() == 1){ lcd.print(F("You are at your ")); lcd.setCursor(0, 1); lcd.print(F("current target.")); } if (finish.step() == 2){ lcd.setCursor(0, 0); lcd.print(F("Press the button")); lcd.setCursor(0, 1); lcd.print(F("to continue... ")); } if (but == 1){ // Go to next target target++; ok = 1; } #else lcd.clear(); lcd.setCursor(0, 0); lcd.print(F("You are at your ")); lcd.setCursor(0, 1); lcd.print(F("current target.")); target++; delay(5000); but = 0; #endif // Open the box at the end of game if(target > NUMBER_OF_TARGETS){ lcd.clear(); lcd.setCursor(0, 0); lcd.print(F("CONRATULATIONS! ")); delay(5000); open_box(); } else { EEPROM.write(EEPROM_TARGET_INDEX, target); } } if(millis() > update_time + 1000){ update_time = millis(); Serial.println(gps.location.lat(), 6); Serial.print(F("LAT=")); Serial.println(gps.location.lat(), 6); Serial.print(F("LONG=")); Serial.println(gps.location.lng(), 6); Serial.print(F("ALT=")); Serial.println(gps.altitude.meters()); Serial.print(F("hdop=")); Serial.println(hdop); Serial.print(F("sats=")); Serial.println(sats_fix); if(hdop < 500 && sats_fix > 4){ fix = 1; distance = gps.distanceBetween(position_lat, position_lon, TARGET_1_LAT, TARGET_1_LON); } else{ fix = 0; strength = sats_fix; //lcd_gps_signal(lcd, strength); } } if(millis() > sleep_time + SLEEP_TIME_MS){ go_sleep(); } } void go_sleep(void) { lcd.clear(); lcd.print(F("Going to sleep..")); delay(2000); pinMode(ON_PIN, OUTPUT); digitalWrite(ON_PIN, 0); }
// TODO: This is extremely kludgy right now. // The delay()'s should be made more robust, faster by periodically checking for a response, // while still checking for a timeout. // Checking for just the first char of a response is a questionabl solution. // Needs more testing. So many unknown states the BlueSMiRF could be in. // We need some flow chart action here. int SFE_MetaWatch::connect() { char c; int timeout = CONNECT_TIMEOUT; bt.print('\r'); // Clear any previous commands delay(BLUETOOTH_RESPONSE_DELAY); bt.flush(); // Entering command mode. Should either print "CMD" or "?" if already there while ((c != 'C') && (c != '?') && (timeout > 0)) { bt.print("$$$"); // Enter command mode delay(BLUETOOTH_RESPONSE_DELAY); c = bt.read(); // Read first character of response bt.flush(); timeout--; } if (timeout == 0) return -2; else timeout = CONNECT_TIMEOUT; // After sending connect command, should print "TRYING", may also print "ERR-connected" while ((c != 'T') && (c != 'E') && (timeout > 0)) { bt.print("C,"); bt.print(watchAddress); bt.print('\r'); delay(BLUETOOTH_RESPONSE_DELAY); c = bt.read(); bt.flush(); timeout--; } // If there was an error, try to exit command mode if ((c == 'E') || timeout == 0) { bt.print("---"); // Exit command mode bt.print('\r'); delay(BLUETOOTH_RESPONSE_DELAY); bt.flush(); } if (timeout == 0) return -1; // Return -1 if connect command error else if (c == 'E') return 2; // Return 2 if we think we're already connected else return 1; // Return 1 if all went according to plan }