String wifiChat::checkForRequest() { tryConnect(); String requestString = ""; WiFiClient client = server.available(); Serial.print(client); if(!client) return requestString; //Serial.print("Client.available() = "); //Serial.print(client.available()); if (client.available() > 0) { char thisChar = client.read(); while(thisChar != '\n' && client.available() > 0) { requestString.concat(thisChar); thisChar = client.read(); } } return requestString; }
void loop() { // check the network connection once every 10 seconds: delay(10000); printCurrentNet(); // Trying to connect to http://hasthelargehadroncolliderdestroyedtheworldyet.com/ Serial5.println("Trying to connect to : www.hasthelargehadroncolliderdestroyedtheworldyet.com :"); httpRequest(); while( client.available() ) { Serial5.print((char)(client.read())); } Serial5.println("END"); }
extern "C" void MW_WifiTCPFinalread(uint8_t wifitcpindex, uint8_t *data, uint32_t serverport, int32_t *outStatus) { int libFcnOutput; WiFiClient client = server[wifitcpindex].available(); if (client == true) { libFcnOutput = client.read(); *data = (uint8_t) libFcnOutput; *outStatus = (libFcnOutput != -1); } else { //When the client is not connected the status flag is accordingly toggled. *outStatus = 0; } }
//****************** Recieve data for ModBusMaster **************** void MgsModbus::MbmRun() { //****************** Read from socket **************** while (MbmClient.available()) { MbmByteArray[MbmCounter] = MbmClient.read(); if (MbmCounter > 4) { if (MbmCounter == MbmByteArray[5] + 5) { // the full answer is recieved MbmClient.stop(); MbmProcess(); #ifdef DEBUG Serial.println("recieve klaar"); #endif } } MbmCounter++; } }
void ThingspeakClient::getLastChannelItem(String channelId, String readApiKey) { JsonStreamingParser parser; parser.setListener(this); WiFiClient client; // http://api.thingspeak.com/channels/CHANNEL_ID/feeds.json?results=2&api_key=API_KEY const char host[] = "api.thingspeak.com"; String url = "/channels/" + channelId +"/feeds.json?results=1&api_key=" + readApiKey; const int httpPort = 80; if (!client.connect(host, httpPort)) { Serial.println("connection failed"); return; } Serial.print("Requesting URL: "); Serial.println(url); // This will send the request to the server client.print(String("GET ") + url + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); while(!client.available()) { Serial.println("."); delay(1000); } int pos = 0; boolean isBody = false; char c; int size = 0; client.setNoDelay(false); while(client.connected()) { while((size = client.available()) > 0) { c = client.read(); if (c == '{' || c == '[') { isBody = true; } if (isBody) { parser.parse(c); } } } }
void RobotHostInterface::rcvCommand(struct HostCommand *command) { byte rawCmd = 0xFF; WiFiClient client = robotServer->available(); if (client) { Serial.print("Robot Client connected..."); Serial.println("Waiting for a command......" ); while (client.available() == 0 ) { delay( 100 ); } rawCmd = (byte)client.read(); Serial.print("Raw Command: "); Serial.print(rawCmd); command->cmd = rawCmd >> 3; command->arg = rawCmd & 0x07; Serial.print(", Cmd: "); Serial.print(command->cmd); Serial.print(", arg: "); Serial.println(command->arg); if (command->cmd == CMD_ARRIVAL || command->cmd == CMD_WATCHDOG) { if (command->cmd == CMD_ARRIVAL && getArrival()) { rawCmd = CMD_ARRIVAL << 3; setArrival(false); } else if (command->cmd == CMD_WATCHDOG) { rawCmd = 0xFF; } else { rawCmd = 0xFF; } } /* send acknowledgement */ robotServer->write(rawCmd); delay(100); client.stop(); Serial.println("Client Disconnected.\n"); } }
void loop() { // if there are incoming bytes available // from the server, read them and print them: while (client.available()) { char c = client.read(); Serial.write(c); } // if the server's disconnected, stop the client: if (!client.connected()) { Serial.println(); Serial.println("disconnecting from server."); client.stop(); // do nothing forevermore: while(true); } }
void WundergroundClient::doUpdate(String url) { JsonStreamingParser parser; parser.setListener(this); WiFiClient client; const int httpPort = 80; if (!client.connect("api.wunderground.com", httpPort)) { Serial.println("connection failed"); return; } Serial.print("Requesting URL: "); Serial.println(url); // This will send the request to the server client.print(String("GET ") + url + " HTTP/1.1\r\n" + "Host: api.wunderground.com\r\n" + "Connection: close\r\n\r\n"); int retryCounter = 0; while(!client.available()) { delay(1000); retryCounter++; if (retryCounter > 10) { return; } } int pos = 0; boolean isBody = false; char c; int size = 0; client.setNoDelay(false); while(client.connected()) { while((size = client.available()) > 0) { c = client.read(); if (c == '{' || c == '[') { isBody = true; } if (isBody) { parser.parse(c); } } } }
void next_client() { // Listenning for new clients client = server.available(); if (client) { Serial.println("New client"); // bolean to locate when the http request ends boolean blank_line = true; while (client.connected()) { if (client.available()) { char c = client.read(); if (c == '\n' && blank_line) { client.println("HTTP/1.1 200 OK"); client.println("Content-Type: application/json"); client.println("Access-Control-Allow-Origin: *"); client.println("Connection: close"); client.println(); print_json(); break; } if (c == '\n') { // when starts reading a new line Serial.println(); blank_line = true; } else if (c != '\r') { // when finds a character on the current line Serial.write(c); blank_line = false; } } } // closing the client connection delay(1); client.stop(); Serial.println("Client disconnected."); } }
bool ESPWebServer::handleClientRequest(ServoControl &servoInteraction, String htmlPage) { bool clientHandled = false; WiFiClient client = m_server.available(); // Listen for incoming clients if (client) { Serial.println("New Client."); String header = ""; String currentLine = ""; // make a String to hold incoming data from the client while (client.connected()) { if (client.available()) { char c = client.read(); // read a byte, then Serial.write(c); // print it out the serial monitor header += c; if (c == '\n') { // if the current line is blank, you got two newline characters in a row. // that's the end of the client HTTP request, so send a response: if (currentLine.length() == 0) { // checks if the client signaled an interaction int index; servoInteraction.type = NONE; if ((index = header.indexOf("GET /openBlinds")) >= 0) { servoInteraction.type = OPEN_BLINDS; } else if ((index = header.indexOf("GET /closeBlinds")) >= 0) { servoInteraction.type = CLOSE_BLINDS; } else if ((index = header.indexOf("GET /setOpenBlinds")) >= 0) { String passedValue; index += 20; char newChar = header.charAt(index); while(newChar != '"') { passedValue += newChar; index++; newChar = header.charAt(index); } servoInteraction.type = SET_OPEN; servoInteraction.setting = passedValue.toInt(); } else if ((index = header.indexOf("GET /setCloseBlinds")) >= 0) { String passedValue; index += 21; char newChar = header.charAt(index); while(newChar != '"') { passedValue += newChar; index++; newChar = header.charAt(index); } servoInteraction.type = SET_CLOSE; servoInteraction.setting = passedValue.toInt(); } // HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK) // and a content-type so the client knows what's coming, then a blank line: client.println("HTTP/1.1 200 OK"); client.println("Content-type:text/html"); client.println("Connection: close"); client.println(); // Display the HTML web page client.println(htmlPage); // Break out of the while loop clientHandled = true; break; } else { // if you got a newline, then clear currentLine currentLine = ""; } } else if (c != '\r') { // if you got anything else but a carriage return character, currentLine += c; // add it to the end of the currentLine } } } // Close the connection client.stop(); Serial.println("Client disconnected."); Serial.println(""); } return clientHandled; }
void waitForTarget() { //define a client object to connect to the server WiFiClient mainClient; //wait for a client to connect to the server while(!alreadyConnectedMain) { //attempt to save a client connecting to the server mainClient = mainServer.available(); //if a client is connected, begin communication if (mainClient) { if (!alreadyConnectedMain) { // clead out the input buffer: mainClient.flush(); Serial.println("We have a new client"); debugServer.println("We have a new client"); mainClient.println("Hello, client!"); alreadyConnectedMain = true; } } delay(100); delay(100); } Serial.println("writing"); debugClient.println("writing"); //mainServer.println("ready"); delay(1000); //Strings to read in latitude and longitude from the client char lat[50] = ""; char lon[50] = ""; int ind = 0; //Wait for input to be on the buffer while(!mainClient.available()); char destNum = '0'; while(!(destNum == '1' || destNum == '2' || destNum == '3')) { destNum = mainClient.read(); Serial.println(destNum); } if(destNum == '1') { tarLat = LAT1; tarLon = LON1; } if(destNum == '2') { tarLat = LAT2; tarLon = LON2; } if(destNum == '3') { tarLat = LAT3; tarLon = LON3; } /* //Read in characters from the input buffer until a new line character is reached //this will be the latitude while(mainClient.available()) { char c = mainClient.read(); lat[ind] = c; if(c == '\n') { lat[ind] = NULL; break; } ind++; } ind = 0; //Read in characters from the input buffer until a new line character is reached //this will be the longitude while(mainClient.available()) { char c = mainClient.read(); lon[ind] = c; if(c == '\n') { lon[ind] = NULL; break; } ind++; } mainClient.stop(); //convert from a string to a float tarLat = strtof(lat, NULL); tarLon = strtof(lon, NULL); //digitalWrite(LED1, LOW); //tarLat = atof(lat); //tarLon = atof(lon);*/ Serial.print("Lat: "); Serial.print(lat); Serial.print(" "); Serial.println(tarLat, 6); Serial.print("Lon: "); Serial.print(lon); Serial.print(" "); Serial.println(tarLon, 6); debugClient.print("Lat: "); debugClient.print(lat); debugClient.print(" "); debugClient.println(tarLat, 6); debugClient.print("Lon: "); debugClient.print(lon); debugClient.print(" "); debugClient.println(tarLon, 6); //Erick's //tarLat = 28.504906f; //tarLon = -81.457456f; //apt //tarLat = 28.582183f; //tarLon = -81.202770f; //apt 2 //tarLat = 28.582373f; //tarLon = -81.202996f; //curLat = 28.628811f; //curLon = -81.199479f; //mem mall //tarLat = 28.603710f; //tarLon = -81.199371f; //matt's //tarLat = 28.628391; //tarLon = -81.200013; }
bool FOTAService(void) { FOTA_StateMachine_t state_current; String storage_bucket = EE_GetFirebaseStorageBucket(); state_current = state; switch (state) { case FOTA_Sm_IDLE: break; case FOTA_Sm_GET_MD5: { String md5file_url = String(F("/v0/b/")) + storage_bucket + String(F("/o/")) + VERS_HW_VER + String(FPSTR(md5file_name)) + String(F("?alt=media")); addr = String(F("https://")) + String(FPSTR(storage_host)) + md5file_url; DEBUG_PRINT("FOTA_Sm_GET_MD5 %s\n", addr.c_str()); http = new HTTPClient; http->setReuse(true); http->setTimeout(3000); bool res = http->begin(addr, storage_fingerprint); if (res == true) { int httpCode = http->GET(); // httpCode will be negative on error if (httpCode > 0) { // HTTP header has been send and Server response header has been handled DEBUG_PRINT("[HTTP] GET... code: %d\n", httpCode); // file found at server if (httpCode == HTTP_CODE_OK) { int size = http->getSize(); if (size == DIGEST_MD5_SIZE) { DEBUG_PRINT("md5file size %d\n", size); WiFiClient *stream = http->getStreamPtr(); digest_MD5 = (uint8_t *)malloc(DIGEST_MD5_SIZE); stream->read(digest_MD5, size); state = FOTA_Sm_CHECK; } else { DEBUG_PRINT("md5file size error: %d\n", size); state = FOTA_Sm_ERROR; } } else { DEBUG_PRINT("md5file httpCode error: %d\n", httpCode); state = FOTA_Sm_ERROR; } } else { DEBUG_PRINT("[HTTP] GET... failed, error: %s\n", http->errorToString(httpCode).c_str()); state = FOTA_Sm_ERROR; } } else { DEBUG_PRINT("[HTTP] begin... failed, error: %d\n", res); state = FOTA_Sm_ERROR; } } break; case FOTA_Sm_CHECK: { String file_url = String(F("/v0/b/")) + storage_bucket + String(F("/o/")) + VERS_HW_VER + String(FPSTR(file_name)) + String(F("?alt=media")); addr = String(F("https://")) + String(FPSTR(storage_host)) + file_url; DEBUG_PRINT("FOTA_Sm_CHECK %s\n", addr.c_str()); http->setReuse(true); bool res = http->begin(addr, storage_fingerprint); if (res == true) { int httpCode = http->GET(); // httpCode will be negative on error if (httpCode > 0) { http->end(); // HTTP header has been send and Server response header has been handled DEBUG_PRINT("[HTTP] GET... code: %d\n", httpCode); int size = http->getSize(); DEBUG_PRINT("file size %d\n", size); block = 0; num_blocks = (size + block_size - 1) / block_size; if (Update.begin(size, 0)) { Update.setMD5((char *)digest_MD5); buffer = (uint8_t *)malloc(block_size); state = FOTA_Sm_GET_BLOCK; } else { state = FOTA_Sm_ERROR; } } else { DEBUG_PRINT("file httpCode error: %d\n", httpCode); state = FOTA_Sm_ERROR; } } else { state = FOTA_Sm_ERROR; } } break; case FOTA_Sm_GET_BLOCK: { http->setReuse(true); bool res = http->begin(addr, storage_fingerprint); if (res == true) { String range = String(F("bytes=")) + String(block * block_size) + String(F("-")) + String(((block + 1) * block_size) - 1); http->addHeader(String(F("Range")), range); int httpCode = http->GET(); // httpCode will be negative on error if (httpCode > 0) { // HTTP header has been send and Server response header has been handled // Serial.printf("[HTTP] GET... code: %d\n", httpCode); int len = http->getSize(); // get tcp stream WiFiClient *stream = http->getStreamPtr(); int pos = 0; bool run = true; bool fail = false; while (run == true) { delay(1); if (pos < len) { size_t size = stream->available(); if (size) { uint16_t c = stream->readBytes(&buffer[pos], size); pos += c; } if (!http->connected() && (pos < len)) { run = false; fail = true; } } else { run = false; } } if (fail == false) { Update.write(buffer, pos); DEBUG_PRINT("[%03d]: %02d%% -- %d\r", block, 100 * block / num_blocks, ESP.getFreeHeap()); block++; if (block < num_blocks) { /* move to next block */ state = FOTA_Sm_GET_BLOCK; } else { if (!Update.end()) { DEBUG_PRINT("Update Error\n"); } state = FOTA_Sm_COMPLETE; } } else { state = FOTA_Sm_ERROR; } } else { DEBUG_PRINT("[HTTP] GET... failed, error: %s\n", http->errorToString(httpCode).c_str()); state = FOTA_Sm_ERROR; } } else { DEBUG_PRINT("begin error @ %d\n", block); state = FOTA_Sm_ERROR; } } break; case FOTA_Sm_ERROR: { if (http_fail_cnt++ < 20) { DEBUG_PRINT("retry %d\n", http_fail_cnt); state = state_last; } else { /* give-up */ DEBUG_PRINT("retry give-up\n"); Serial.flush(); ESP.restart(); } } break; case FOTA_Sm_COMPLETE: { DEBUG_PRINT("closing connection\n"); Serial.flush(); free(buffer); /* restar node anycase */ ESP.restart(); state = FOTA_Sm_IDLE; } break; } state_last = state_current; return (state != FOTA_Sm_IDLE); }
/* * ======== apLoop ======== */ __extern void apLoop() { /* Did a client connect/disconnect since the last time we checked? */ int a = WiFi.getTotalDevices(); if (a != num_clients) { if (a > num_clients) { // new Client connected int i; /* display all clients on the network */ Serial.println("New client connected. All clients:"); for (i = 0; i < a; i++) { Serial.print(" Client #"); Serial.print(i); Serial.print(" at IP address = "); Serial.print(WiFi.deviceIpAddress(i)); Serial.print(", MAC = "); Serial.println(WiFi.deviceMacAddress(i)); } } else { // a Client disconnected Serial.print("Client disconnected, "); Serial.print(a); Serial.println(" clients remaining."); } num_clients = a; } if (num_clients > 0) { /* listen for incoming clients */ WiFiClient client = server.available(); if (client) { /* if there's a client, read and process commands */ Serial.print("new client socket: "); Serial.println(++num_sockets); static char buffer[80] = {0}; int bufLen = 0; /* while connected to the client, read commands and send results */ while (client.connected()) { /* if there's a byte to read from the client .. */ if (client.available()) { /* copy it to the command buffer, byte at a time */ char c = client.read(); /* ignore bogus characters */ if (c == '\0' || c == '\r') continue; /* never overrun the command buffer */ if (bufLen >= (int)(sizeof (buffer))) { bufLen = sizeof (buffer) - 1; } buffer[bufLen++] = c; /* if there's a new line, we have a complete command */ if (c == '\n') { doCommand(buffer, bufLen, client); /* reset command buffer index to get next command */ bufLen = 0; } } } /* client disconnected, close the connection */ client.stop(); Serial.println("client socket disconnected"); } } delay(100); }
void GPSUploader::_sendNextGpsData() { int startTimeUploading = millis(); if(!this->_initialized) return; Serial.printf("Upload: Pending messages: %d\n", this->_sdQueue.getCount()); Serial.println("Upload: preparation"); this->_sdQueue.flush();//avoid parallel flush() during server connection (too much mem) if(this->_sdQueue.getCount()==0) { Serial.println("Upload: no data to send"); return; } //connect to server and send various POST on the same connection WiFiClient client; // Serial.printf("Host=%s:%d\n", this->_configNode.getUploadServerHost().c_str(), this->_configNode.getUploadServerPort()); _watchdog.ping(); int startTime = millis(); if (!client.connect(this->_uploadServerHost.get(), this->_uploadServerPort.get())) { this->_totalUploadCountError++; this->_totalUploadTimeError+=(millis()-startTime); Serial.println("Upload: server connection failed"); _watchdog.ping(); return; } _watchdog.ping(); //send //If this takes more than 10s, abort and loop again so that Wifi and MQTT won't lose connection for(int i=0; i<10 && ((millis()-startTimeUploading)<10000); i++) { // int len = 0; int sdRecordsCount = 0; int sdRecordsOK = 0; int sdRecordsError = 0; strcpy(this->_gpsUploadBuffer, ""); // Serial.println("Upload: Preparing chunk"); while(this->_sdQueue.peek(this->_gpsRecord, sdRecordsCount++) && strlen(this->_gpsUploadBuffer) < 1150) { //fill post with ~1200 bytes if(GPSUtils::validateNmeaChecksum(this->_gpsRecord)) { strcat(this->_gpsUploadBuffer, this->_gpsRecord); strcat(this->_gpsUploadBuffer, "\n"); sdRecordsOK++; } else { Serial.printf("Upload: crc error %s\n", this->_gpsRecord); sdRecordsError++; } yield(); } if(strlen(this->_gpsUploadBuffer)>0) { Serial.printf("Upload: records=%d err=%d\n", sdRecordsOK, sdRecordsError); Serial.println("POST /" + String(this->_uploadServerUri.c_str())); int startTime = millis(); client.printf("POST /%s HTTP/1.1\r\nHost: %s\r\nContent-Length: %d\r\nContent-Type: text/plain\r\n\r\n", this->_uploadServerUri.c_str(), "api.devices.stutzthings.com", // this->_uploadServerHost.get(), strlen(this->_gpsUploadBuffer) ); client.print(this->_gpsUploadBuffer); _watchdog.ping(); // Serial.println("SENT"); //wait for response available int timeout = millis(); while (client.available() < 15) { if (millis() - timeout > 5000) { Serial.println("Upload: server response timeout"); client.stop(); this->_totalUploadBytesError += strlen(this->_gpsUploadBuffer); this->_totalUploadCountError++; this->_totalUploadTimeError+=(millis()-startTime); return; } delay(50); _watchdog.ping(); } // Serial.println("RECEIVED RESPONSE"); //process response bool success = false; if(client.readStringUntil(GCHAR_SPACE).length()>0) { String code = client.readStringUntil(GCHAR_SPACE); _watchdog.ping(); if(code == "201") { Serial.println("Upload: 201 Created"); success = true; this->_totalUploadBytesSuccess += strlen(this->_gpsUploadBuffer); this->_totalUploadCountSuccess++; this->_totalUploadTimeSuccess+=(millis()-startTime); this->_totalUploadRecordsSuccess+=sdRecordsOK; this->_totalUploadRecordCRCError+=sdRecordsError; this->_sdQueue.removeElements(sdRecordsCount); // Serial.println("Upload: sent records removed from disk"); } else { this->_totalUploadBytesError += strlen(this->_gpsUploadBuffer); this->_totalUploadCountError++; this->_totalUploadTimeError+=(millis()-startTime); Serial.println("Upload: server error " + String(code)); } } else { this->_totalUploadBytesError += strlen(this->_gpsUploadBuffer); this->_totalUploadCountError++; this->_totalUploadTimeError+=(millis()-startTime); Serial.println("Upload: invalid server response"); } //drain response data // Serial.println("RESPONSE DRAIN0"); _watchdog.ping(); while(client.available()>0) { client.read(); } // Serial.println("RESPONSE DRAIN1"); // Serial.println("Upload: post finished"); } else { Serial.println("Upload: no data pending"); if(sdRecordsError>0) { this->_sdQueue.removeElements(sdRecordsError); this->_totalUploadRecordCRCError+=sdRecordsError; } break; } _watchdog.ping(); yield(); _watchdog.ping(); // Serial.println("FINISHED POST"); } client.stop(); }
/* * ======== apLoop ======== */ __extern void apLoop() { /* Did a client connect/disconnect since the last time we checked? */ int a = WiFi.getTotalDevices(); if (a != num_clients) { if (a > num_clients) { // new Client connected int i; digitalWrite(MAIN_LED_PIN, !digitalRead(MAIN_LED_PIN)); /* display all clients on the network */ Serial.println("New client connected. All clients:"); for (i = 0; i < a; i++) { Serial.print(" Client #"); Serial.print(i); Serial.print(" at IP address = "); Serial.print(WiFi.deviceIpAddress(i)); Serial.print(", MAC = "); Serial.println(WiFi.deviceMacAddress(i)); } } else { // a Client disconnected digitalWrite(MAIN_LED_PIN, !digitalRead(MAIN_LED_PIN)); Serial.print("Client disconnected, "); Serial.print(a); Serial.println(" clients remaining."); } num_clients = a; } if (num_clients > 0) { /* listen for incoming clients */ WiFiClient client = server.available(); if (client) { /* if there's a client, read and process commands */ Serial.print("new client socket: "); Serial.println(++num_sockets); static char buffer[64] = {0}; int bufLen = 0; /* while connected to the client, read commands and send results */ unsigned int lapse = 0; unsigned int start = millis(); while (client.connected()) { /* if there's a byte to read from the client .. */ if (client.available()) { /* copy it to the command buffer, byte at a time */ char c = client.read(); /* ignore bogus characters */ if (c == '\0' || c == '\r') continue; /* never overrun the command buffer */ if (bufLen >= (int)(sizeof (buffer))) { bufLen = sizeof (buffer) - 1; } buffer[bufLen++] = c; //Serial.print(num_sockets); Serial.print(": "); //Serial.println((int)c); /* if there's a new line, we have a complete command */ if (c == '\n') { doCommand(buffer, bufLen, client); /* reset command buffer index to get next command */ bufLen = 0; } lapse = 0; start = millis(); } else { lapse = millis() - start; } } Serial.print("client socket disconnected: lapse = "); Serial.println(lapse); /* client disconnected or timed out, close the connection */ client.stop(); /* disconnect => implicitly stop the motor */ motorWASD = ' '; } } /* check for new connections 2 times per second */ delay(500); }
void loop(){ WiFiClient client = server.available(); // Listen for incoming clients if (client) { // Print local IP address and start web server Serial.println(""); Serial.println("WiFi connected."); Serial.println("IP address: "); Serial.println(WiFi.localIP()); //server.begin(); // If a new client connects, Serial.println("New Client."); // print a message out in the serial port String currentLine = ""; // make a String to hold incoming data from the client while (client.connected()) { // loop while the client's connected if (client.available()) { // if there's bytes to read from the client, char c = client.read(); // read a byte, then Serial.write(c); // print it out the serial monitor header += c; if (c == '\n') { // if the byte is a newline character // if the current line is blank, you got two newline characters in a row. // that's the end of the client HTTP request, so send a response: if (currentLine.length() == 0) { // HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK) // and a content-type so the client knows what's coming, then a blank line: client.println("HTTP/1.1 200 OK"); client.println("Content-type:text/html"); client.println("Connection: close"); client.println(); // turns the GPIOs on and off if (header.indexOf("GET /5/on") >= 0) { Serial.println("GPIO 5 on"); output5State = "on"; digitalWrite(output5, HIGH); } else if (header.indexOf("GET /5/off") >= 0) { Serial.println("GPIO 5 off"); output5State = "off"; digitalWrite(output5, LOW); } else if (header.indexOf("GET /4/on") >= 0) { Serial.println("GPIO 4 on"); output4State = "on"; digitalWrite(output4, HIGH); } else if (header.indexOf("GET /4/off") >= 0) { Serial.println("GPIO 4 off"); output4State = "off"; digitalWrite(output4, LOW); } // Display the HTML web page client.println("<!DOCTYPE html><html>"); client.println("<head><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">"); client.println("<link rel=\"icon\" href=\"data:,\">"); // CSS to style the on/off buttons // Feel free to change the background-color and font-size attributes to fit your preferences client.println("<style>html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}"); client.println(".button { background-color: #195B6A; border: none; color: white; padding: 16px 40px;"); client.println("text-decoration: none; font-size: 30px; margin: 2px; cursor: pointer;}"); client.println(".button2 {background-color: #77878A;}</style></head>"); // Web Page Heading client.println("<body><h1>ESP8266 Web Server</h1>"); // Display current state, and ON/OFF buttons for GPIO 5 client.println("<p>GPIO 5 - State " + output5State + "</p>"); // If the output5State is off, it displays the ON button if (output5State=="off") { client.println("<p><a href=\"/5/on\"><button class=\"button\">ON</button></a></p>"); } else { client.println("<p><a href=\"/5/off\"><button class=\"button button2\">OFF</button></a></p>"); } // Display current state, and ON/OFF buttons for GPIO 4 client.println("<p>GPIO 4 - State " + output4State + "</p>"); // If the output4State is off, it displays the ON button if (output4State=="off") { client.println("<p><a href=\"/4/on\"><button class=\"button\">ON</button></a></p>"); } else { client.println("<p><a href=\"/4/off\"><button class=\"button button2\">OFF</button></a></p>"); } client.println("</body></html>"); // The HTTP response ends with another blank line client.println(); // Break out of the while loop break; } else { // if you got a newline, then clear currentLine currentLine = ""; } } else if (c != '\r') { // if you got anything else but a carriage return character, currentLine += c; // add it to the end of the currentLine } } } // Clear the header variable header = ""; // Close the connection client.stop(); Serial.println("Client disconnected."); Serial.println(""); } }
AJ_Status AJ_Net_Recv(AJ_IOBuffer* buf, uint32_t len, uint32_t timeout) { AJ_Status status = AJ_ERR_READ; uint32_t ret; uint32_t rx = AJ_IO_BUF_SPACE(buf); uint32_t recvd = 0; unsigned long Recv_lastCall = millis(); // first we need to clear out our buffer uint32_t M = 0; AJ_InfoPrintf(("AJ_Net_Recv(buf=0x%p, len=%d., timeout=%d.)\n", buf, len, timeout)); if (rxLeftover != 0) { // there was something leftover from before, AJ_InfoPrintf(("AJ_NetRecv(): leftover was: %d\n", rxLeftover)); M = min(rx, rxLeftover); memcpy(buf->writePtr, rxDataStash, M); // copy leftover into buffer. buf->writePtr += M; // move the data pointer over memmove(rxDataStash, rxDataStash + M, rxLeftover - M); // shift left-overs toward the start. rxLeftover -= M; recvd += M; // we have read as many bytes as we can // higher level isn't requesting any more if (recvd == rx) { AJ_InfoPrintf(("AJ_Net_Recv(): status=AJ_OK\n")); return AJ_OK; } } if ((M != 0) && (rxLeftover != 0)) { AJ_InfoPrintf(("AJ_Net_REcv(): M was: %d, rxLeftover was: %d\n", M, rxLeftover)); } // wait for data to become available // time out if nothing arrives while (g_client.connected() && g_client.available() == 0 && (millis() - Recv_lastCall < timeout)) { delay(50); // wait for data or timeout } // return timeout if nothing is available AJ_InfoPrintf(("AJ_Net_Recv(): millis %d, Last_call %d timeout %d Avail: %d\n", millis(), Recv_lastCall, timeout, g_client.available())); if (g_client.connected() && (millis() - Recv_lastCall >= timeout) && (g_client.available() == 0)) { AJ_InfoPrintf(("AJ_Net_Recv(): timeout. status=AJ_ERR_TIMEOUT\n")); return AJ_ERR_TIMEOUT; } if (g_client.connected()) { uint32_t askFor = rx; askFor -= M; AJ_InfoPrintf(("AJ_Net_Recv(): ask for: %d\n", askFor)); ret = g_client.read(buf->writePtr, askFor); AJ_InfoPrintf(("AJ_Net_Recv(): read(): ret %d askfor %d\n", ret, askFor)); if (askFor < ret) { AJ_InfoPrintf(("AJ_Net_Recv(): BUFFER OVERRUN: askFor=%u, ret=%u\n", askFor, ret)); } if (ret == -1) { AJ_ErrPrintf(("AJ_Net_Recv(): read() failed. status=AJ_ERR_READ\n")); status = AJ_ERR_READ; } else { AJ_InfoPrintf(("AJ_Net_Recv(): ret now %d\n", ret)); AJ_DumpBytes("Recv", buf->writePtr, ret); if (ret > askFor) { AJ_InfoPrintf(("AJ_Net_Recv(): new leftover %d\n", ret - askFor)); // now shove the extra into the stash memcpy(rxDataStash + rxLeftover, buf->writePtr + askFor, ret - askFor); rxLeftover += (ret - askFor); buf->writePtr += rx; } else { buf->writePtr += ret; } status = AJ_OK; } } return status; }
//****************** Recieve data for ModBusSlave **************** void MgsModbus::MbsRun() { //****************** Read from socket **************** WiFiClient client = MbServer.available(); if(client.available()) { delay(10); int i = 0; while(client.available()) { MbsByteArray[i] = client.read(); i++; } MbsFC = SetFC(MbsByteArray[7]); //Byte 7 of request is FC } int Start, WordDataLength, ByteDataLength, CoilDataLength, MessageLength; //****************** Read Coils (1 & 2) ********************** if(MbsFC == MB_FC_READ_COILS || MbsFC == MB_FC_READ_DISCRETE_INPUT) { Start = word(MbsByteArray[8],MbsByteArray[9]); CoilDataLength = word(MbsByteArray[10],MbsByteArray[11]); ByteDataLength = CoilDataLength / 8; if(ByteDataLength * 8 < CoilDataLength) ByteDataLength++; CoilDataLength = ByteDataLength * 8; MbsByteArray[5] = ByteDataLength + 3; //Number of bytes after this one. MbsByteArray[8] = ByteDataLength; //Number of bytes after this one (or number of bytes of data). for(int i = 0; i < ByteDataLength ; i++) { MbsByteArray[9 + i] = 0; // To get all remaining not written bits zero for(int j = 0; j < 8; j++) { bitWrite(MbsByteArray[9 + i], j, GetBit(Start + i * 8 + j)); } } MessageLength = ByteDataLength + 9; client.write((uint8_t*)MbsByteArray, MessageLength); MbsFC = MB_FC_NONE; } //****************** Read Registers (3 & 4) ****************** if(MbsFC == MB_FC_READ_REGISTERS || MbsFC == MB_FC_READ_INPUT_REGISTER) { Start = word(MbsByteArray[8],MbsByteArray[9]); WordDataLength = word(MbsByteArray[10],MbsByteArray[11]); ByteDataLength = WordDataLength * 2; MbsByteArray[5] = ByteDataLength + 3; //Number of bytes after this one. MbsByteArray[8] = ByteDataLength; //Number of bytes after this one (or number of bytes of data). for(int i = 0; i < WordDataLength; i++) { MbsByteArray[ 9 + i * 2] = highByte(MbData[Start + i]); MbsByteArray[10 + i * 2] = lowByte(MbData[Start + i]); } MessageLength = ByteDataLength + 9; client.write((uint8_t*)MbsByteArray, MessageLength); MbsFC = MB_FC_NONE; } //****************** Write Coil (5) ********************** if(MbsFC == MB_FC_WRITE_COIL) { Start = word(MbsByteArray[8],MbsByteArray[9]); if (word(MbsByteArray[10],MbsByteArray[11]) == 0xFF00){SetBit(Start,true);} if (word(MbsByteArray[10],MbsByteArray[11]) == 0x0000){SetBit(Start,false);} MbsByteArray[5] = 2; //Number of bytes after this one. MessageLength = 8; client.write((uint8_t*)MbsByteArray, MessageLength); MbsFC = MB_FC_NONE; } //****************** Write Register (6) ****************** if(MbsFC == MB_FC_WRITE_REGISTER) { Start = word(MbsByteArray[8],MbsByteArray[9]); MbData[Start] = word(MbsByteArray[10],MbsByteArray[11]); MbsByteArray[5] = 6; //Number of bytes after this one. MessageLength = 12; client.write((uint8_t*)MbsByteArray, MessageLength); MbsFC = MB_FC_NONE; } //****************** Write Multiple Coils (15) ********************** if(MbsFC == MB_FC_WRITE_MULTIPLE_COILS) { Start = word(MbsByteArray[8],MbsByteArray[9]); CoilDataLength = word(MbsByteArray[10],MbsByteArray[11]); MbsByteArray[5] = 6; for(int i = 0; i < CoilDataLength; i++) { SetBit(Start + i,bitRead(MbsByteArray[13 + (i/8)],i-((i/8)*8))); } MessageLength = 12; client.write((uint8_t*)MbsByteArray, MessageLength); MbsFC = MB_FC_NONE; } //****************** Write Multiple Registers (16) ****************** if(MbsFC == MB_FC_WRITE_MULTIPLE_REGISTERS) { Start = word(MbsByteArray[8],MbsByteArray[9]); WordDataLength = word(MbsByteArray[10],MbsByteArray[11]); ByteDataLength = WordDataLength * 2; MbsByteArray[5] = 6; for(int i = 0; i < WordDataLength; i++) { MbData[Start + i] = word(MbsByteArray[ 13 + i * 2],MbsByteArray[14 + i * 2]); } MessageLength = 12; client.write((uint8_t*)MbsByteArray, MessageLength); MbsFC = MB_FC_NONE; } }