Android Device Type Updated

application-manager-new
ayyoob 10 years ago
parent be5e12deb9
commit 07bae69062

@ -0,0 +1,99 @@
#include "Arduinoboardwifi.h"
#include <Adafruit_CC3000.h>
#include <SPI.h>
Adafruit_CC3000 cc3000 = Adafruit_CC3000(ADAFRUIT_CC3000_CS, ADAFRUIT_CC3000_IRQ, ADAFRUIT_CC3000_VBAT,
SPI_CLOCK_DIVIDER); // you can change this clock speed
Adafruit_CC3000_Client pushClient;
Adafruit_CC3000_Client pollClient;
uint32_t sserver;
/**********************************************************************************************
0. Check with a sample Wifi code of the Adafruit_CC3000 library to ensure that the sheild is working
1. Set the ip of the server(byte array below) where the Web-Rest API for the FireAlarm is running
2. Check whether the "SERVICE_EPOINT" is correct in the 'FireAlarmWifiAgent.h' file
3. Check whether the "SERVICE_PORT" is the same (9763) for the server running. Change it if needed
4. Check whether the pins have been attached accordingly in the Arduino
5. Check whether all reqquired pins are added to the 'digitalPins' array
***********************************************************************************************/
byte server[4] = { 192, 168, 1, 101 };
String host, jsonPayLoad, replyMsg;
String responseMsg, subStrn;
void setup()
{
Serial.begin(9600);
Serial.println(F("Internal Temperature Sensor"));
pinMode(6, OUTPUT);
connectHttp();
setupResource();
}
void loop()
{
if (pushClient.connected() && pollClient.connected()) {
pushData();
delay(POLL_INTERVAL);
boolean valid = readControls();
responseMsg="";
} else {
if(DEBUG) {
Serial.println("client not found...");
Serial.println("disconnecting.");
}
pushClient.close();
pollClient.close();
cc3000.disconnect();
connectHttp();
}
delay(1000);
}
double getBoardTemp(void)
{
unsigned int wADC;
double t;
// The internal temperature has to be used
// with the internal reference of 1.1V.
// Channel 8 can not be selected with
// the analogRead function yet.
// Set the internal reference and mux.
ADMUX = (_BV(REFS1) | _BV(REFS0) | _BV(MUX3));
ADCSRA |= _BV(ADEN); // enable the ADC
delay(20); // wait for voltages to become stable.
ADCSRA |= _BV(ADSC); // Start the ADC
// Detect end-of-conversion
while (bit_is_set(ADCSRA,ADSC));
// Reading register "ADCW" takes care of how to read ADCL and ADCH.
wADC = ADCW;
// The offset of 324.31 could be wrong. It is just an indication.
t = (wADC - 324.31 ) / 1.22;
// The returned temperature is in degrees Celcius.
return (t);
}

@ -0,0 +1,39 @@
#ifndef ArduinoWifiAgent_H
#define ArduinoWifiAgent_H
#if (ARDUINO >= 100)
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
// These are the interrupt and control pins
#define ADAFRUIT_CC3000_IRQ 3 // MUST be an interrupt pin!
// These can be any two pins
#define ADAFRUIT_CC3000_VBAT 5
#define ADAFRUIT_CC3000_CS 10
#define WLAN_SSID "SSID" // cannot be longer than 32 characters!
#define WLAN_PASS "Password"
#define WLAN_SECURITY WLAN_SEC_WPA
// Security can be WLAN_SEC_UNSEC, WLAN_SEC_WEP, WLAN_SEC_WPA or WLAN_SEC_WPA2
#define IDLE_TIMEOUT_MS 3000
#define DEVICE_OWNER "${DEVICE_OWNER}"
#define DEVICE_ID "${DEVICE_ID}"
#define DEVICE_TOKEN "${DEVICE_TOKEN}"
#define SERVICE_PORT 9763
#define SERVICE_EPOINT "/arduino/controller/"
#define POLL_INTERVAL 1000
#define DEBUG false
#define CON_DEBUG true
#endif

@ -1,42 +1,97 @@
byte mac[6] = { 0x90, 0xA2, 0xDA, 0x0D, 0x30, 0xD7}; //mac - 90a2da0d30d7 /**********************************************************************************************
byte dns2[] = { 8, 8, 8, 8 }; Use the below variables when required to set a static IP for the WifiSheild
byte subnet[] = { 255, 255, 255, 0 }; ***********************************************************************************************/
byte gateway[] = { 192, 168, 1, 1 }; // byte dns2[] = { 8, 8, 8, 8 };
// byte subnet[] = { 255, 255, 255, 0 };
byte deviceIP[4] = { 192, 168, 1, 219 }; // byte gateway[] = { 10, 100, 9, 254 };
byte server[4] = { 192, 168, 1, 216 }; // byte deviceIP[4] = { 10, 100, 9, 9 };
// byte gateway[] = { 192, 168, 1, 1 };
// byte deviceIP[4] = { 192, 168, 1, 219 };
// uint32_t ip, ddns, ssubnet, ggateway;
// byte mac[6] = { 0xC0, 0x4A, 0x00, 0x1A, 0x08, 0xDA }; //mac - c0:4a:00:1a:08:da
// c0:4a:00:1a:03:f8
// b8:27:eb:88:37:7a
String connecting = "connecting.... "; String connecting = "connecting.... ";
void connectHttp() { void connectHttp() {
if(DEBUG) Serial.println("-------------------------------"); /* Initialise the module */
if(DEBUG) Serial.println(F("\nInitializing..."));
if (!cc3000.begin())
{
if(DEBUG) Serial.println(F("Couldn't begin()! Check your wiring?"));
while(1);
}
Ethernet.begin(mac, deviceIP, dns2, gateway, subnet); // if( cc3000.setMacAddress(mac) ) { // Set your own mac and print it to re-check
delay(2000); // uint8_t address[6];
// cc3000.getMacAddress(address);
// if(DEBUG){
// Serial.print(address[0], HEX); Serial.print(":");
// Serial.print(address[1], HEX); Serial.print(":");
// Serial.print(address[2], HEX); Serial.print(":");
// Serial.print(address[3], HEX); Serial.print(":");
// Serial.print(address[4], HEX); Serial.print(":");
// Serial.println(address[5], HEX);
// }
// }
/**********************************************************************************************
Only required if using static IP for the WifiSheild
***********************************************************************************************/
// ip = cc3000.IP2U32(deviceIP[0], deviceIP[1], deviceIP[2], deviceIP[3]);
// ddns = cc3000.IP2U32(dns2[0], dns2[1], dns2[2], dns2[3]);
// ssubnet = cc3000.IP2U32(subnet[0], subnet[1], subnet[2], subnet[3]);
// ggateway = cc3000.IP2U32(gateway[0], gateway[1], gateway[2], gateway[3]);
// cc3000.setStaticIPAddress(ip, ssubnet, ggateway, ddns); // required for setting static IP
/***********************************************************************************************/
sserver = cc3000.IP2U32(server[0], server[1], server[2], server[3]);
if(CON_DEBUG) {
Serial.print(F("\nAttempting to connect to "));
Serial.println(WLAN_SSID);
}
if(DEBUG) { if (!cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY)) {
Serial.print("My IP: "); if(CON_DEBUG) Serial.println(F("Failed!"));
Serial.println(Ethernet.localIP()); while(1);
} }
connecting += httpClient.connect(server, SERVICE_PORT); if(CON_DEBUG) Serial.println(F("Connected to Wifi network!"));
delay(2000);
if(DEBUG) Serial.println(connecting);
if (httpClient.connected()) { if(CON_DEBUG) Serial.println(F("Request DHCP"));
if(DEBUG) Serial.println("connected"); while (!cc3000.checkDHCP())
} else { {
if(DEBUG) Serial.println("connection failed"); delay(100); // ToDo: Insert a DHCP timeout!
}
while(!httpClient.connected()){ /* Display the IP address DNS, Gateway, etc. */
if(DEBUG) Serial.println("retrying to connect......"); while (! displayConnectionDetails()) {
httpClient.connect(server, SERVICE_PORT); delay(1000);
delay(2000);
} }
if(DEBUG) Serial.println("connected to server!"); pushClient = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT
if (pushClient.connected()) {
if(CON_DEBUG) Serial.println("PushClient Connected to server");
} else {
cc3000.disconnect();
if(CON_DEBUG) Serial.println(F("PushClient Connection failed"));
} }
if(DEBUG) Serial.println("-------------------------------");
pollClient = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT
if (pollClient.connected()) {
if(CON_DEBUG) Serial.println("PollClient Connected to server");
} else {
cc3000.disconnect();
if(CON_DEBUG) Serial.println(F("PollClient Connection failed"));
}
if(CON_DEBUG) Serial.println(F("-------------------------------------"));
} }
@ -47,11 +102,11 @@ void setupResource(){
host = "Host: " + hostIP + ":" + port; host = "Host: " + hostIP + ":" + port;
if(DEBUG) Serial.println(host); if(DEBUG) Serial.println(host);
jsonPayLoad = String(OWNER_JSON); jsonPayLoad = "{\"owner\":\"";
jsonPayLoad += String(DEVICE_OWNER); jsonPayLoad += String(DEVICE_OWNER);
jsonPayLoad += String(DEVICE_ID_JSON); jsonPayLoad += "\",\"deviceId\":\"";
jsonPayLoad += String(DEVICE_ID); jsonPayLoad += String(DEVICE_ID);
jsonPayLoad += String(REPLY_JSON); jsonPayLoad += "\",\"reply\":\"";
if(DEBUG) { if(DEBUG) {
Serial.print("JSON Payload: "); Serial.print("JSON Payload: ");
@ -60,18 +115,6 @@ void setupResource(){
} }
} }
String getMyIP(){
String myIP = "";
myIP = String(Ethernet.localIP()[0]);
for ( int index = 1; index < 4; index++) {
myIP += "." + String(Ethernet.localIP()[index]);
}
return myIP;
}
String getHostIP(byte server[4]){ String getHostIP(byte server[4]){
String hostIP = String(server[0]); String hostIP = String(server[0]);
@ -81,3 +124,27 @@ String getHostIP(byte server[4]){
return hostIP; return hostIP;
} }
bool displayConnectionDetails(void)
{
uint32_t ipAddress, netmask, gateway, dhcpserv, dnsserv;
if(!cc3000.getIPAddress(&ipAddress, &netmask, &gateway, &dhcpserv, &dnsserv))
{
if(DEBUG) Serial.println(F("Unable to retrieve the IP Address!\r\n"));
return false;
}
else
{
if(CON_DEBUG) {
Serial.print(F("\nIP Addr: ")); cc3000.printIPdotsRev(ipAddress);
Serial.print(F("\nNetmask: ")); cc3000.printIPdotsRev(netmask);
Serial.print(F("\nGateway: ")); cc3000.printIPdotsRev(gateway);
Serial.print(F("\nDHCPsrv: ")); cc3000.printIPdotsRev(dhcpserv);
Serial.print(F("\nDNSserv: ")); cc3000.printIPdotsRev(dnsserv);
Serial.println();
}
return true;
}
}

@ -1,48 +0,0 @@
#ifndef FireAlarmEthernetAgent_H
#define FireAlarmEthernetAgent_H
#if (ARDUINO >= 100)
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
#define HTTP_POST "POST"
#define HTTP_GET "GET"
#define HTTP_VERSION "HTTP/1.1"
#define HTTP_CONTENT_TYPE "Content-Type: application/json"
#define HTTP_CONTENT_LEN "Content-Length: "
#define DEVICE_OWNER "${DEVICE_OWNER}" //"Smeansbeer"
#define DEVICE_ID "${DEVICE_ID}" //"vbhenqyt85yq"
#define DEVICE_TOKEN "${DEVICE_TOKEN}"
#define PUSH_ALARM_DATA "pushalarmdata"
#define READ_CONTROLS "readcontrols/"
#define REPLY "reply"
#define OWNER_JSON "{\"owner\":\""
#define DEVICE_ID_JSON "\",\"deviceId\":\""
#define REPLY_JSON "\",\"replyMessage\":\""
#define TIME_JSON "\",\"time\":\""
#define KEY_JSON "\",\"key\":\""
#define VALUE_JSON "\",\"value\":\""
#define END_JSON "\"}"
#define SERVICE_PORT 9763
#define SERVICE_EPOINT "/firealarm/controller/"
// pushalarmdata - application/json - {"owner":"","deviceId":"","replyMessage":"","time":"","key":"","value":""}
// readcontrols/{owner}/{deviceId}
// reply - application/json - {"owner":"","deviceId":"","replyMessage":""}
#define TEMP_PIN 3
#define BULB_PIN 4
#define FAN_PIN 5
#define DEBUG false
#define POLL_INTERVAL 1000
#endif

@ -1,143 +0,0 @@
#include "FireAlarmEthernetAgent.h"
#include <Ethernet.h>
#include <SPI.h>
#include "dht.h"
/**********************************************************************************************
0. Check with a sample Ethernet code of the Ethernet library to ensure that the sheild is working
1. Set the ip of the server(byte array below) where the Web-Rest API for the FireAlarm is running
2. Check whether the "SERVICE_EPOINT" is correct in the 'FireAlarmWifiAgent.h' file
3. Check whether the "SERVICE_PORT" is the same (9763) for the server running. Change it if needed
4. Check whether the pins have been attached accordingly in the Arduino
5. Check whether all reqquired pins are added to the 'digitalPins' array
***********************************************************************************************/
int digitalPins[] = { TEMP_PIN, BULB_PIN, FAN_PIN };
int analogPins[] = { 0, 1, 2, 3, 4, 5 };
EthernetClient httpClient;
String host, jsonPayLoad, replyMsg;
void setup() {
if(DEBUG) Serial.begin(9600);
pinMode(BULB_PIN, OUTPUT);
pinMode(FAN_PIN, OUTPUT);
connectHttp();
setupResource();
}
void loop() {
if (httpClient.connected()) {
pushDigitalPinData();
// pushData(); // Use this method to batch all data together and send in one call
delay(POLL_INTERVAL);
String responseMsg = readControls();
int index = responseMsg.lastIndexOf(":");
int newLine = responseMsg.lastIndexOf("\n");
String subStrn = responseMsg.substring(index + 1);
if (subStrn.equals("IN")) {
responseMsg = responseMsg.substring(newLine + 1, index);
if (responseMsg.equals("TEMPERATURE")) {
replyMsg = "Temperature is " + String(getTemperature()) + "C.";
reply(replyMsg);
} else if (responseMsg.equals("BULB")) {
replyMsg = "Bulb was switched " + switchBulb();
} else if (responseMsg.equals("FAN")) {
replyMsg = "Bulb was switched " + switchFan();
}
}
} else {
if(DEBUG) {
Serial.println("client not found...");
Serial.println("disconnecting.");
}
httpClient.stop();
connectHttp();
}
}
String getDataType(int pin){
switch(pin){
case TEMP_PIN:
return "Temperature";
case BULB_PIN:
return "Bulb";
case FAN_PIN:
return "Fan";
default:
return String(pin);
}
}
String switchBulb() {
if (digitalRead(BULB_PIN) == HIGH) {
digitalWrite(BULB_PIN, LOW);
return "OFF";
} else {
digitalWrite(BULB_PIN, HIGH);
return "ON";
}
}
String switchFan() {
if (digitalRead(FAN_PIN) == HIGH) {
digitalWrite(FAN_PIN, LOW);
return "OFF";
} else {
digitalWrite(FAN_PIN, HIGH);
return "ON";
}
}
double getTemperature(){
dht DHT;
if(DEBUG) {
Serial.println("-------------------------------");
Serial.println("Type,\tstatus,\tHumidity (%),\tTemperature (C)");
Serial.print("DHT11, \t");
}
int chk = DHT.read11(TEMP_PIN);
switch (chk)
{
case DHTLIB_OK:
if(DEBUG) Serial.print("OK,\t");
break;
case DHTLIB_ERROR_CHECKSUM:
if(DEBUG) Serial.print("Checksum error,\t");
break;
case DHTLIB_ERROR_TIMEOUT:
if(DEBUG) Serial.print("Time out error,\t");
break;
case DHTLIB_ERROR_CONNECT:
if(DEBUG) Serial.print("Connect error,\t");
break;
case DHTLIB_ERROR_ACK_L:
if(DEBUG) Serial.print("Ack Low error,\t");
break;
case DHTLIB_ERROR_ACK_H:
if(DEBUG) Serial.print("Ack High error,\t");
break;
default:
if(DEBUG) Serial.print("Unknown error,\t");
break;
}
// DISPLAY DATA
if(DEBUG) {
Serial.print("\t");
Serial.print(DHT.temperature, 1);
Serial.print(",\t\t");
Serial.println(DHT.humidity, 1);
Serial.println("-------------------------------");
}
return DHT.temperature;
}

@ -1,77 +1,53 @@
String readControls() { boolean readControls() {
String responseMsg; // String responseMsg;
String resource = " " + String(SERVICE_EPOINT) + String(READ_CONTROLS) + String(DEVICE_OWNER) + "/" + String(DEVICE_ID) + " ";
pollClient.fastrprint(F("GET "));
httpClient.print(HTTP_GET); pollClient.fastrprint(SERVICE_EPOINT);
httpClient.print(resource); pollClient.fastrprint(F("readcontrols/"));
httpClient.println(HTTP_VERSION); pollClient.fastrprint(DEVICE_ID);
httpClient.println(host); pollClient.fastrprint(F("?owner="));
httpClient.println(); pollClient.fastrprint(DEVICE_OWNER);
pollClient.fastrprint(F(" HTTP/1.1")); pollClient.fastrprint(F("\n"));
if(DEBUG) { pollClient.fastrprint(host.c_str()); pollClient.fastrprint(F("\n"));
Serial.print(HTTP_GET); pollClient.println();
Serial.print(resource);
Serial.println(HTTP_VERSION);
Serial.println(host);
Serial.println();
}
delay(1000); delay(1000);
while (httpClient.available()) {
char response = httpClient.read(); while (pollClient.available()) {
char response = pollClient.read();
responseMsg += response; responseMsg += response;
} }
int index = responseMsg.lastIndexOf(":");
int newLine = responseMsg.lastIndexOf("\n");
subStrn = responseMsg.substring(index + 1);
responseMsg = responseMsg.substring(newLine + 1, index);
if(DEBUG) { if(DEBUG) {
Serial.print(responseMsg); Serial.print(responseMsg);
Serial.println(); Serial.println();
Serial.println("-------------------------------"); Serial.println("-------------------------------");
} }
delay(1000);
return responseMsg;
}
void reply(String replyMsg) { if (subStrn.equals("ON")) {
String resource = " " + String(SERVICE_EPOINT) + String(REPLY) + " "; Serial.println("ITS ON");
String payLoad = jsonPayLoad + replyMsg + String(END_JSON); //digitalWrite(13, HIGH);
digitalWrite(6, HIGH);
httpClient.print(HTTP_POST); } else if (subStrn.equals("OFF")){
httpClient.print(resource);
httpClient.println(HTTP_VERSION);
httpClient.println(host);
httpClient.println(HTTP_CONTENT_TYPE);
httpClient.print(HTTP_CONTENT_LEN);
httpClient.println(payLoad.length());
httpClient.println();
httpClient.println(payLoad);
httpClient.println();
if(DEBUG) { Serial.println("ITS OFF");
Serial.print(HTTP_POST); //digitalWrite(13, LOW);
Serial.print(resource); digitalWrite(6, LOW);
Serial.println(HTTP_VERSION);
Serial.println(host);
Serial.println(HTTP_CONTENT_TYPE);
Serial.print(HTTP_CONTENT_LEN);
Serial.println(payLoad.length());
Serial.println();
Serial.println(payLoad);
Serial.println();
}
delay(1000);
while (httpClient.available()) {
char response = httpClient.read();
if(DEBUG) Serial.print(response);
} }
if (responseMsg.equals("BULB")) {
if(DEBUG) { return false;
Serial.println();
Serial.println("-------------------------------");
} }
delay(1000);
return true;
} }

@ -6,193 +6,80 @@
***********************************************************************************************/ ***********************************************************************************************/
void pushData(){ void pushData(){
String resource = " " + String(SERVICE_EPOINT) + String(PUSH_ALARM_DATA) + " "; String payLoad = "Data";
String payLoad = jsonPayLoad + "DigitalPinData"; payLoad = payLoad + "\",\"value\":\"";
payLoad = payLoad + String(TIME_JSON) + "9999";
payLoad = payLoad + String(KEY_JSON) + "Data";
payLoad += String(VALUE_JSON);
for ( int pin = 0; pin < (sizeof(digitalPins)/sizeof(int)); pin++) {
if ( digitalPins[pin] == TEMP_PIN ) {
payLoad += String(getTemperature());
} else if ( digitalRead(digitalPins[pin]) == HIGH ) {
payLoad += "ON";
} else if ( digitalRead(digitalPins[pin]) == LOW ) {
payLoad += "OFF";
}
if ( ((sizeof(digitalPins)/sizeof(int)) - 1) != pin ) {
payLoad += "-";
}
}
payLoad = payLoad + String(END_JSON); payLoad+=getBoardTemp();
if(DEBUG) Serial.println(payLoad);
httpClient.print(HTTP_POST); payLoad += "\"}";
httpClient.print(resource);
httpClient.println(HTTP_VERSION);
httpClient.println(host);
httpClient.println(HTTP_CONTENT_TYPE);
httpClient.print(HTTP_CONTENT_LEN);
httpClient.println(payLoad.length());
httpClient.println();
httpClient.println(payLoad);
httpClient.println();
if(DEBUG) { pushClient.fastrprint(F("POST "));
Serial.print(HTTP_POST); pushClient.fastrprint(SERVICE_EPOINT); pushClient.fastrprint(F("pushdata"));
Serial.print(resource); pushClient.fastrprint(F(" HTTP/1.1")); pushClient.fastrprint(F("\n"));
Serial.println(HTTP_VERSION); pushClient.fastrprint(host.c_str()); pushClient.fastrprint(F("\n"));
Serial.println(host); pushClient.fastrprint(F("Content-Type: application/json")); pushClient.fastrprint(F("\n"));
Serial.println(HTTP_CONTENT_TYPE); pushClient.fastrprint(F("Content-Length: "));
Serial.print(HTTP_CONTENT_LEN);
Serial.println(payLoad.length());
Serial.println();
Serial.println(payLoad);
Serial.println();
}
delay(1000); int payLength = jsonPayLoad.length() + payLoad.length();
while (httpClient.available()) { pushClient.fastrprint(String(payLength).c_str()); pushClient.fastrprint(F("\n"));
char response = httpClient.read(); pushClient.fastrprint(F("\n"));
if(DEBUG) Serial.print(response);
}
if(DEBUG) { if(DEBUG) {
Serial.print("POST ");
Serial.print(SERVICE_EPOINT); Serial.print("pushdata");
Serial.print(" HTTP/1.1"); Serial.println();
Serial.print(host); Serial.println();
Serial.print("Content-Type: application/json"); Serial.println();
Serial.print("Content-Length: ");
Serial.print(payLength); Serial.println();
Serial.println(); Serial.println();
Serial.println("-------------------------------");
} }
delay(1000);
}
/********************************************************************************************** int chunkSize = 50;
This method will traverse the array of digital pins and publish the data from the those pins.
It differs from the above method such that the pin data is published one after the other in
seperate calls to the server
***********************************************************************************************/
void pushDigitalPinData(){
for ( int pin = 0; pin < (sizeof(digitalPins)/sizeof(int)); pin++) {
String resource = " " + String(SERVICE_EPOINT) + String(PUSH_ALARM_DATA) + " ";
String payLoad = jsonPayLoad + "DigitalPinData"; for (int i = 0; i < jsonPayLoad.length(); i++) {
payLoad = payLoad + String(TIME_JSON) + "9999"; if ( (i+1)*chunkSize > jsonPayLoad.length()) {
payLoad = payLoad + String(KEY_JSON) + getDataType(digitalPins[pin]); pushClient.print(jsonPayLoad.substring(i*chunkSize, jsonPayLoad.length()));
payLoad += String(VALUE_JSON); if(DEBUG) Serial.print(jsonPayLoad.substring(i*chunkSize, jsonPayLoad.length()));
i = jsonPayLoad.length();
} else {
if ( digitalPins[pin] == TEMP_PIN ) { pushClient.print(jsonPayLoad.substring(i*chunkSize, (i+1)*chunkSize));
payLoad += String(getTemperature()); if(DEBUG) Serial.print(jsonPayLoad.substring(i*chunkSize, (i+1)*chunkSize));
} else if ( digitalRead(digitalPins[pin]) == HIGH ) {
payLoad += "ON";
} else if ( digitalRead(digitalPins[pin]) == LOW ) {
payLoad += "OFF";
}
payLoad = payLoad + String(END_JSON);
if(DEBUG) Serial.println(payLoad);
httpClient.print(HTTP_POST);
httpClient.print(resource);
httpClient.println(HTTP_VERSION);
httpClient.println(host);
httpClient.println(HTTP_CONTENT_TYPE);
httpClient.print(HTTP_CONTENT_LEN);
httpClient.println(payLoad.length());
httpClient.println();
httpClient.println(payLoad);
httpClient.println();
if(DEBUG) {
Serial.print(HTTP_POST);
Serial.print(resource);
Serial.println(HTTP_VERSION);
Serial.println(host);
Serial.println(HTTP_CONTENT_TYPE);
Serial.print(HTTP_CONTENT_LEN);
Serial.println(payLoad.length());
Serial.println();
Serial.println(payLoad);
Serial.println();
} }
delay(1000);
while (httpClient.available()) {
char response = httpClient.read();
if(DEBUG) Serial.print(response);
} }
if(DEBUG) { for (int i = 0; i < payLoad.length(); i++) {
Serial.println(); if ( (i+1)*chunkSize > payLoad.length()) {
Serial.println("-------------------------------"); pushClient.print(payLoad.substring(i*chunkSize, payLoad.length()));
if(DEBUG) Serial.print(payLoad.substring(i*chunkSize, payLoad.length()));
i = payLoad.length();
} else {
pushClient.print(payLoad.substring(i*chunkSize, (i+1)*chunkSize));
if(DEBUG) Serial.print(payLoad.substring(i*chunkSize, (i+1)*chunkSize));
} }
delay(1000);
} }
}
/**********************************************************************************************
Only required for cases of reading analog pin values.
An int Array of analog pins that needs to be read has to be initialised.
This method will traverse the array and publish the data from the selected pins
***********************************************************************************************/
void pushAnalogPinData(){ pushClient.fastrprint(F("\n"));
for ( int pin = 0; pin < (sizeof(analogPins)/sizeof(int)); pin++) { if(DEBUG) Serial.println();
String resource = " " + String(SERVICE_EPOINT) + String(PUSH_ALARM_DATA) + " ";
String payLoad = jsonPayLoad + "AnalogPinData";
payLoad = payLoad + String(TIME_JSON) + "9999";
payLoad = payLoad + String(KEY_JSON) + getDataType(analogPins[pin]);
payLoad = payLoad + String(VALUE_JSON) + analogRead(analogPins[pin]);
payLoad = payLoad + String(END_JSON);
if(DEBUG) Serial.println(payLoad);
httpClient.print(HTTP_POST);
httpClient.print(resource);
httpClient.println(HTTP_VERSION);
httpClient.println(host);
httpClient.println(HTTP_CONTENT_TYPE);
httpClient.print(HTTP_CONTENT_LEN);
httpClient.println(payLoad.length());
httpClient.println();
httpClient.println(payLoad);
httpClient.println();
if(DEBUG) {
Serial.print(HTTP_POST);
Serial.print(resource);
Serial.println(HTTP_VERSION);
Serial.println(host);
Serial.println(HTTP_CONTENT_TYPE);
Serial.print(HTTP_CONTENT_LEN);
Serial.println(payLoad.length());
Serial.println();
Serial.println(payLoad);
Serial.println();
}
delay(1000); delay(1000);
while (httpClient.available()) {
char response = httpClient.read(); while (pushClient.available()) {
char response = pushClient.read();
if(DEBUG) Serial.print(response); if(DEBUG) Serial.print(response);
} }
if(DEBUG) { if(DEBUG) {
Serial.println(); Serial.println();
Serial.println("-------------------------------"); Serial.println("-------------------------------");
} }
delay(1000);
} payLoad = "";
} }

@ -1,2 +1,2 @@
templates=FireAlarmEthernetAgent.h templates=Arduinoboardwifi.h
zipfilename=Arduino.zip zipfilename=ArduinoBoardSketch.zip
Loading…
Cancel
Save