/* 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); }
void loop() { if (Serial.available()) if (mySerial.available()) mySerial.println(Serial.read()); Serial.write(mySerial.read()); }
/* 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 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()); }
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; }
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 toSerial() { while(gprsSerial.available()!=0) { Serial.write(gprsSerial.read()); } }
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 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 }
void ncArduinoPollGetData() { int c; while (mySerial.available() > 0) { c = mySerial.read(); byteStreamToPackageStream((unsigned char) c); } }
void GlobalsClass::handle() { if (qCon.available() > 0) checkSerialMsg(); //alarm time checking if (ResetTimeCheck > 0) { if (millis() - ResetTimeCheck > (ResetAlarmSeconds * 1000)) { ResetAlarms(); } //check to see if we've past resetalarm; } }
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; }
/* 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 issues the reboot command, and adds a lengthy delay to give the RN-42 time to restart. */ uint8_t makeyMateClass::reboot(void) { if (bluetooth.available()) bluetooth.flush(); // Get rid of any characters in the buffer, we'll need to check it fresh bluetooth.print("R,1"); // reboot command bluetooth.write('\r'); delay(BLUETOOTH_RESPONSE_DELAY); bluetoothReceive(rxBuffer); delay(BLUETOOTH_RESET_DELAY); return bluetoothCheckReceive(rxBuffer, "Reboot!", 7); }
/* 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 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 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); }
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); } } }
/* 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 }
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); } }
void loop() { digitalWrite(b1, LOW); digitalWrite(b0, LOW); readings[0]=analogRead(1); readings[1]=analogRead(2); readings[2]=analogRead(3); readings[3]=analogRead(4); digitalWrite(b0, HIGH); readings[4]=analogRead(1); readings[5]=analogRead(2); readings[6]=analogRead(3); readings[7]=analogRead(4); digitalWrite(b1, HIGH); digitalWrite(b0, LOW); readings[8]=analogRead(1); readings[9]=analogRead(2); readings[10]=analogRead(3); if(blueToothSerial.available ()) { char ch = Serial.read(); if (ch >='a') { peter=addAction(peter, readings, ch); int i; for(i=0;i<11;i++) { blueToothSerial.println(peter->action->high[i]); } } else { ch = ch + 32; removeAction(ch); } } p=recognize(readings, p); }
/* 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; }
int getState () { if( !wificmd("CIPSTART=\"TCP\",\"example.com\",8080", "OK")) { //start a TCP connection. return 0; } delay(1000); String getRequest = "STATE"; ESPserial.print("AT+CIPSEND="); ESPserial.println(getRequest.length()); delay(500); if(ESPserial.find(">")) { clearWifi(); //Serial.println("Sending.."); ESPserial.print(getRequest); if( ESPserial.find("SEND OK")) { //Serial.println("Packet sent"); String tmpResp = ""; while (ESPserial.available()) { tmpResp = ESPserial.readString(); } // close the connection if(wificmd("CIPCLOSE", "OK")) { if (tmpResp.substring(11) == "1") { return 1; } else { return 0; } } else { Serial.println("Error closing connection"); } } else { Serial.println("Error sending data"); } } return 0; }
/* 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..."); }
int available() { return bluetoothModule->available(); }
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; }