void loop() {
unsigned long time = millis();
if (next < time) {
Ethernet.maintain();
next += send_delay;
if (next <= time)
next = time + 1;
Serial.println("request time !");
if (client.connected()) {
Serial.println("already connected");
} else {
Serial.print("connecting results : ");
Serial.println(client.connect("tarzan.info.emn.fr", 80));
}
int sent = client.println("GET /ping.php HTTP/1.1");
sent = client.println(F("Host: tarzan.info.emn.fr"));
client.println();
}
if (client.connected() && client.available() > 0) {
Serial.println("client received data : ");
unsigned char buffer[buff_size + 1];
while (client.available() > 0) {
int read = client.read(buffer, buff_size);
buffer[read] = '\0';
Serial.println(read);
}
}
if (radio.receiveDone()) {
}
}
void loop() {
// if there's incoming data from the net connection.
// send it out the serial port. This is for debugging
// purposes only:
if (client.available()) {
char c = client.read();
Serial.print(c);
}
// if there's no net connection, but there was one last time
// through the loop, then stop the client:
if (!client.connected() && lastConnected) {
Serial.println();
Serial.println("disconnecting.");
client.stop();
}
// if you're not connected, and ten seconds have passed since
// your last connection, then connect again and send data:
if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {
httpRequest();
}
// store the state of the connection for next time through
// the loop:
lastConnected = client.connected();
}
boolean readServerResponse() {
response = "";
char inBuf[RESPONSE_BUFFER];
//response.reserve(RESPONSE_BUFFER);
int bytesRead = 0;
if (client.connected()) {
delay(SERVER_WAIT_TIME);
Serial.println("awaiting response");
while (client.available()) {
char c = client.read();
Serial.print(c);
if (bytesRead < RESPONSE_BUFFER) inBuf[bytesRead] = c;
//else client.flush();
bytesRead++;
}
if (bytesRead > 0) {
response = inBuf;
Serial.println("Response Received");
//if (!client.connected()) client.stop();
return true;
}
}
return false;
}
void loop() {
// listen for incoming clients
EthernetClient client = server.available();
// we get a request
if (client) {
Serial.println(F("Client connected"));
// an http request ends with a blank line
boolean done = false;
while (client.connected() && !done) {
while (client.available () > 0 && !done) {
done = processIncomingByte (client.read ());
}
} // end of while client connected
// get ROV status values as json string
String rovStatus = getRovStatus();
// send a standard http response header
client.println(F("HTTP/1.1 200 OK"));
client.println(F("Content-Type: text/json"));
client.println(F("Connection: close")); // close after completion of the response
client.println(); // end of HTTP header
client.println(rovStatus);
// give the web browser time to receive the data
delay(10);
// close the connection:
client.stop();
Serial.println(F("Client disconnected"));
} // end of got a new client
} // end of loop
static void
extract_status_code(struct HTTPObject *h, EthernetClient client){
unsigned int k,multiplier,j;
j=0;
char c;
const byte STATUS_CODE_START_INDEX = 9;
const byte STATUS_CODE_END_INDEX = 11;
while(j<=STATUS_CODE_END_INDEX && client.connected()){
if(client.available()){
// We want to extract the 200 from "HTTP/1.1 200 OK". The
// status code starts at index 9 in the string and ends at 11
c = client.read();
if(j<STATUS_CODE_START_INDEX){
j++;
}
else if(j>=STATUS_CODE_START_INDEX && j<=STATUS_CODE_END_INDEX){
// code = 10^2 * str[9] + 10^1 * str[10] + 10^0 * str[11]
// Do ghetto exponentiation here.
multiplier = 1;
for(k = 1; k <= 2 - (j - STATUS_CODE_START_INDEX); k++){
multiplier *= 10;
}
// c - '0' => char to int
h->statusCode += (c - '0') * multiplier;
j++;
}
}
}
}
void loop() {
client = server.available();
if (client) {
while (client.connected()) {
if (client.available()) {
if (client.find("GET /")) {
//INICIAR CRONOMETRAGEM
if (client.find("setCron=")) {
int charReaded = client.read();
if(charReaded == 49){
iniciarCronometragem();
}
}
//RETORNA O TEMPO DESDE O INICIO
if (client.find("getCron=")) {
int charReaded = client.read();
if(charReaded == 49){
getCronometragem();
}
}
}
}
Serial.println();
break;
}
client.println(" HTTP/1.1 200 OK ");
}
// give the web browser time to receive the data
delay(1);
client.stop();
}
void Nimbits::createPoint(String pointName)
{
EthernetClient client;
if (client.connect(GOOGLE, PORT))
{
client.println(F("POST /service/point HTTP/1.1"));
String content;
// writeAuthParams(content);
content += "email=";
content += _ownerEmail;
if (_accessKey.length() > 0)
{
content += ("&key=");
content += (_accessKey);
}
content += "&action=create&point=";
content += (pointName);
client.println(F("Host:nimbits1.appspot.com"));
client.println(F("Connection:close"));
client.println(F("Cache-Control:max-age=0"));
client.print(F("Content-Type: application/x-www-form-urlencoded\n"));
client.print(F("Content-Length: "));
client.print(content.length());
client.print(F("\n\n"));
client.print(content);
while (client.connected() && !client.available())
{
delay(1); //waits for data
}
client.stop();
client.flush();
}
}
void loop() {
// listen for incoming clients
EthernetClient client = server.available();
if (client)
{
Serial.println("new client");
// an http request ends with a blank line
boolean currentLineIsBlank = true;
while (client.connected())
{
if (client.available())
{
char c = client.read();
Serial.write(c);
//*******************233333333333333333333333333333333333333333333*******
// if you've gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so you can send a reply
if (c == '\n' && currentLineIsBlank)
{
// send a standard http response header
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: textml");
client.println("Connection: close"); // the connection will be closed after completion of the response
client.println("Refresh: 5"); // refresh the page automatically every 5 sec
client.println();
client.println("<!DOCTYPE HTML>");
client.println("<html>");
// output the value of each analog input pin
for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
int sensorReading = analogRead(analogChannel);
client.print("analog input ");
client.print(analogChannel);
client.print(" is ");
client.print(sensorReading);
client.println("<br />");
}
client.println("<ml>");
break;
}
if (c == '\n')
{
// you're starting a new line
currentLineIsBlank = true;
}
else if (c != '\r')
{
// you've gotten a character on the current line
currentLineIsBlank = false;
}
}
}
// give the web browser time to receive the data
delay(1);
// close the connection:
client.stop();
Serial.println("client disconnected");
}
}
//---------------------------------------------------------------------
void loop()
{
waitForIncomingConnection();
while ( client_.connected() )
{
uint8_t cmd = 255;
if ( checkTcpTimeout() )
{
#ifdef DEBUG_SERIAL
Serial.println( "ERROR: connection timeout!" );
#endif
break;
}
cmd = getCommand();
if ( cmd == COMMAND_INVALID_COMMAND )
{
#ifdef DEBUG_SERIAL
Serial.print( "ERROR: invalid command received: ");
Serial.println( cmd );
#endif
break;
}
processCommand( cmd );
}
terminateConnection();
}
void getData(char *dst)
{
Serial.println("Trying to grab data from server:");
// from the server, read them and print them:
int i = 0;
while (!client.available());
while (client.available()) {
char c = client.read();
Serial.print(c);
if (i < 10)
{
dst[i] = c;
//dst[i+1] = 0;
}
i++;
}
// if the server's disconnected, stop the client:
if (!client.connected()) {
Serial.println();
Serial.println("disconnecting.");
client.stop();
// do nothing forevermore:
while(true);
}
}
String GAE(String link) {
httpRequest(link);
delay(10000);
String readString = ""; //Reset string
while (client.available() > 0) {
char s = client.read();
//Serial.print(s); //Complete response w/ headers. For dev mode.
if (s== '\n') {
char c = client.read();
//Serial.print(c); //Parsed response. For dev mode.
if (c == '\r') {
while (client.connected()) {
char z = client.read();
readString += z;
}
}
}
}
client.stop();
return(readString);
}
void loopServer() {
EthernetClient client = server.available();
if (client) {
while (client.connected()) {
if (client.available()) {
char c = client.read();
//read char by char HTTP request
if (readString.length() < 100) {
//store characters to string
readString += c;
//Serial.print(c);
}
//if HTTP request has ended
if (c == '\n') {
///////////////
Serial.print(readString); //print to serial monitor for debuging
//now output HTML data header
client.println(F("HTTP/1.1 200 OK")); //send new page on browser request
client.println(F("Content-Type: text/html"));
client.println();
client.println(F("Ok"));
delay(1);
//stopping client
client.stop();
if (readString.indexOf("R1=1") > 0){
soldoRelays[0]->On();
// Serial.println(">>>>>>>>>>>>");
// Serial.println("R1=1");
}
if (readString.indexOf("R2=1") > 0){
soldoRelays[1]->On();
// Serial.println(">>>>>>>>>>>>");
// Serial.println("R2=1");
}
if (readString.indexOf("R1=0") > 0){
soldoRelays[0]->Off();
// Serial.println(">>>>>>>>>>>>");
// Serial.println("R1=0");
}
if (readString.indexOf("R2=0") > 0){
soldoRelays[1]->Off();
// Serial.println(">>>>>>>>>>>>");
// Serial.println("R2=0");
}
readString="";
}
}
}
}
}
void ProcessClientMessage(){
// listen for incoming clients
EthernetClient client = GetAvailableClient();
if (client)
{
// an http request ends with a blank line
boolean currentLineIsBlank = true;
while (client.connected())
{
if (client.available())
{
char c = client.read();
// if you've gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so you can send a reply
if (c == '\n' && currentLineIsBlank)
{
//Magnetic;Noise;Temperature;Vibration;Voltage
String data = "";
data += String(GetMagnetic());
data += ";";
data += String(GetTemperature());
data += ";";
data += String(GetVibration());
data += ";";
data += String(GetVoltage());
client.println(data);
break;
}
if (c == '\n') {
// you're starting a new line
currentLineIsBlank = true;
}
else if (c != '\r')
{
// you've gotten a character on the current line
currentLineIsBlank = false;
}
}
}
// give the web browser time to receive the data
delay(10);
// close the connection:
client.stop();
}
}
void LeweiTcpClient::listenServer()
{
EthernetClient clientWeb = server.available();
if (clientWeb) {
//Serial.println("new clientWeb");
// an http request ends with a blank line
boolean currentLineIsBlank = true;
String clientStr = "";
while (clientWeb.connected()) {
if (clientWeb.available()) {
char c = clientWeb.read();
clientStr += c;
//Serial.write(c);
// if you've gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so you can send a reply
if (c == '\n' && currentLineIsBlank) {
clientWeb.println("<html><body><form method='get'>");
clientWeb.print("KEY<input type='text' name='a' value='");
clientWeb.print(_userKey);
clientWeb.print("'>GW<input type='text' name='g' value='");
clientWeb.print(_gatewayNo);
clientWeb.println("'><input type='submit'>");
clientWeb.println("</form></body></html>");
break;
}
if (c == '\n') {
// you're starting a new line
currentLineIsBlank = true;
if(clientStr.indexOf(" /?a=")>0)
{
Serial.print(clientStr);
String userInfoStr = clientStr.substring(clientStr.indexOf(" /?a=")+5,clientStr.indexOf("&g="));
userInfoStr += clientStr.substring(clientStr.indexOf("&g=")+3,clientStr.indexOf(" HTTP/1.1"));
if(userInfoStr.length()>33)writeRom(userInfoStr);
Serial.println(userInfoStr);
}
//Serial.println(clientStr);
clientStr = "";
//checkFreeMem();
}
else if (c != '\r') {
// you've gotten a character on the current line
currentLineIsBlank = false;
}
}
}
// give the web browser time to receive the data
delay(1);
// close the connection:
clientWeb.stop();
clientWeb= NULL;
//Serial.println("clientWeb disonnected");
}
}
void CosmClient::updateFeed(uint32_t feedId, char datastreamId[], double dataToSend) {
if (_client.available()) {
char c = _client.read();
Serial.print(c);
}
if (!_client.connected() && lastConnected) {
Serial.println("disconnecting.\n");
_client.stop();
}
if (!_client.connected() && (millis() - _lastConnMillis > _interval)) {
sendData(feedId, datastreamId, dataToSend);
_lastConnMillis = millis();
}
lastConnected = _client.connected();
}
/*
* Read through all the headers of the HTTP Response stored in the client
*/
static void
skip_http_headers(EthernetClient client){
char c;
byte allHeadersRead = 0;
while(!allHeadersRead && client.connected()){
if(client.available()){
c = client.read();
allHeadersRead = finished_reading_headers(&c, client);
}
}
}
void extract_body(struct HTTPObject *h, EthernetClient client){
char c;
unsigned int bodyIdx = 0;
while(bodyIdx < h->bufSize - 1 && client.connected()){
if(client.available()){
c = client.read();
h->body[bodyIdx++] = c;
}
}
h->body[bodyIdx] = '\0';
h->bodyLength = bodyIdx;
}
void api_call_http_register_self(byte amsg_server[]) {
char path[ 30 ];
char host[ 30 ];
strcpy_P(path, msg_server_path);
strcpy_P(host, msg_server_host);
EthernetClient client;
Serial.print("HTTP opening connection to ");
Serial.println(host);
/*
if (!ether.dnsLookup(website))
Serial.println("DNS failed");
else
Serial.println("DNS resolution done");
ether.printIp("SRV IP:\t", ether.hisip);
*/
if (!client.connect(amsg_server, pgm_read_word(&msg_server_port))) {
Serial.println("HTTP failed");
return;
}
char d;
String netbuf = "GET ";
netbuf += path;
netbuf += " HTTP/1.0\nHost: ";
netbuf += host;
netbuf += "\nConnection: close\n\n\n";
Serial.print("HTTP connected to ... ");
char sockbuf[ netbuf.length() ];
netbuf.toCharArray(sockbuf, netbuf.length());
client.write(sockbuf);
delay(100);
while(client.connected()) {
while(client.available()) {
d = client.read();
if (d == '\n')
Serial.print("\r\n");
else
Serial.print(d);
}
}
client.stop();
Serial.println();
}
boolean put_handler(TinyWebServer& web_server) {
const char* length_str = web_server.get_header_value(PSTR("Content-Length"));
long length = atol(length_str);
uint32_t start_time = 0;
boolean watchdog_start = false;
char buffer_[512];
EthernetClient client = web_server.get_client();
if (put_handler_fn) {
(*put_handler_fn)(web_server, START, NULL, length);
}
uint32_t i;
for (i = 0; i < length && client.connected();) {
// int16_t size = read_chars(web_server, client, (uint8_t*)buffer, 64);
int16_t size = read_fast(web_server, client, (uint8_t*)buffer_, sizeof(buffer_));
if (!size) {
if (watchdog_start) {
if (millis() - start_time > 30000) {
// Exit if there has been zero data from connected client
// for more than 30 seconds.
#if DEBUG
Serial << F("TWS:There has been no data for >30 Sec.\n");
#endif
break;
}
} else {
// We have hit an empty buffer, start the watchdog.
start_time = millis();
watchdog_start = true;
}
continue;
}
i += size;
// Ensure we re-start the watchdog if we get ANY data input.
watchdog_start = false;
if (put_handler_fn) {
(*put_handler_fn)(web_server, WRITE, buffer_, size);
}
}
if (put_handler_fn) {
(*put_handler_fn)(web_server, END, NULL, 0);
}
client << F("HTTP/1.1 200 OK\r\n");
// web_server.send_error_code(200);
web_server.end_headers();
return true;
}
void loop() {
// read the analog sensor:
int sensorReading = analogRead(A0);
// convert the data to a String to send it:
String dataString = String(sensorReading);
// you can append multiple readings to this String if your
// pachube feed is set up to handle multiple values:
int otherSensorReading = analogRead(A1);
dataString += ",";
dataString += String(otherSensorReading);
// if there's incoming data from the net connection.
// send it out the serial port. This is for debugging
// purposes only:
if (client.available()) {
char c = client.read();
Serial.print(c);
}
// if there's no net connection, but there was one last time
// through the loop, then stop the client:
if (!client.connected() && lastConnected) {
Serial.println();
Serial.println("disconnecting.");
client.stop();
}
// if you're not connected, and ten seconds have passed since
// your last connection, then connect again and send data:
if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {
sendData(dataString);
}
// store the state of the connection for next time through
// the loop:
lastConnected = client.connected();
}
void ModbusIP::task() {
EthernetClient client = _server.available();
if (client) {
if (client.connected()) {
int i = 0;
while (client.available()){
_MBAP[i] = client.read();
i++;
if (i==7) break; //MBAP length has 7 bytes size
}
_len = _MBAP[4] << 8 | _MBAP[5];
_len--; // Do not count with last byte from MBAP
if (_MBAP[2] !=0 || _MBAP[3] !=0) return; //Not a MODBUSIP packet
if (_len > MODBUSIP_MAXFRAME) return; //Length is over MODBUSIP_MAXFRAME
_frame = (byte*) malloc(_len);
i = 0;
while (client.available()){
_frame[i] = client.read();
i++;
if (i==_len) break;
}
this->receivePDU(_frame);
if (_reply != MB_REPLY_OFF) {
//MBAP
_MBAP[4] = (_len+1) >> 8; //_len+1 for last byte from MBAP
_MBAP[5] = (_len+1) & 0x00FF;
byte sendbuffer[7 + _len];
for (i = 0 ; i < 7 ; i++) {
sendbuffer[i] = _MBAP[i];
}
//PDU Frame
for (i = 0 ; i < _len ; i++) {
sendbuffer[i+7] = _frame[i];
}
client.write(sendbuffer, _len + 7);
}
#ifndef TCP_KEEP_ALIVE
client.stop();
#endif
free(_frame);
_len = 0;
}
void sendData() {
request[0] = '?';
int sensorsRead = buildRequestString(soldoSensors, SOLDO_SENSORS_COUNT,
request + 1);
if (sensorsRead > 0) {
if (client.connect(serverIp, 80)) {
Serial.println("connecting...");
// send the HTTP PUT request:
client.print("GET /index.py");
client.print(request);
client.println(" HTTP/1.0");
client.println();
} else {
// if you couldn't make a connection:
Serial.println("connection failed");
Serial.println("disconnecting.");
client.stop();
}
int cc = 20000;
while (client.connected() && !client.available()) {
delay(1); //waits for data
if(cc--) break;
}
while (client.connected() || client.available()) { //connected or data available
char c = client.read();
//Serial.print(c);
}
Serial.println();
Serial.println("disconnecting.");
Serial.println("==================");
Serial.println();
client.stop();
}
}
String Nimbits::getFullResponse(EthernetClient client) {
char c;
String response;
while(client.connected() && !client.available()) delay(1);
while (client.available()) {
c = client.read();
response += c;
}
Serial.println(response);
int responseCode = getResponseCode(response);
return response;
}
bool
Twitter::query_time(void)
{
EthernetClient http;
if (!http.connect(ip, port))
{
println(PSTR("query_time: could not connect to server"));
return false;
}
http_print(&http, PSTR("HEAD "));
if (proxy)
{
http_print(&http, PSTR("http://"));
http_print(&http, server);
}
http_println(&http, PSTR("/ HTTP/1.1"));
http_print(&http, PSTR("Host: "));
http_print(&http, server);
http_newline(&http);
http_println(&http, PSTR("Connection: close"));
http_newline(&http);
while (http.connected())
{
if (!read_line(&http, buffer, buffer_len))
break;
if (buffer[0] == '\0')
break;
if (process_date_header(buffer))
break;
}
http.stop();
return basetime != 0L;
}
void loop()
{
// listen for incoming clients
EthernetClient client = server.available();
if (client) {
// an http request ends with a blank line
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
// if you've gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so you can send a reply
if (c == '\n' && currentLineIsBlank) {
// send a standard http response header
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println();
// output the value of each analog input pin
for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
client.print("analog input ");
client.print(analogChannel);
client.print(" is ");
client.print(analogRead(analogChannel));
client.println("<br />");
}
break;
}
if (c == '\n') {
// you're starting a new line
currentLineIsBlank = true;
}
else if (c != '\r') {
// you've gotten a character on the current line
currentLineIsBlank = false;
}
}
}
// give the web browser time to receive the data
delay(1);
// close the connection:
client.stop();
}
}
void loop() {
// if there are incoming bytes available
// from the server, read them and print them:
if (client.available()) {
char c = client.read();
Serial.print(c);
}
// if the server's disconnected, stop the client:
if (!client.connected()) {
Serial.println();
Serial.println("disconnecting.");
client.stop();
// do nothing forevermore:
while (true);
}
}
String Nimbits::recordValue(String point, float value)
{
EthernetClient client;
String content;
if (client.connect(GOOGLE, PORT))
{
client.println(F("POST /service/value HTTP/1.1"));
// writeAuthParams(content);
content += ("email=");
content += _ownerEmail;
if (_accessKey.length() > 0)
{
content += ("&key=");
content += (_accessKey);
}
char buffer[10];
dtostrf(value, 5, 5, buffer);
String str = buffer;
content += ("&value=");
content += (str);
content += ("&point=");
content += (point);
client.println(F("Host:nimbits1.appspot.com"));
client.println(F("Connection:close"));
client.println(F("Cache-Control:max-age=0"));
client.print(F("Content-Type: application/x-www-form-urlencoded\n"));
client.print(F("Content-Length: "));
client.print(content.length());
client.print(F("\n\n"));
client.print(content);
while (client.connected() && !client.available())
{
delay(1); //waits for data
}
client.stop();
client.flush();
}
return content;
}
void loop()
{
if (client.connected()) {
if (client.available()) {
// read incoming bytes:
char inChar = client.read();
// add incoming byte to end of line:
currentLine += inChar;
// if you get a newline, clear the line:
if (inChar == '\n') {
currentLine = "";
}
// if the current line ends with <text>, it will
// be followed by the tweet:
if ( currentLine.endsWith("<text>")) {
// tweet is beginning. Clear the tweet string:
readingTweet = true;
tweet = "";
}
// if you're currently reading the bytes of a tweet,
// add them to the tweet String:
if (readingTweet) {
if (inChar != '<') {
tweet += inChar;
}
else {
// if you got a "<" character,
// you've reached the end of the tweet:
readingTweet = false;
Serial.println(tweet);
// close the connection to the server:
client.stop();
}
}
}
}
else if (millis() - lastAttemptTime > requestInterval) {
// if you're not connected, and two minutes have passed since
// your last connection, then attempt to connect again:
connectToServer();
}
}
void DataServeriOS::WaitForRequest()
{
bufferSize = 0;
while (_client.connected()) {
if (_client.available()) {
char c = _client.read();
if (c == '\n')
{
_client.println("HTTP/1.1 200 OK\nContent-Type: application/json\n\n");
break;
}
else
if (bufferSize < bufferMax) {
buffer[bufferSize++] = c;
}
else
break;
}
}
}
void loop(){
if (dataLesen()==1) {
//QFF-Berechnung
x = ((temp + konst1)/(qfe/100)*exp(((temp+konst1+konst2)*11.5526-26821)/(temp+konst1+konst2-1060)));
qff = (qfe/100)*exp(konst2*10.5152/(x+temp+konst1+konst2));
//Messwerten abschicken
if (client.connect(serverName, 80)) {
//Serial.println("Verbunden ... sende ... fertig!");
// URL anrufen:
client.print("GET /upload.php?TEMP=");
client.print(temp);
client.print("&TAU=");
client.print(taupunkt);
client.print("&QFE=");
client.print(qfe/100, 1);
client.print("&QFF=");
client.print(qff,1);
client.print("&FEUCHTE=");
client.print(feuchte);
client.println("&key=root HTTP/1.0\n");
client.println("Host: localhost");
client.println("User-Agent: Arduino");
client.println();
client.stop();
}
if (!client.connected()) {
/*Serial.println();
Serial.println("disconnecting.");*/
client.stop();
}
delay(899500);
softReset();
/* else {
// 2. Worst-Case-Szenario
Serial.println("connection failed");
}*/
}
}