application-manager-new
Rasika 10 years ago
commit 98dde99da1

@ -343,6 +343,33 @@
</configuration> </configuration>
</execution> </execution>
<execution>
<!-- Creating IOT Management schema -->
<id>create-android-schema</id>
<phase>package</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo message="########### Device Cloud H2 Schema ###########" />
<property name="db.dir" value="target/wso2carbon-core-${carbon.kernel.version}/repository/database" />
<property name="userid" value="wso2carbon" />
<property name="password" value="wso2carbon" />
<property name="dbURL" value="jdbc:h2:file:${basedir}/${db.dir}/AndroidDM_DB;DB_CLOSE_ON_EXIT=FALSE" />
<sql driver="org.h2.Driver" url="${dbURL}" userid="${userid}" password="${password}" autocommit="true" onerror="continue">
<classpath refid="maven.dependency.classpath" />
<classpath refid="maven.compile.classpath" />
<classpath refid="maven.runtime.classpath" />
<fileset file="${basedir}/../p2-profile-gen/target/wso2carbon-core-${carbon.kernel.version}/dbscripts/cdm/plugins/h2_android.sql" />
</sql>
<echo message="##################### END ####################" />
</tasks>
</configuration>
</execution>
<execution> <execution>
<!-- Creating IOT Management schema --> <!-- Creating IOT Management schema -->
<id>create-raspberrypi-schema</id> <id>create-raspberrypi-schema</id>

@ -280,6 +280,7 @@
<include>devicecloud.war</include> <include>devicecloud.war</include>
<include>firealarm.war</include> <include>firealarm.war</include>
<include>arduino.war</include> <include>arduino.war</include>
<include>android.war</include>
<include>sensebot.war</include> <include>sensebot.war</include>
<include>raspberrypi.war</include> <include>raspberrypi.war</include>
<include>digitaldisplay.war</include> <include>digitaldisplay.war</include>

@ -140,6 +140,27 @@
</definition> </definition>
</datasource> </datasource>
<datasource>
<name>AndroidDM_DS</name>
<description>The datasource used for Android database</description>
<jndiConfig>
<name>jdbc/AndroidDM_DB</name>
</jndiConfig>
<definition type="RDBMS">
<configuration>
<url>jdbc:h2:repository/database/AndroidDM_DB;DB_CLOSE_ON_EXIT=FALSE</url>
<username>wso2carbon</username>
<password>wso2carbon</password>
<driverClassName>org.h2.Driver</driverClassName>
<maxActive>50</maxActive>
<maxWait>60000</maxWait>
<testOnBorrow>true</testOnBorrow>
<validationQuery>SELECT 1</validationQuery>
<validationInterval>30000</validationInterval>
</configuration>
</definition>
</datasource>
<datasource> <datasource>
<name>SensebotDM_DS</name> <name>SensebotDM_DS</name>
<description>The datasource used for Sensebot database</description> <description>The datasource used for Sensebot database</description>

@ -0,0 +1,47 @@
#ifndef ArduinoWifiAgent_H
#define ArduinoWifiAgent_H
#include "Arduino.h"
// 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 PUSH_INTERVAL 10000
#define DEBUG true
#define CON_DEBUG true
byte server[4] = { 192, 168, 1, 101 };
String host, jsonPayLoad, replyMsg;
String responseMsg, subStrn;
double cpuTemperature =0;
static unsigned long pushTimestamp = 0;
static unsigned long pollTimestamp = 0;
#endif

@ -1,99 +1,56 @@
#include "Arduinoboardwifi.h" #include "ArduinoBoardSketch.h"
#include <Adafruit_CC3000.h> #include <Adafruit_CC3000.h>
#include <SPI.h> #include <SPI.h>
#include <avr/wdt.h>
Adafruit_CC3000 cc3000 = Adafruit_CC3000(ADAFRUIT_CC3000_CS, ADAFRUIT_CC3000_IRQ, ADAFRUIT_CC3000_VBAT, Adafruit_CC3000 cc3000 = Adafruit_CC3000(ADAFRUIT_CC3000_CS, ADAFRUIT_CC3000_IRQ, ADAFRUIT_CC3000_VBAT,
SPI_CLOCK_DIVIDER); // you can change this clock speed SPI_CLOCK_DIVIDER); // you can change this clock speed
Adafruit_CC3000_Client pushClient; Adafruit_CC3000_Client client;
Adafruit_CC3000_Client pollClient;
uint32_t sserver; 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() void setup()
{ {
Serial.begin(9600); Serial.begin(9600);
Serial.println(F("Internal Temperature Sensor"));
Serial.println(F("Internal Temperature Sensor")); pinMode(6, OUTPUT);
pinMode(6, OUTPUT); connectHttp();
connectHttp(); setupResource();
setupResource(); wdt_enable(WDTO_8S);
} }
void loop() void loop()
{ {
while( !cc3000.checkConnected() ){
connectHttp();
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(); cpuTemperature=getBoardTemp();
pollClient.close();
cc3000.disconnect();
connectHttp();
}
delay(1000);
}
if(millis() - pushTimestamp > PUSH_INTERVAL){
while (!client.connected()) {
setupClient();
}
pushData();
pushTimestamp = millis();
}
double getBoardTemp(void) //Serial.println("PUSHED");
{
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 if(millis() - pollTimestamp > POLL_INTERVAL){
while (bit_is_set(ADCSRA,ADSC)); while (!client.connected()) {
setupClient();
}
readControls();
// Reading register "ADCW" takes care of how to read ADCL and ADCH. pollTimestamp = millis();
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. //Serial.println("LOOPING");
return (t); wdt_reset();
} }

@ -1,39 +0,0 @@
#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,6 +1,7 @@
/********************************************************************************************** #include "ArduinoBoardSketch.h"
Use the below variables when required to set a static IP for the WifiSheild /**********************************************************************************************
***********************************************************************************************/ Use the below variables when required to set a static IP for the WifiSheild
***********************************************************************************************/
// byte dns2[] = { 8, 8, 8, 8 }; // byte dns2[] = { 8, 8, 8, 8 };
// byte subnet[] = { 255, 255, 255, 0 }; // byte subnet[] = { 255, 255, 255, 0 };
// byte gateway[] = { 10, 100, 9, 254 }; // byte gateway[] = { 10, 100, 9, 254 };
@ -11,140 +12,146 @@
// uint32_t ip, ddns, ssubnet, ggateway; // uint32_t ip, ddns, ssubnet, ggateway;
// byte mac[6] = { 0xC0, 0x4A, 0x00, 0x1A, 0x08, 0xDA }; //mac - c0:4a:00:1a:08:da // byte mac[6] = { 0xC0, 0x4A, 0x00, 0x1A, 0x08, 0xDA }; //mac - c0:4a:00:1a:08:da
// c0:4a:00:1a:03:f8 // c0:4a:00:1a:03:f8
// b8:27:eb:88:37:7a // b8:27:eb:88:37:7a
String connecting = "connecting.... "; String connecting = "connecting.... ";
void connectHttp() { void connectHttp() {
/* Initialise the module */ /* Initialise the module */
if(DEBUG) Serial.println(F("\nInitializing...")); if(DEBUG) Serial.println(F("\nInitializing..."));
if (!cc3000.begin()) if (!cc3000.begin())
{ {
if(DEBUG) Serial.println(F("Couldn't begin()! Check your wiring?")); if(DEBUG) Serial.println(F("Couldn't begin()! Check your wiring?"));
while(1); while(1);
} }
// if( cc3000.setMacAddress(mac) ) { // Set your own mac and print it to re-check // if( cc3000.setMacAddress(mac) ) { // Set your own mac and print it to re-check
// uint8_t address[6]; // uint8_t address[6];
// cc3000.getMacAddress(address); // cc3000.getMacAddress(address);
// if(DEBUG){ // if(DEBUG){
// Serial.print(address[0], HEX); Serial.print(":"); // Serial.print(address[0], HEX); Serial.print(":");
// Serial.print(address[1], HEX); Serial.print(":"); // Serial.print(address[1], HEX); Serial.print(":");
// Serial.print(address[2], HEX); Serial.print(":"); // Serial.print(address[2], HEX); Serial.print(":");
// Serial.print(address[3], HEX); Serial.print(":"); // Serial.print(address[3], HEX); Serial.print(":");
// Serial.print(address[4], HEX); Serial.print(":"); // Serial.print(address[4], HEX); Serial.print(":");
// Serial.println(address[5], HEX); // Serial.println(address[5], HEX);
// } // }
// } // }
/********************************************************************************************** /**********************************************************************************************
Only required if using static IP for the WifiSheild Only required if using static IP for the WifiSheild
***********************************************************************************************/ ***********************************************************************************************/
// ip = cc3000.IP2U32(deviceIP[0], deviceIP[1], deviceIP[2], deviceIP[3]); // ip = cc3000.IP2U32(deviceIP[0], deviceIP[1], deviceIP[2], deviceIP[3]);
// ddns = cc3000.IP2U32(dns2[0], dns2[1], dns2[2], dns2[3]); // ddns = cc3000.IP2U32(dns2[0], dns2[1], dns2[2], dns2[3]);
// ssubnet = cc3000.IP2U32(subnet[0], subnet[1], subnet[2], subnet[3]); // ssubnet = cc3000.IP2U32(subnet[0], subnet[1], subnet[2], subnet[3]);
// ggateway = cc3000.IP2U32(gateway[0], gateway[1], gateway[2], gateway[3]); // ggateway = cc3000.IP2U32(gateway[0], gateway[1], gateway[2], gateway[3]);
// cc3000.setStaticIPAddress(ip, ssubnet, ggateway, ddns); // required for setting static IP // cc3000.setStaticIPAddress(ip, ssubnet, ggateway, ddns); // required for setting static IP
/***********************************************************************************************/ /***********************************************************************************************/
sserver = cc3000.IP2U32(server[0], server[1], server[2], server[3]); sserver = cc3000.IP2U32(server[0], server[1], server[2], server[3]);
if(CON_DEBUG) { if(CON_DEBUG) {
Serial.print(F("\nAttempting to connect to ")); Serial.print(F("\nAttempting to connect to "));
Serial.println(WLAN_SSID); Serial.println(WLAN_SSID);
} }
if (!cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY)) { if (!cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY)) {
if(CON_DEBUG) Serial.println(F("Failed!")); if(CON_DEBUG) Serial.println(F("Failed!"));
while(1); while(1);
} }
if(CON_DEBUG) Serial.println(F("Connected to Wifi network!")); if(CON_DEBUG) Serial.println(F("Connected to Wifi network!"));
if(CON_DEBUG) Serial.println(F("Request DHCP")); if(CON_DEBUG) Serial.println(F("Request DHCP"));
while (!cc3000.checkDHCP()) while (!cc3000.checkDHCP())
{ {
delay(100); // ToDo: Insert a DHCP timeout! delay(100); // ToDo: Insert a DHCP timeout!
} }
/* Display the IP address DNS, Gateway, etc. */ /* Display the IP address DNS, Gateway, etc. */
while (! displayConnectionDetails()) { while (! displayConnectionDetails()) {
delay(1000); delay(1000);
} }
pushClient = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT client = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT
if (pushClient.connected()) { if (client.connected()) {
if(CON_DEBUG) Serial.println("PushClient Connected to server"); if(CON_DEBUG) Serial.println("client Connected to server");
} else { } else {
cc3000.disconnect(); if(CON_DEBUG) Serial.println(F("client Connection failed"));
if(CON_DEBUG) Serial.println(F("PushClient Connection failed")); }
}
pollClient = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT
if (pollClient.connected()) { if(CON_DEBUG) Serial.println(F("-------------------------------------"));
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("-------------------------------------"));
} }
void setupResource(){ void setupResource(){
String hostIP = getHostIP(server); String hostIP = getHostIP(server);
String port = String(SERVICE_PORT); String port = String(SERVICE_PORT);
host = "Host: " + hostIP + ":" + port; host = "Host: " + hostIP + ":" + port;
if(DEBUG) Serial.println(host); if(DEBUG) Serial.println(host);
jsonPayLoad = "{\"owner\":\""; jsonPayLoad = "{\"owner\":\"";
jsonPayLoad += String(DEVICE_OWNER); jsonPayLoad += String(DEVICE_OWNER);
jsonPayLoad += "\",\"deviceId\":\""; jsonPayLoad += "\",\"deviceId\":\"";
jsonPayLoad += String(DEVICE_ID); jsonPayLoad += String(DEVICE_ID);
jsonPayLoad += "\",\"reply\":\""; jsonPayLoad += "\",\"reply\":\"";
if(DEBUG) { if(DEBUG) {
Serial.print("JSON Payload: "); Serial.print("JSON Payload: ");
Serial.println(jsonPayLoad); Serial.println(jsonPayLoad);
Serial.println("-------------------------------"); Serial.println("-------------------------------");
} }
} }
String getHostIP(byte server[4]){ String getHostIP(byte server[4]){
String hostIP = String(server[0]); String hostIP = String(server[0]);
for ( int index = 1; index < 4; index++) { for ( int index = 1; index < 4; index++) {
hostIP += "." + String(server[index]); hostIP += "." + String(server[index]);
} }
return hostIP; return hostIP;
} }
bool displayConnectionDetails(void) bool displayConnectionDetails(void)
{ {
uint32_t ipAddress, netmask, gateway, dhcpserv, dnsserv; uint32_t ipAddress, netmask, gateway, dhcpserv, dnsserv;
if(!cc3000.getIPAddress(&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")); if(DEBUG) Serial.println(F("Unable to retrieve the IP Address!\r\n"));
return false; return false;
} }
else else
{ {
if(CON_DEBUG) { if(CON_DEBUG) {
Serial.print(F("\nIP Addr: ")); cc3000.printIPdotsRev(ipAddress); Serial.print(F("\nIP Addr: ")); cc3000.printIPdotsRev(ipAddress);
Serial.print(F("\nNetmask: ")); cc3000.printIPdotsRev(netmask); Serial.print(F("\nNetmask: ")); cc3000.printIPdotsRev(netmask);
Serial.print(F("\nGateway: ")); cc3000.printIPdotsRev(gateway); Serial.print(F("\nGateway: ")); cc3000.printIPdotsRev(gateway);
Serial.print(F("\nDHCPsrv: ")); cc3000.printIPdotsRev(dhcpserv); Serial.print(F("\nDHCPsrv: ")); cc3000.printIPdotsRev(dhcpserv);
Serial.print(F("\nDNSserv: ")); cc3000.printIPdotsRev(dnsserv); Serial.print(F("\nDNSserv: ")); cc3000.printIPdotsRev(dnsserv);
Serial.println(); Serial.println();
}
return true;
}
}
void setupClient(){
client = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT
if (client.connected()) {
if(CON_DEBUG) Serial.println("client Connected to server");
} else {
while( !cc3000.checkConnected() ){
connectHttp();
}
if(CON_DEBUG) Serial.println(F("client Connection failed"));
} }
return true;
}
} }

@ -1,55 +1,48 @@
boolean readControls() { #include "ArduinoBoardSketch.h"
// String responseMsg; void readControls() {
// String responseMsg;
pollClient.fastrprint(F("GET ")); client.fastrprint(F("GET "));
pollClient.fastrprint(SERVICE_EPOINT); client.fastrprint(SERVICE_EPOINT);
pollClient.fastrprint(F("readcontrols/")); client.fastrprint(F("readcontrols/"));
pollClient.fastrprint(DEVICE_ID); client.fastrprint(DEVICE_ID);
pollClient.fastrprint(F("?owner=")); client.fastrprint(F("?owner="));
pollClient.fastrprint(DEVICE_OWNER); client.fastrprint(DEVICE_OWNER);
pollClient.fastrprint(F(" HTTP/1.1")); pollClient.fastrprint(F("\n")); client.fastrprint(F(" HTTP/1.1")); client.fastrprint(F("\n"));
pollClient.fastrprint(host.c_str()); pollClient.fastrprint(F("\n")); client.fastrprint(host.c_str()); client.fastrprint(F("\n"));
pollClient.println(); client.println();
delay(1000); delay(1000);
while (pollClient.available()) { while (client.available()) {
char response = pollClient.read(); char response = client.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) {
Serial.print(responseMsg);
Serial.println();
Serial.println("-------------------------------");
}
if (subStrn.equals("ON")) {
int index = responseMsg.lastIndexOf(":");
int newLine = responseMsg.lastIndexOf("\n");
subStrn = responseMsg.substring(index + 1);
responseMsg = responseMsg.substring(newLine + 1, index);
if(DEBUG) {
Serial.print(responseMsg);
Serial.println();
Serial.println("-------------------------------");
}
if (subStrn.equals("ON")) {
Serial.println("ITS ON"); Serial.println("ITS ON");
//digitalWrite(13, HIGH); //digitalWrite(13, HIGH);
digitalWrite(6, HIGH); digitalWrite(6, HIGH);
} else if (subStrn.equals("OFF")){ } else if (subStrn.equals("OFF")){
Serial.println("ITS OFF"); Serial.println("ITS OFF");
//digitalWrite(13, LOW); //digitalWrite(13, LOW);
digitalWrite(6, LOW); digitalWrite(6, LOW);
}
if (responseMsg.equals("BULB")) {
return false;
}
}
return true;
} }

@ -1,82 +1,84 @@
#include "ArduinoBoardSketch.h"
/********************************************************************************************** /**********************************************************************************************
This method will traverse the array of digital pins and batch the data from the those pins together. This method will traverse the array of digital pins and batch the data from the those pins together.
It makes a single call to the server and sends all pin values as a batch. It makes a single call to the server and sends all pin values as a batch.
Server dis-assembles it accordingly and makes multiple publish calls for each sensor type. Server dis-assembles it accordingly and makes multiple publish calls for each sensor type.
***********************************************************************************************/ ***********************************************************************************************/
void pushData(){ void pushData(){
String payLoad = "Data"; String payLoad = "Data";
payLoad = payLoad + "\",\"value\":\""; payLoad = payLoad + "\",\"value\":\"";
payLoad+=getBoardTemp(); payLoad+=cpuTemperature;
payLoad += "\"}"; payLoad += "\"}";
pushClient.fastrprint(F("POST ")); client.fastrprint(F("POST "));
pushClient.fastrprint(SERVICE_EPOINT); pushClient.fastrprint(F("pushdata")); client.fastrprint(SERVICE_EPOINT); client.fastrprint(F("pushdata"));
pushClient.fastrprint(F(" HTTP/1.1")); pushClient.fastrprint(F("\n")); client.fastrprint(F(" HTTP/1.1")); client.fastrprint(F("\n"));
pushClient.fastrprint(host.c_str()); pushClient.fastrprint(F("\n")); client.fastrprint(host.c_str()); client.fastrprint(F("\n"));
pushClient.fastrprint(F("Content-Type: application/json")); pushClient.fastrprint(F("\n")); client.fastrprint(F("Content-Type: application/json")); client.fastrprint(F("\n"));
pushClient.fastrprint(F("Content-Length: ")); client.fastrprint(F("Content-Length: "));
int payLength = jsonPayLoad.length() + payLoad.length(); int payLength = jsonPayLoad.length() + payLoad.length();
pushClient.fastrprint(String(payLength).c_str()); pushClient.fastrprint(F("\n")); client.fastrprint(String(payLength).c_str()); client.fastrprint(F("\n"));
pushClient.fastrprint(F("\n")); client.fastrprint(F("\n"));
if(DEBUG) { if(DEBUG) {
Serial.print("POST "); Serial.print("POST ");
Serial.print(SERVICE_EPOINT); Serial.print("pushdata"); Serial.print(SERVICE_EPOINT); Serial.print("pushdata");
Serial.print(" HTTP/1.1"); Serial.println(); Serial.print(" HTTP/1.1"); Serial.println();
Serial.print(host); Serial.println(); Serial.print(host); Serial.println();
Serial.print("Content-Type: application/json"); Serial.println(); Serial.print("Content-Type: application/json"); Serial.println();
Serial.print("Content-Length: "); Serial.print("Content-Length: ");
Serial.print(payLength); Serial.println(); Serial.print(payLength); Serial.println();
Serial.println(); Serial.println();
} }
int chunkSize = 50; int chunkSize = 50;
for (int i = 0; i < jsonPayLoad.length(); i++) { for (int i = 0; i < jsonPayLoad.length(); i++) {
if ( (i+1)*chunkSize > jsonPayLoad.length()) { if ( (i+1)*chunkSize > jsonPayLoad.length()) {
pushClient.print(jsonPayLoad.substring(i*chunkSize, jsonPayLoad.length())); client.print(jsonPayLoad.substring(i*chunkSize, jsonPayLoad.length()));
if(DEBUG) Serial.print(jsonPayLoad.substring(i*chunkSize, jsonPayLoad.length())); if(DEBUG) Serial.print(jsonPayLoad.substring(i*chunkSize, jsonPayLoad.length()));
i = jsonPayLoad.length(); i = jsonPayLoad.length();
} else { } else {
pushClient.print(jsonPayLoad.substring(i*chunkSize, (i+1)*chunkSize)); client.print(jsonPayLoad.substring(i*chunkSize, (i+1)*chunkSize));
if(DEBUG) Serial.print(jsonPayLoad.substring(i*chunkSize, (i+1)*chunkSize)); if(DEBUG) Serial.print(jsonPayLoad.substring(i*chunkSize, (i+1)*chunkSize));
} }
} }
for (int i = 0; i < payLoad.length(); i++) { for (int i = 0; i < payLoad.length(); i++) {
if ( (i+1)*chunkSize > payLoad.length()) { if ( (i+1)*chunkSize > payLoad.length()) {
pushClient.print(payLoad.substring(i*chunkSize, payLoad.length())); client.print(payLoad.substring(i*chunkSize, payLoad.length()));
if(DEBUG) Serial.print(payLoad.substring(i*chunkSize, payLoad.length())); if(DEBUG) Serial.print(payLoad.substring(i*chunkSize, payLoad.length()));
i = payLoad.length(); i = payLoad.length();
} else { } else {
pushClient.print(payLoad.substring(i*chunkSize, (i+1)*chunkSize)); client.print(payLoad.substring(i*chunkSize, (i+1)*chunkSize));
if(DEBUG) Serial.print(payLoad.substring(i*chunkSize, (i+1)*chunkSize)); if(DEBUG) Serial.print(payLoad.substring(i*chunkSize, (i+1)*chunkSize));
} }
} }
pushClient.fastrprint(F("\n")); client.fastrprint(F("\n"));
if(DEBUG) Serial.println(); if(DEBUG) Serial.println();
delay(1000); delay(1000);
while (pushClient.available()) { while (client.available()) {
char response = pushClient.read(); char response = client.read();
if(DEBUG) Serial.print(response); if(DEBUG) Serial.print(response);
} }
if(DEBUG) { if(DEBUG) {
Serial.println(); Serial.println();
Serial.println("-------------------------------"); Serial.println("-------------------------------");
} }
payLoad = ""; payLoad = "";
@ -84,3 +86,35 @@ void pushData(){
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);
}

@ -1,6 +1,7 @@
/**********************************************************************************************
Use the below variables when required to set a static IP for the WifiSheild /**********************************************************************************************
***********************************************************************************************/ Use the below variables when required to set a static IP for the WifiSheild
***********************************************************************************************/
// byte dns2[] = { 8, 8, 8, 8 }; // byte dns2[] = { 8, 8, 8, 8 };
// byte subnet[] = { 255, 255, 255, 0 }; // byte subnet[] = { 255, 255, 255, 0 };
// byte gateway[] = { 10, 100, 9, 254 }; // byte gateway[] = { 10, 100, 9, 254 };
@ -10,111 +11,106 @@
// uint32_t ip, ddns, ssubnet, ggateway; // 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 //mac - c0:4a:00:1a:08:da
// b8:27:eb:88:37:7a // c0:4a:00:1a:03:f8
String connecting = "connecting.... "; // b8:27:eb:88:37:7a
void connectHttp() { void connectHttp() {
/* Initialise the module */ /* Initialise the module */
if(DEBUG) Serial.println(F("\nInitializing...")); if(DEBUG) Serial.println(F("\nInitializing..."));
if (!cc3000.begin()) if (!cc3000.begin())
{ {
if(DEBUG) Serial.println(F("Couldn't begin()! Check your wiring?")); if(DEBUG) Serial.println(F("Couldn't begin()! Check your wiring?"));
while(1); while(1);
} }
// if( cc3000.setMacAddress(mac) ) { // Set your own mac and print it to re-check cc3000.setMacAddress(mac); // Set your own mac and print it to re-check
// uint8_t address[6]; // uint8_t address[6];
// cc3000.getMacAddress(address); // cc3000.getMacAddress(address);
// if(DEBUG){ // if(DEBUG){
// Serial.print(address[0], HEX); Serial.print(":"); // Serial.print(address[0], HEX); Serial.print(":");
// Serial.print(address[1], HEX); Serial.print(":"); // Serial.print(address[1], HEX); Serial.print(":");
// Serial.print(address[2], HEX); Serial.print(":"); // Serial.print(address[2], HEX); Serial.print(":");
// Serial.print(address[3], HEX); Serial.print(":"); // Serial.print(address[3], HEX); Serial.print(":");
// Serial.print(address[4], HEX); Serial.print(":"); // Serial.print(address[4], HEX); Serial.print(":");
// Serial.println(address[5], HEX); // Serial.println(address[5], HEX);
// } // }
// } // }
/********************************************************************************************** /**********************************************************************************************
Only required if using static IP for the WifiSheild Only required if using static IP for the WifiSheild
***********************************************************************************************/ ***********************************************************************************************/
// ip = cc3000.IP2U32(deviceIP[0], deviceIP[1], deviceIP[2], deviceIP[3]); // ip = cc3000.IP2U32(deviceIP[0], deviceIP[1], deviceIP[2], deviceIP[3]);
// ddns = cc3000.IP2U32(dns2[0], dns2[1], dns2[2], dns2[3]); // ddns = cc3000.IP2U32(dns2[0], dns2[1], dns2[2], dns2[3]);
// ssubnet = cc3000.IP2U32(subnet[0], subnet[1], subnet[2], subnet[3]); // ssubnet = cc3000.IP2U32(subnet[0], subnet[1], subnet[2], subnet[3]);
// ggateway = cc3000.IP2U32(gateway[0], gateway[1], gateway[2], gateway[3]); // ggateway = cc3000.IP2U32(gateway[0], gateway[1], gateway[2], gateway[3]);
// cc3000.setStaticIPAddress(ip, ssubnet, ggateway, ddns); // required for setting static IP // cc3000.setStaticIPAddress(ip, ssubnet, ggateway, ddns); // required for setting static IP
/***********************************************************************************************/ /***********************************************************************************************/
sserver = cc3000.IP2U32(server[0], server[1], server[2], server[3]); 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 (!cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY)) { if(CON_DEBUG) {
if(CON_DEBUG) Serial.println(F("Failed!")); Serial.print(F("\nAttempting to connect to "));
while(1); Serial.println(WLAN_SSID);
} }
if (!cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY)) {
if(CON_DEBUG) Serial.println(F("Failed!"));
while(1);
}
if(CON_DEBUG) Serial.println(F("Connected to Wifi network!")); if(CON_DEBUG) Serial.println(F("Connected to Wifi network!"));
if(CON_DEBUG) Serial.println(F("Request DHCP")); if(true) Serial.println(F("Request DHCP"));
while (!cc3000.checkDHCP()) while (!cc3000.checkDHCP())
{ {
delay(100); // ToDo: Insert a DHCP timeout! delay(100); // ToDo: Insert a DHCP timeout!
} }
/* Display the IP address DNS, Gateway, etc. */ /* Display the IP address DNS, Gateway, etc. */
while (! displayConnectionDetails()) { while (! displayConnectionDetails()) {
delay(1000); delay(1000);
} }
pushClient = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT pushClient = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT
if (pushClient.connected()) { if (pushClient.connected()) {
if(CON_DEBUG) Serial.println("PushClient Connected to server"); if(true) Serial.println(F("pushClient Connected to server"));
} else { } else {
cc3000.disconnect(); if(CON_DEBUG) Serial.println(F("pushClient Connection failed"));
if(CON_DEBUG) Serial.println(F("PushClient Connection failed")); }
}
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("-------------------------------------"));
if(CON_DEBUG) Serial.println(F("-------------------------------------"));
} }
void setupResource(){ void setupResource(){
String hostIP = getHostIP(server); String hostIP = getHostIP(server);
String port = String(SERVICE_PORT); String port = String(SERVICE_PORT);
//
host = "Host: " + hostIP + ":" + port; host = "Host: " + hostIP + ":" + port;
if(DEBUG) Serial.println(host); // if(DEBUG) Serial.println(host);
jsonPayLoad = "{\"owner\":\""; jsonPayLoad = "{\"owner\":\"";
jsonPayLoad += String(DEVICE_OWNER); jsonPayLoad += DEVICE_OWNER;
jsonPayLoad += "\",\"deviceId\":\""; jsonPayLoad += "\",\"deviceId\":\"";
jsonPayLoad += String(DEVICE_ID); jsonPayLoad += DEVICE_ID;
jsonPayLoad += "\",\"reply\":\""; jsonPayLoad += "\",\"reply\":\"";
if(DEBUG) { if(DEBUG) {
Serial.print("JSON Payload: "); Serial.print("JSON Payload: ");
Serial.println(jsonPayLoad); Serial.println(jsonPayLoad);
Serial.println("-------------------------------"); Serial.println("-------------------------------");
} }
} }
String getHostIP(byte server[4]){ String getHostIP(byte server[4]){
String hostIP = String(server[0]); String hostIP = String(server[0]);
@ -128,23 +124,36 @@ String getHostIP(byte server[4]){
bool displayConnectionDetails(void) bool displayConnectionDetails(void)
{ {
uint32_t ipAddress, netmask, gateway, dhcpserv, dnsserv; uint32_t netmask, gateway, dhcpserv, dnsserv;
if(!cc3000.getIPAddress(&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")); if(DEBUG) Serial.println(F("Unable to retrieve the IP Address!\r\n"));
return false; return false;
} }
else else
{ {
if(CON_DEBUG) { if(CON_DEBUG) {
Serial.print(F("\nIP Addr: ")); cc3000.printIPdotsRev(ipAddress); Serial.print(F("\nIP Addr: ")); cc3000.printIPdotsRev(ipAddress);
Serial.print(F("\nNetmask: ")); cc3000.printIPdotsRev(netmask); Serial.print(F("\nNetmask: ")); cc3000.printIPdotsRev(netmask);
Serial.print(F("\nGateway: ")); cc3000.printIPdotsRev(gateway); Serial.print(F("\nGateway: ")); cc3000.printIPdotsRev(gateway);
Serial.print(F("\nDHCPsrv: ")); cc3000.printIPdotsRev(dhcpserv); Serial.print(F("\nDHCPsrv: ")); cc3000.printIPdotsRev(dhcpserv);
Serial.print(F("\nDNSserv: ")); cc3000.printIPdotsRev(dnsserv); Serial.print(F("\nDNSserv: ")); cc3000.printIPdotsRev(dnsserv);
Serial.println(); Serial.println();
}
return true;
}
}
void setupClient(){
pushClient = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT
if (pushClient.connected()) {
if(CON_DEBUG) Serial.println(F("client Connected to server"));
} else {
while( !cc3000.checkConnected() ){
connectHttp();
}
if(CON_DEBUG) Serial.println(F("client Connection failed"));
} }
return true;
}
} }

@ -13,32 +13,57 @@
#define ADAFRUIT_CC3000_VBAT 5 #define ADAFRUIT_CC3000_VBAT 5
#define ADAFRUIT_CC3000_CS 10 #define ADAFRUIT_CC3000_CS 10
#define WLAN_SSID "YourAP-SSID" // cannot be longer than 32 characters! #define LISTEN_PORT 80 // What TCP port to listen on for connections.
#define WLAN_PASS "Your-Password" // The HTTP protocol uses port 80 by default.
#define WLAN_SECURITY WLAN_SEC_WPA2 #define MAX_ACTION 6 // Maximum length of the HTTP action that can be parsed.
#define MAX_PATH 10 // Maximum length of the HTTP request path that can be parsed.
// There isn't much memory available so keep this short!
#define BUFFER_SIZE MAX_ACTION + MAX_PATH + 10 // Size of buffer for incoming request data.
// Since only the first line is parsed this
// needs to be as large as the maximum action
// and path plus a little for whitespace and
// HTTP version.
#define TIMEOUT_MS 500 // Amount of time in milliseconds to wait for
// an incoming request to finish. Don't set this
// too high or your server could be slow to respond.
#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 // Security can be WLAN_SEC_UNSEC, WLAN_SEC_WEP, WLAN_SEC_WPA or WLAN_SEC_WPA2
#define IDLE_TIMEOUT_MS 3000 #define IDLE_TIMEOUT_MS 3000
#define DEVICE_OWNER "${DEVICE_OWNER}" //"SHABIRMEAN" #define DEVICE_OWNER "${DEVICE_OWNER}"
#define DEVICE_ID "${DEVICE_ID}" //"vbhenqyt85yq" #define DEVICE_ID "${DEVICE_ID}"
#define DEVICE_TOKEN "${DEVICE_TOKEN}" #define DEVICE_TOKEN "${DEVICE_TOKEN}"
#define SERVICE_PORT 9763 #define SERVICE_PORT 9763
#define SERVICE_EPOINT "/firealarm/controller/" #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 6
#define BULB_PIN 7
#define FAN_PIN 8
#define POLL_INTERVAL 1000 #define TEMP_PIN A5
#define BULB_PIN A4
#define FAN_PIN A3
#define DEBUG false #define DEBUG false
#define CON_DEBUG true #define CON_DEBUG true
#endif static unsigned long pushTimestamp = 0;
byte server[4] = { 192, 168, 1, 101 };
String host, jsonPayLoad;
String responseMsg, subStrn;
uint32_t ipAddress;
#define PUSH_INTERVAL 30000
byte mac[6] = { 0xc0, 0x4a, 0x00, 0x1a, 0xb8, 0xbb };
#endif

@ -1,156 +1,81 @@
#include "FireAlarmWifiAgent.h" #include "FireAlarmWifiAgent.h"
#include <Adafruit_CC3000.h> #include <Adafruit_CC3000.h>
#include <avr/wdt.h>
#include <SPI.h> #include <SPI.h>
#include "dht.h" #include "dht.h"
#include <pt.h>
Adafruit_CC3000 cc3000 = Adafruit_CC3000(ADAFRUIT_CC3000_CS, ADAFRUIT_CC3000_IRQ, ADAFRUIT_CC3000_VBAT, Adafruit_CC3000 cc3000 = Adafruit_CC3000(ADAFRUIT_CC3000_CS, ADAFRUIT_CC3000_IRQ, ADAFRUIT_CC3000_VBAT,
SPI_CLOCK_DIVIDER); // you can change this clock speed SPI_CLOCK_DIVIDER); // you can change this clock speed
Adafruit_CC3000_Client pushClient; Adafruit_CC3000_Client pushClient;
Adafruit_CC3000_Client pollClient; Adafruit_CC3000_Server httpServer(LISTEN_PORT);
static struct pt pushThread;
uint32_t sserver; uint32_t sserver;
/********************************************************************************************** /**********************************************************************************************
0. Check with a sample Wifi code of the Adafruit_CC3000 library to ensure that the sheild is working 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 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 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 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 4. Check whether the pins have been attached accordingly in the Arduino
5. Check whether all reqquired pins are added to the 'digitalPins' array 5. Check whether all reqquired pins are added to the 'digitalPins' array
***********************************************************************************************/ ***********************************************************************************************/
void setup() {
if (CON_DEBUG) Serial.begin(9600);
byte server[4] = { 10, 100, 7, 38 }; pinMode(BULB_PIN, OUTPUT);
pinMode(FAN_PIN, OUTPUT);
pinMode(TEMP_PIN, INPUT);
setupResource();
int digitalPins[] = { TEMP_PIN, BULB_PIN, FAN_PIN }; do {
String host, jsonPayLoad, replyMsg; connectHttp();
String responseMsg, subStrn; } while (!cc3000.checkConnected());
void setup() { while (!pushClient.connected()) {
if(true) Serial.begin(115200); setupClient();
pinMode(BULB_PIN, OUTPUT); }
pinMode(FAN_PIN, OUTPUT);
PT_INIT(&pushThread); registerIP();
connectHttp(); httpServer.begin();
setupResource(); wdt_enable(WDTO_8S);
} }
void loop() { void loop() {
if (pushClient.connected() && pollClient.connected()) {
pushData(); // batches all the required pin values together and pushes once
// pushDigitalPinData(); // pushes pin data via multiple calls with a single pin data per call
// protothread1(&pushThread, 1000); // Pushes data and waits for control signals to be received
delay(POLL_INTERVAL);
boolean valid = readControls();
if (!valid) {
if (responseMsg.equals("TEMPERATURE")) {
int temperature = (uint8_t)getTemperature();
replyMsg = "Temperature is " + String(temperature) + " C";
reply();
} else if (responseMsg.equals("BULB")) {
replyMsg = "Bulb was switched " + switchBulb();
} else if (responseMsg.equals("FAN")) {
replyMsg = "Buzzer was switched " + switchFan();
}
}
} else {
if(DEBUG) {
Serial.println("client not found...");
Serial.println("disconnecting.");
}
pushClient.close();
pollClient.close();
cc3000.disconnect();
connectHttp();
}
}
while (!cc3000.checkConnected()) {
connectHttp();
String switchBulb() {
if (digitalRead(BULB_PIN) == HIGH) {
digitalWrite(BULB_PIN, LOW);
return "OFF";
} else {
digitalWrite(BULB_PIN, HIGH);
return "ON";
} }
} wdt_reset();
String switchFan() { if (millis() - pushTimestamp > PUSH_INTERVAL) {
if (digitalRead(FAN_PIN) == HIGH) { wdt_reset();
digitalWrite(FAN_PIN, LOW); while (!pushClient.connected()) {
return "OFF"; setupClient();
} else { }
digitalWrite(FAN_PIN, HIGH); pushData();
return "ON"; pushTimestamp = millis();
}
readControls();
wdt_reset();
if (subStrn.equals("ON")) {
if (responseMsg.equals("BULB")) {
digitalWrite(BULB_PIN, HIGH);
} else if (responseMsg.equals("FAN")) {
digitalWrite(FAN_PIN, HIGH);
}
} else if (subStrn.equals("OFF")) {
if (responseMsg.equals("BULB")) {
digitalWrite(BULB_PIN, LOW);
} else if (responseMsg.equals("FAN")) {
digitalWrite(FAN_PIN, LOW);
}
} }
}
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;
}
wdt_reset();
static int protothread1(struct pt *pt, int interval) {
static unsigned long timestamp = 0;
PT_BEGIN(pt);
while(1) { // never stop
/* each time the function it is checked whether any control signals are sent
* if so exit this proto thread
*/
PT_WAIT_UNTIL(pt, readControls() );
pushData();
}
PT_END(pt);
} }

@ -0,0 +1,94 @@
uint8_t buffer[BUFFER_SIZE + 1];
int bufindex = 0;
char action[MAX_ACTION + 1];
char path[MAX_PATH + 1];
void readControls() {
// Try to get a client which is connected.
Adafruit_CC3000_ClientRef client = httpServer.available();
if (client) {
bufindex = 0;
memset(&buffer, 0, sizeof(buffer));
// Clear action and path strings.
memset(&action, 0, sizeof(action));
memset(&path, 0, sizeof(path));
// Set a timeout for reading all the incoming data.
unsigned long endtime = millis() + TIMEOUT_MS;
// Read all the incoming data until it can be parsed or the timeout expires.
bool parsed = false;
while (!parsed && (millis() < endtime) && (bufindex < BUFFER_SIZE)) {
if (client.available()) {
buffer[bufindex++] = client.read();
}
parsed = parseRequest(buffer, bufindex, action, path);
}
wdt_reset();
if (parsed) {
if (strcmp(action, "GET") == 0) {
responseMsg = path;
if (DEBUG) {
Serial.println(responseMsg);
}
int index = responseMsg.lastIndexOf("/");
int newLine = responseMsg.indexOf("/");
subStrn = responseMsg.substring(index + 1);
responseMsg = responseMsg.substring(newLine + 1, index);
if (DEBUG) {
Serial.print(responseMsg);
Serial.print(" - ");
Serial.println(subStrn);
Serial.println("-------------------------------");
}
}
if (responseMsg == "TEMP") {
int temperature = (uint8_t) getTemperature();
client.fastrprintln(F("HTTP/1.1 200 OK"));
client.fastrprintln(F("Connection: close"));
client.fastrprintln(F(""));
client.fastrprint(String(temperature).c_str());
}
}
delay(100);
// Close the connection when done.
Serial.println(F("Client disconnected"));
client.close();
wdt_reset();
}
}
bool parseRequest(uint8_t *buf, int bufSize, char *action, char *path) {
// Check if the request ends with \r\n to signal end of first line.
if (bufSize < 2)
return false;
if (buf[bufSize - 2] == '\r' && buf[bufSize - 1] == '\n') {
parseFirstLine((char *) buf, action, path);
return true;
}
return false;
}
// Parse the action and path from the first line of an HTTP request.
void parseFirstLine(char *line, char *action, char *path) {
// Parse first word up to whitespace as action.
char *lineaction = strtok(line, " ");
if (lineaction != NULL)
strncpy(action, lineaction, MAX_ACTION);
// Parse second word up to whitespace as path.
char *linepath = strtok(NULL, " ");
if (linepath != NULL)
strncpy(path, linepath, MAX_PATH);
}

@ -1,120 +1,33 @@
boolean readControls() { void registerIP() {
// String responseMsg; pushClient.fastrprint(F("GET "));
pushClient.fastrprint(SERVICE_EPOINT); pushClient.fastrprint(F("register/"));
pollClient.fastrprint(F("GET ")); pushClient.fastrprint(DEVICE_OWNER); pushClient.fastrprint(F("/"));
pollClient.fastrprint(SERVICE_EPOINT); pollClient.fastrprint(F("readcontrols/")); pushClient.fastrprint(DEVICE_ID); pushClient.fastrprint(F("/"));
pollClient.fastrprint(DEVICE_OWNER); pollClient.fastrprint(F("/")); pollClient.fastrprint(DEVICE_ID);
pollClient.fastrprint(F(" HTTP/1.1")); pollClient.fastrprint(F("\n")); // pushClient.fastrprint(deviceIP.c_str());
pollClient.fastrprint(host.c_str()); pollClient.fastrprint(F("\n")); pushClient.fastrprint(String((uint8_t)(ipAddress >> 24)).c_str());
pollClient.println(); pushClient.fastrprint(".");
pushClient.fastrprint(String((uint8_t)(ipAddress >> 16)).c_str());
delay(1000); pushClient.fastrprint(".");
pushClient.fastrprint(String((uint8_t)(ipAddress >> 8)).c_str());
if (true) { pushClient.fastrprint(".");
while (pollClient.available()) { pushClient.fastrprint(String((uint8_t)ipAddress).c_str());
char response = pollClient.read();
responseMsg += response; pushClient.fastrprint(F(" HTTP/1.1")); pushClient.fastrprint(F("\n"));
} pushClient.fastrprint(host.c_str()); pushClient.fastrprint(F("\n"));
} pushClient.println();
if (DEBUG) {
int index = responseMsg.lastIndexOf(":"); Serial.print("GET "); Serial.print(SERVICE_EPOINT); Serial.print("register/");
int newLine = responseMsg.lastIndexOf("\n"); Serial.print(DEVICE_OWNER); Serial.print("/"); Serial.print(DEVICE_ID);
subStrn = responseMsg.substring(index + 1); Serial.print("/");
responseMsg = responseMsg.substring(newLine + 1, index); // Serial.print(deviceIP);
if(DEBUG) {
Serial.print(responseMsg);
Serial.println();
Serial.println("-------------------------------");
}
if (subStrn.equals("IN")) {
return false;
}
return true;
}
void reply() {
String payLoad = replyMsg + "\"}";
if(DEBUG) {
Serial.print(jsonPayLoad); Serial.println(payLoad);
}
pollClient.fastrprint(F("POST "));
pollClient.fastrprint(SERVICE_EPOINT); pollClient.fastrprint(F("reply"));
pollClient.fastrprint(F(" HTTP/1.1")); pollClient.fastrprint(F("\n"));
pollClient.fastrprint(host.c_str()); pollClient.fastrprint(F("\n"));
pollClient.fastrprint(F("Content-Type: application/json")); pollClient.fastrprint(F("\n"));
pollClient.fastrprint(F("Content-Length: "));
int payLength = jsonPayLoad.length() + payLoad.length();
pollClient.fastrprint(String(payLength).c_str()); pollClient.fastrprint(F("\n"));
pollClient.fastrprint(F("\n"));
if(DEBUG) {
Serial.print("POST ");
Serial.print(SERVICE_EPOINT); Serial.print("reply");
Serial.print(" HTTP/1.1"); Serial.println(); Serial.print(" HTTP/1.1"); Serial.println();
Serial.print(host); Serial.println(); Serial.print(host); Serial.println(); Serial.println();
Serial.print("Content-Type: application/json"); Serial.println();
Serial.print("Content-Length: ");
Serial.print(payLength); Serial.println();
Serial.println();
}
int chunkSize = 50;
for (int i = 0; i < jsonPayLoad.length(); i++) {
if ( (i+1)*chunkSize > jsonPayLoad.length()) {
pollClient.print(jsonPayLoad.substring(i*chunkSize, jsonPayLoad.length()));
if(DEBUG) Serial.print(jsonPayLoad.substring(i*chunkSize, jsonPayLoad.length()));
i = jsonPayLoad.length();
} else {
pollClient.print(jsonPayLoad.substring(i*chunkSize, (i+1)*chunkSize));
if(DEBUG) Serial.print(jsonPayLoad.substring(i*chunkSize, (i+1)*chunkSize));
}
}
for (int i = 0; i < payLoad.length(); i++) {
if ( (i+1)*chunkSize > payLoad.length()) {
pollClient.print(payLoad.substring(i*chunkSize, payLoad.length()));
if(DEBUG) Serial.print(payLoad.substring(i*chunkSize, payLoad.length()));
i = payLoad.length();
} else {
pollClient.print(payLoad.substring(i*chunkSize, (i+1)*chunkSize));
if(DEBUG) Serial.print(payLoad.substring(i*chunkSize, (i+1)*chunkSize));
}
}
pollClient.fastrprint(F("\n"));
if(DEBUG) Serial.println();
delay(1000);
if(true) {
while (pollClient.available()) {
char response = pollClient.read();
if(DEBUG) Serial.print(response);
}
}
if(DEBUG) {
Serial.println();
Serial.println("-------------------------------");
} }
payLoad = ""; delay(100);
// delay(1000);
pushClient.flush();
pushClient.close();
} }

@ -1,30 +1,16 @@
/**********************************************************************************************
This method will traverse the array of digital pins and batch the data from the those pins together.
It makes a single call to the server and sends all pin values as a batch.
Server dis-assembles it accordingly and makes multiple publish calls for each sensor type.
***********************************************************************************************/
void pushData(){ void pushData(){
String payLoad = "Data"; String payLoad = "Data";
payLoad = payLoad + "\",\"value\":\""; payLoad = payLoad + "\",\"value\":\"";
for ( int pin = 0; pin < (sizeof(digitalPins)/sizeof(int)); pin++) {
if ( digitalPins[pin] == TEMP_PIN ) {
int temperature = (uint8_t)getTemperature();
payLoad += temperature;
} 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 += (uint8_t)getTemperature();
payLoad += "\"}"; payLoad += ":";
payLoad += ( digitalRead(BULB_PIN) == HIGH )?"ON":"OFF";
payLoad += ":";
payLoad += ( digitalRead(FAN_PIN) == HIGH )?"ON":"OFF";
payLoad += "\"}";
pushClient.fastrprint(F("POST ")); pushClient.fastrprint(F("POST "));
pushClient.fastrprint(SERVICE_EPOINT); pushClient.fastrprint(F("pushalarmdata")); pushClient.fastrprint(SERVICE_EPOINT); pushClient.fastrprint(F("pushalarmdata"));
@ -76,203 +62,69 @@ void pushData(){
pushClient.fastrprint(F("\n")); pushClient.fastrprint(F("\n"));
if(DEBUG) Serial.println(); if(DEBUG) Serial.println();
delay(1000); delay(100);
if(true) {
while (pushClient.available()) {
char response = pushClient.read();
if(DEBUG) Serial.print(response);
}
}
if(DEBUG) { pushClient.flush();
Serial.println(); pushClient.close();
Serial.println("-------------------------------"); wdt_reset();
}
payLoad = "";
}
/**********************************************************************************************
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 payLoad = getDataType(digitalPins[pin]);
// payLoad = payLoad + "\",\"value\":\"";
//
// if ( digitalPins[pin] == TEMP_PIN ) {
// int temperature = (uint8_t)getTemperature();
// payLoad += temperature;
// } else if ( digitalRead(digitalPins[pin]) == HIGH ) {
// payLoad += "ON";
// } else if ( digitalRead(digitalPins[pin]) == LOW ) {
// payLoad += "OFF";
// }
//
// payLoad += "\"}";
//
// pushClient.fastrprint(F("POST "));
// pushClient.fastrprint(SERVICE_EPOINT); pushClient.fastrprint(F("pushalarmdata"));
// pushClient.fastrprint(F(" HTTP/1.1")); pushClient.fastrprint(F("\n"));
// pushClient.fastrprint(host.c_str()); pushClient.fastrprint(F("\n"));
// pushClient.fastrprint(F("Content-Type: application/json")); pushClient.fastrprint(F("\n"));
// pushClient.fastrprint(F("Content-Length: "));
//
// int payLength = jsonPayLoad.length() + payLoad.length();
//
// pushClient.fastrprint(String(payLength).c_str()); pushClient.fastrprint(F("\n"));
// pushClient.fastrprint(F("\n"));
//
// if(DEBUG) {
// Serial.print("POST ");
// Serial.print(SERVICE_EPOINT); Serial.print("pushalarmdata");
// 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();
// }
//
// int chunkSize = 50;
//
// for (int i = 0; i < jsonPayLoad.length(); i++) {
// if ( (i+1)*chunkSize > jsonPayLoad.length()) {
// pushClient.print(jsonPayLoad.substring(i*chunkSize, jsonPayLoad.length()));
// if(DEBUG) Serial.print(jsonPayLoad.substring(i*chunkSize, jsonPayLoad.length()));
// i = jsonPayLoad.length();
// } else {
// pushClient.print(jsonPayLoad.substring(i*chunkSize, (i+1)*chunkSize));
// if(DEBUG) Serial.print(jsonPayLoad.substring(i*chunkSize, (i+1)*chunkSize));
// }
// }
//
// for (int i = 0; i < payLoad.length(); i++) {
// if ( (i+1)*chunkSize > payLoad.length()) {
// 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));
// }
// }
//
// pushClient.fastrprint(F("\n"));
// if(DEBUG) Serial.println();
//
// delay(1000);
//
// if(true) { // if(true) {
// while (pushClient.available()) { // while (pushClient.available()) {
// char response = pushClient.read(); // char response = pushClient.read();
// if(DEBUG) Serial.print(response); // if(DEBUG) Serial.print(response);
// } // }
// } // }
//
// if(DEBUG) {
// Serial.println();
// Serial.println("-------------------------------");
// }
//
// payLoad = "";
//// 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(){
// for ( int pin = 0; pin < (sizeof(analogPins)/sizeof(int)); pin++) {
// String payLoad = jsonPayLoad + "AnalogPinData";
// payLoad = payLoad + "\",\"time\":\"" + "9999";
// payLoad = payLoad + "\",\"key\":\"" + getDataType(analogPins[pin]);
// payLoad = payLoad + "\",\"value\":\"" + analogRead(analogPins[pin]);
// payLoad = payLoad + "\"}";
//
// pushClient.fastrprint(F("POST "));
// pushClient.fastrprint(SERVICE_EPOINT); pushClient.fastrprint(F("pushalarmdata"));
// pushClient.fastrprint(F(" HTTP/1.1")); pushClient.fastrprint(F("\n"));
// pushClient.fastrprint(host.c_str()); pushClient.fastrprint(F("\n"));
// pushClient.fastrprint(F("Content-Type: application/json")); pushClient.fastrprint(F("\n"));
// pushClient.fastrprint(F("Content-Length: "));
//
// int payLength = payLoad.length();
//
// pushClient.fastrprint(String(payLength).c_str()); pushClient.fastrprint(F("\n"));
// pushClient.fastrprint(F("\n"));
//
// if(DEBUG) {
// Serial.print("POST ");
// Serial.print(SERVICE_EPOINT); Serial.print("pushalarmdata");
// 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();
// }
//
// int chunkSize = 50;
//
// for (int i = 0; i < payLength; i++) {
// if ( (i+1)*chunkSize > payLength) {
// pushClient.print(payLoad.substring(i*chunkSize, payLength));
// if(DEBUG) Serial.print(payLoad.substring(i*chunkSize, payLength));
// i = payLength;
// } else {
// pushClient.print(payLoad.substring(i*chunkSize, (i+1)*chunkSize));
// if(DEBUG) Serial.print(payLoad.substring(i*chunkSize, (i+1)*chunkSize));
// }
// }
//
// pushClient.fastrprint(F("\n"));
// if(DEBUG) Serial.println();
//
// delay(1000);
//
// if(true) {
// while (pushClient.available()) {
// char response = pushClient.read();
// if(DEBUG) Serial.print(response);
// }
// }
//
// if(DEBUG) {
// Serial.println();
// Serial.println("-------------------------------");
// }
//
// payLoad = "";
// delay(1000);
// }
//}
if(DEBUG) {
Serial.println();
Serial.println("-------------------------------");
}
payLoad = "";
}
double getTemperature(){
dht DHT;
String getDataType(int pin){ if(DEBUG) {
switch(pin){ Serial.println("-------------------------------");
case TEMP_PIN: Serial.println("Type,\tstatus,\tHumidity (%),\tTemperature (C)");
return "TEMP"; Serial.print("DHT11, \t");
case BULB_PIN: }
return "BULB"; int chk = DHT.read11(TEMP_PIN);
case FAN_PIN: switch (chk)
return "FAN"; {
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: default:
return String(pin); 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,6 +1,7 @@
/**********************************************************************************************
Use the below variables when required to set a static IP for the WifiSheild /**********************************************************************************************
***********************************************************************************************/ Use the below variables when required to set a static IP for the WifiSheild
***********************************************************************************************/
// byte dns2[] = { 8, 8, 8, 8 }; // byte dns2[] = { 8, 8, 8, 8 };
// byte subnet[] = { 255, 255, 255, 0 }; // byte subnet[] = { 255, 255, 255, 0 };
// byte gateway[] = { 10, 100, 9, 254 }; // byte gateway[] = { 10, 100, 9, 254 };
@ -10,106 +11,106 @@
// uint32_t ip, ddns, ssubnet, ggateway; // uint32_t ip, ddns, ssubnet, ggateway;
// byte mac[6] = { 0xC0, 0x4A, 0x00, 0x1A, 0x08, 0xDA }; //mac - c0:4a:00:1a:08:da byte mac[6] = { 0xc0, 0x4a, 0x00, 0x1a, 0x08, 0xaa };
// c0:4a:00:1a:03:f8 //mac - c0:4a:00:1a:08:da
// b8:27:eb:88:37:7a // c0:4a:00:1a:03:f8
String connecting = "connecting.... "; // b8:27:eb:88:37:7a
void connectHttp() { void connectHttp() {
/* Initialise the module */ /* Initialise the module */
if(DEBUG) Serial.println(F("\nInitializing...")); if(DEBUG) Serial.println(F("\nInitializing..."));
if (!cc3000.begin()) if (!cc3000.begin())
{ {
if(DEBUG) Serial.println(F("Couldn't begin()! Check your wiring?")); if(DEBUG) Serial.println(F("Couldn't begin()! Check your wiring?"));
while(1); while(1);
} }
// if( cc3000.setMacAddress(mac) ) { // Set your own mac and print it to re-check cc3000.setMacAddress(mac); // Set your own mac and print it to re-check
// uint8_t address[6]; // uint8_t address[6];
// cc3000.getMacAddress(address); // cc3000.getMacAddress(address);
// if(DEBUG){ // if(DEBUG){
// Serial.print(address[0], HEX); Serial.print(":"); // Serial.print(address[0], HEX); Serial.print(":");
// Serial.print(address[1], HEX); Serial.print(":"); // Serial.print(address[1], HEX); Serial.print(":");
// Serial.print(address[2], HEX); Serial.print(":"); // Serial.print(address[2], HEX); Serial.print(":");
// Serial.print(address[3], HEX); Serial.print(":"); // Serial.print(address[3], HEX); Serial.print(":");
// Serial.print(address[4], HEX); Serial.print(":"); // Serial.print(address[4], HEX); Serial.print(":");
// Serial.println(address[5], HEX); // Serial.println(address[5], HEX);
// } // }
// } // }
/********************************************************************************************** /**********************************************************************************************
Only required if using static IP for the WifiSheild Only required if using static IP for the WifiSheild
***********************************************************************************************/ ***********************************************************************************************/
// ip = cc3000.IP2U32(deviceIP[0], deviceIP[1], deviceIP[2], deviceIP[3]); // ip = cc3000.IP2U32(deviceIP[0], deviceIP[1], deviceIP[2], deviceIP[3]);
// ddns = cc3000.IP2U32(dns2[0], dns2[1], dns2[2], dns2[3]); // ddns = cc3000.IP2U32(dns2[0], dns2[1], dns2[2], dns2[3]);
// ssubnet = cc3000.IP2U32(subnet[0], subnet[1], subnet[2], subnet[3]); // ssubnet = cc3000.IP2U32(subnet[0], subnet[1], subnet[2], subnet[3]);
// ggateway = cc3000.IP2U32(gateway[0], gateway[1], gateway[2], gateway[3]); // ggateway = cc3000.IP2U32(gateway[0], gateway[1], gateway[2], gateway[3]);
// cc3000.setStaticIPAddress(ip, ssubnet, ggateway, ddns); // required for setting static IP // cc3000.setStaticIPAddress(ip, ssubnet, ggateway, ddns); // required for setting static IP
/***********************************************************************************************/ /***********************************************************************************************/
sserver = cc3000.IP2U32(server[0], server[1], server[2], server[3]); 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 (!cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY)) { if(CON_DEBUG) {
if(CON_DEBUG) Serial.println(F("Failed!")); Serial.print(F("\nAttempting to connect to "));
while(1); Serial.println(WLAN_SSID);
} }
if(CON_DEBUG) Serial.println(F("Connected to Wifi network!")); if (!cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY)) {
if(CON_DEBUG) Serial.println(F("Failed!"));
while(1);
}
if(CON_DEBUG) Serial.println(F("Connected to Wifi network!"));
if(CON_DEBUG) Serial.println(F("Request DHCP")); if(true) Serial.println(F("Request DHCP"));
while (!cc3000.checkDHCP()) while (!cc3000.checkDHCP())
{ {
delay(100); // ToDo: Insert a DHCP timeout! delay(100); // ToDo: Insert a DHCP timeout!
} }
/* Display the IP address DNS, Gateway, etc. */ /* Display the IP address DNS, Gateway, etc. */
while (! displayConnectionDetails()) { while (! displayConnectionDetails()) {
delay(1000); delay(1000);
} }
client = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT
if (client.connected()) {
if(true) Serial.println(F("client Connected to server"));
} else {
if(CON_DEBUG) Serial.println(F("client Connection failed"));
}
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"));
}
httpServer.begin();
Serial.println(F("Listening for connections..."));
if(CON_DEBUG) Serial.println(F("-------------------------------------")); if(CON_DEBUG) Serial.println(F("-------------------------------------"));
} }
void setupResource(){ void setupResource(){
String hostIP = getHostIP(server); String hostIP = getHostIP(server);
String port = String(SERVICE_PORT); String port = String(SERVICE_PORT);
//
host = "Host: " + hostIP + ":" + port; host = "Host: " + hostIP + ":" + port;
if(DEBUG) Serial.println(host); // if(DEBUG) Serial.println(host);
jsonPayLoad = "{\"owner\":\""; jsonPayLoad = "{\"owner\":\"";
jsonPayLoad += String(DEVICE_OWNER); jsonPayLoad += DEVICE_OWNER;
jsonPayLoad += "\",\"deviceId\":\""; jsonPayLoad += "\",\"deviceId\":\"";
jsonPayLoad += String(DEVICE_ID); jsonPayLoad += DEVICE_ID;
jsonPayLoad += "\",\"reply\":\""; jsonPayLoad += "\",\"reply\":\"";
if(DEBUG) { if(DEBUG) {
Serial.print("JSON Payload: "); Serial.print("JSON Payload: ");
Serial.println(jsonPayLoad); Serial.println(jsonPayLoad);
Serial.println("-------------------------------"); Serial.println("-------------------------------");
} }
} }
String getHostIP(byte server[4]){ String getHostIP(byte server[4]){
String hostIP = String(server[0]); String hostIP = String(server[0]);
@ -123,23 +124,36 @@ String getHostIP(byte server[4]){
bool displayConnectionDetails(void) bool displayConnectionDetails(void)
{ {
uint32_t ipAddress, netmask, gateway, dhcpserv, dnsserv; uint32_t ipAddress, netmask, gateway, dhcpserv, dnsserv;
if(!cc3000.getIPAddress(&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")); if(DEBUG) Serial.println(F("Unable to retrieve the IP Address!\r\n"));
return false; return false;
} }
else else
{ {
if(CON_DEBUG) { if(CON_DEBUG) {
Serial.print(F("\nIP Addr: ")); cc3000.printIPdotsRev(ipAddress); Serial.print(F("\nIP Addr: ")); cc3000.printIPdotsRev(ipAddress);
// Serial.print(F("\nNetmask: ")); cc3000.printIPdotsRev(netmask); Serial.print(F("\nNetmask: ")); cc3000.printIPdotsRev(netmask);
// Serial.print(F("\nGateway: ")); cc3000.printIPdotsRev(gateway); Serial.print(F("\nGateway: ")); cc3000.printIPdotsRev(gateway);
// Serial.print(F("\nDHCPsrv: ")); cc3000.printIPdotsRev(dhcpserv); Serial.print(F("\nDHCPsrv: ")); cc3000.printIPdotsRev(dhcpserv);
// Serial.print(F("\nDNSserv: ")); cc3000.printIPdotsRev(dnsserv); Serial.print(F("\nDNSserv: ")); cc3000.printIPdotsRev(dnsserv);
Serial.println(); Serial.println();
}
return true;
}
}
void setupClient(){
client = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT
if (client.connected()) {
if(CON_DEBUG) Serial.println(F("client Connected to server"));
} else {
while( !cc3000.checkConnected() ){
connectHttp();
}
if(CON_DEBUG) Serial.println(F("client Connection failed"));
} }
return true;
}
} }

@ -1,4 +1,11 @@
void updateDirectionVariable(int motionDir){
motion_global = motionDir;
}
void motor_stop(){ void motor_stop(){
digitalWrite(motor_left[0], LOW); digitalWrite(motor_left[0], LOW);
digitalWrite(motor_left[1], LOW); digitalWrite(motor_left[1], LOW);
@ -53,3 +60,19 @@ void turn_left(){
updateDirectionVariable(0); updateDirectionVariable(0);
motor_stop(); motor_stop();
} }
void drive(){
switch(motion_global){
case 1 : drive_forward();
break;
case 2 : drive_backward();
break;
case 3 : turn_left();
break;
case 4 : turn_right();
break;
case 5 :
motor_stop();
break;
}
}

@ -3,17 +3,12 @@ int bufindex = 0;
char action[MAX_ACTION+1]; char action[MAX_ACTION+1];
char path[MAX_PATH+1]; char path[MAX_PATH+1];
boolean listen() void readControls()
{ {
// Try to get a client which is connected. // Try to get a client which is connected.
Adafruit_CC3000_ClientRef client = httpServer.available(); Adafruit_CC3000_ClientRef client = httpServer.available();
if (client) { if(client){
//Serial.println(F("Client connected."));
// Process this request until it completes or times out.
// Note that this is explicitly limited to handling one request at a time!
// Clear the incoming data buffer and point to the beginning of it.
bufindex = 0; bufindex = 0;
memset(&buffer, 0, sizeof(buffer)); memset(&buffer, 0, sizeof(buffer));
@ -37,7 +32,7 @@ boolean listen()
// Serial.print(F("Path: ")); Serial.println(path); // Serial.print(F("Path: ")); Serial.println(path);
if (strcmp(action, "GET") == 0) { if (strcmp(action, "GET") == 0) {
String urlPath = path; urlPath = path;
urlPath.replace("/move/",""); urlPath.replace("/move/","");
urlPath.replace("/",""); urlPath.replace("/","");
@ -61,15 +56,11 @@ boolean listen()
// Wait a short period to make sure the response had time to send before // Wait a short period to make sure the response had time to send before
// the connection is closed (the CC3000 sends data asyncronously). // the connection is closed (the CC3000 sends data asyncronously).
delay(100); delay(200);
// Close the connection when done.
Serial.println(F("Client disconnected"));
client.close(); client.close();
return false;
} else { }
return true;
}
} }

@ -1,36 +1,31 @@
/**********************************************************************************************
This method will traverse the array of digital pins and batch the data from the those pins together.
It makes a single call to the server and sends all pin values as a batch.
Server dis-assembles it accordingly and makes multiple publish calls for each sensor type.
***********************************************************************************************/
void pushData(){ void pushData(){
String payLoad = "Data"; String payLoad = "Data";
payLoad = payLoad + "\",\"value\":\""; payLoad = payLoad + "\",\"value\":\"";
int temperature = (uint8_t)getTemperature();
payLoad += temperature; payLoad += temperature;
payLoad += ":"; payLoad += ":";
payLoad += digitalRead(PIR_PIN); payLoad += pir;
payLoad += ":"; payLoad += ":";
payLoad += getSonar(); // returns distance if < MAX_DISTANCE else returns -1, payLoad += sonar; // returns distance if < MAX_DISTANCE else returns -1,
// Pushed accordingly inside JAX-RS sonar=-1; // Pushed accordingly inside JAX-RS
payLoad += ":"; payLoad += ":";
payLoad += analogRead(LDR_PIN); payLoad += ldr;
payLoad += "\"}"; payLoad += "\"}";
pushClient.fastrprint(F("POST ")); client.fastrprint(F("POST "));
pushClient.fastrprint(SERVICE_EPOINT); pushClient.fastrprint(F("pushsensordata")); client.fastrprint(SERVICE_EPOINT); client.fastrprint(F("pushsensordata"));
pushClient.fastrprint(F(" HTTP/1.1")); pushClient.fastrprint(F("\n")); client.fastrprint(F(" HTTP/1.1")); client.fastrprint(F("\n"));
pushClient.fastrprint(host.c_str()); pushClient.fastrprint(F("\n")); client.fastrprint(host.c_str()); client.fastrprint(F("\n"));
pushClient.fastrprint(F("Content-Type: application/json")); pushClient.fastrprint(F("\n")); client.fastrprint(F("Content-Type: application/json")); client.fastrprint(F("\n"));
pushClient.fastrprint(F("Content-Length: ")); client.fastrprint(F("Content-Length: "));
int payLength = jsonPayLoad.length() + payLoad.length() + 2; int payLength = jsonPayLoad.length() + payLoad.length() + 2;
pushClient.fastrprint(String(payLength).c_str()); pushClient.fastrprint(F("\n")); client.fastrprint(String(payLength).c_str()); client.fastrprint(F("\n"));
pushClient.fastrprint(F("\n")); client.fastrprint(F("\n"));
if(DEBUG) { if(DEBUG) {
Serial.print("POST "); Serial.print("POST ");
@ -43,41 +38,45 @@ void pushData(){
Serial.println(); Serial.println();
} }
int chunkSize = 50; int chunkSize = 50;
for (int i = 0; i < jsonPayLoad.length(); i++) { for (int i = 0; i < jsonPayLoad.length(); i++) {
if ( (i+1)*chunkSize > jsonPayLoad.length()) { if ( (i+1)*chunkSize > jsonPayLoad.length()) {
pushClient.print(jsonPayLoad.substring(i*chunkSize, jsonPayLoad.length())); client.print(jsonPayLoad.substring(i*chunkSize, jsonPayLoad.length()));
if(DEBUG) Serial.print(jsonPayLoad.substring(i*chunkSize, jsonPayLoad.length())); if(DEBUG) Serial.print(jsonPayLoad.substring(i*chunkSize, jsonPayLoad.length()));
i = jsonPayLoad.length(); i = jsonPayLoad.length();
} else { } else {
pushClient.print(jsonPayLoad.substring(i*chunkSize, (i+1)*chunkSize)); client.print(jsonPayLoad.substring(i*chunkSize, (i+1)*chunkSize));
if(DEBUG) Serial.print(jsonPayLoad.substring(i*chunkSize, (i+1)*chunkSize)); if(DEBUG) Serial.print(jsonPayLoad.substring(i*chunkSize, (i+1)*chunkSize));
} }
} }
for (int i = 0; i < payLoad.length(); i++) { for (int i = 0; i < payLoad.length(); i++) {
if ( (i+1)*chunkSize > payLoad.length()) { if ( (i+1)*chunkSize > payLoad.length()) {
pushClient.print(payLoad.substring(i*chunkSize, payLoad.length())); client.print(payLoad.substring(i*chunkSize, payLoad.length()));
if(DEBUG) Serial.print(payLoad.substring(i*chunkSize, payLoad.length())); if(DEBUG) Serial.print(payLoad.substring(i*chunkSize, payLoad.length()));
i = payLoad.length(); i = payLoad.length();
} else { } else {
pushClient.print(payLoad.substring(i*chunkSize, (i+1)*chunkSize)); client.print(payLoad.substring(i*chunkSize, (i+1)*chunkSize));
if(DEBUG) Serial.print(payLoad.substring(i*chunkSize, (i+1)*chunkSize)); if(DEBUG) Serial.print(payLoad.substring(i*chunkSize, (i+1)*chunkSize));
} }
} }
pushClient.fastrprint(F("\r\n")); client.fastrprint(F("\r\n"));
if(DEBUG) Serial.println(); if(DEBUG) Serial.println();
delay(1000); delay(100);
client.flush();
if(true) { client.close();
while (pushClient.available()) { wdt_reset();
char response = pushClient.read(); // if(true) {
if(DEBUG) Serial.print(response); // while (client.available()) {
} // char response = client.read();
} // if(DEBUG) Serial.print(response);
// }
// }
if(DEBUG) { if(DEBUG) {
Serial.println(); Serial.println();
@ -90,3 +89,98 @@ void pushData(){
double getTemperature(){
int chk = DHT.read11(TEMP_PIN);
if(DEBUG){
Serial.println("-------------------------------");
Serial.println("Type,\tstatus,\tHumidity (%),\tTemperature (C)");
Serial.print("DHT11, \t");
switch (chk)
{
case DHTLIB_OK:
Serial.print("OK,\t");
break;
case DHTLIB_ERROR_CHECKSUM:
Serial.print("Checksum error,\t");
break;
case DHTLIB_ERROR_TIMEOUT:
Serial.print("Time out error,\t");
break;
case DHTLIB_ERROR_CONNECT:
Serial.print("Connect error,\t");
break;
case DHTLIB_ERROR_ACK_L:
Serial.print("Ack Low error,\t");
break;
case DHTLIB_ERROR_ACK_H:
Serial.print("Ack High error,\t");
break;
default:
Serial.print("Unknown error,\t");
break;
}
// DISPLAY DATA
Serial.print("\t");
Serial.print(DHT.temperature, 1);
Serial.print(",\t\t");
Serial.println(DHT.humidity, 1);
Serial.println("-------------------------------");
}
temperature= DHT.temperature;
}
void getSonar()
{
long duration, inches, cm;
pinMode(SONAR_TRIG, OUTPUT);// attach pin 3 to Trig
digitalWrite(SONAR_TRIG, LOW);
delayMicroseconds(2);
digitalWrite(SONAR_TRIG, HIGH);
delayMicroseconds(5);
digitalWrite(SONAR_TRIG, LOW);
pinMode (SONAR_ECHO, INPUT);//attach pin 4 to Echo
duration = pulseIn(SONAR_ECHO, HIGH);
// convert the time into a distance
inches = microsecondsToInches(duration);
cm = microsecondsToCentimeters(duration);
if(DEBUG){
Serial.print("SONAR : ");
Serial.print(cm);
Serial.print(" , ");
Serial.println(inches);
Serial.println("-----------------------------------");
}
if (cm > MAX_DISTANCE || cm <= 0){
//Serial.println("Out of range");
noTone(BUZZER);
} else {
tone(BUZZER, BUZZER_SOUND);
sonar= (uint8_t)cm;
}
}
long microsecondsToInches(long microseconds){
return microseconds / 74 / 2;
}
long microsecondsToCentimeters(long microseconds){
return microseconds / 29 / 2;
}

@ -1,37 +1,27 @@
#ifndef SenseBotWifiAgent_H #ifndef ArduinoWifiAgent_H
#define SenseBotWifiAgent_H #define ArduinoWifiAgent_H
#if (ARDUINO >= 100) #include "Arduino.h"
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
// These are the interrupt and control pins // These are the interrupt and control pins
#define ADAFRUIT_CC3000_IRQ 3 // MUST be an interrupt pin! #define ADAFRUIT_CC3000_IRQ 3 // MUST be an interrupt pin!
// These can be any two pins
#define ADAFRUIT_CC3000_VBAT 5 #define ADAFRUIT_CC3000_VBAT 5
#define ADAFRUIT_CC3000_CS 10 #define ADAFRUIT_CC3000_CS 10
#define WLAN_SSID "YourAccessPointSSID" // cannot be longer than 32 characters! #define WLAN_SSID "SSID" // cannot be longer than 32 characters!
#define WLAN_PASS "APPassword" #define WLAN_PASS "password"
#define WLAN_SECURITY WLAN_SEC_WPA2 #define WLAN_SECURITY WLAN_SEC_WPA
// Security can be WLAN_SEC_UNSEC, WLAN_SEC_WEP, WLAN_SEC_WPA or WLAN_SEC_WPA2 // 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_OWNER "${DEVICE_OWNER}"
#define DEVICE_ID "${DEVICE_ID}" #define DEVICE_ID "${DEVICE_ID}"
#define DEVICE_TOKEN "${DEVICE_TOKEN}"
/********************************************************************************************** #define SERVICE_PORT 9763
The following two parameters are used when pushing data via the API in the API Manager #define SERVICE_EPOINT "/sensebot/controller/"
***********************************************************************************************/
#define SERVICE_PORT 8281
#define SERVICE_EPOINT "/sensebotdata/1.0/controller/"
/**********************************************************************************************
Use the following two parameters when pushing data directly to the JAX-RS Service
***********************************************************************************************/
//#define SERVICE_PORT 9763
//#define SERVICE_EPOINT "/sensebot/controller/"
#define BUZZER A0 #define BUZZER A0
#define LDR_PIN A1 #define LDR_PIN A1
@ -45,27 +35,40 @@
#define TURN_DELAY 100 #define TURN_DELAY 100
#define LISTEN_PORT 80 // What TCP port to listen on for connections. #define PUSH_INTERVAL 30000
// The HTTP protocol uses port 80 by default.
#define MAX_ACTION 6 // Maximum length of the HTTP action that can be parsed. #define MAX_ACTION 6 // Maximum length of the HTTP action that can be parsed.
#define MAX_PATH 10 // Maximum length of the HTTP request path that can be parsed. #define MAX_PATH 10
// There isn't much memory available so keep this short!
#define BUFFER_SIZE MAX_ACTION + MAX_PATH + 10 // Size of buffer for incoming request data. #define BUFFER_SIZE MAX_ACTION + MAX_PATH + 10 // Size of buffer for incoming request data.
// Since only the first line is parsed this
// needs to be as large as the maximum action
// and path plus a little for whitespace and
// HTTP version.
#define TIMEOUT_MS 500 // Amount of time in milliseconds to wait for #define TIMEOUT_MS 500
// an incoming request to finish. Don't set this
// too high or your server could be slow to respond.
#define DEBUG false #define DEBUG false
#define CON_DEBUG true #define CON_DEBUG false
byte server[4] = { 192, 168, 1, 101 };
String host, jsonPayLoad;
unsigned long pushTimestamp = 0;
unsigned long pollTimestamp = 0;
#define LISTEN_PORT 80
byte motion_global = 0;
byte temperature = 0;
int pir =0;
int sonar=0;
int ldr =0;
const byte motor_left[] = {7, 8};
const byte enA = 12;
const byte motor_right[] = {4, 6};
const byte enB = 11;
String urlPath;
#endif #endif

@ -1,133 +1,76 @@
#include "SenseBotWifiAgent.h" #include "SenseBotWifiAgent.h"
#include <Adafruit_CC3000.h> #include <Adafruit_CC3000.h>
#include <avr/wdt.h>
#include <SPI.h> #include <SPI.h>
#include <avr/wdt.h>
#include "dht.h" #include "dht.h"
#include <pt.h>
Adafruit_CC3000 cc3000 = Adafruit_CC3000(ADAFRUIT_CC3000_CS, ADAFRUIT_CC3000_IRQ, ADAFRUIT_CC3000_VBAT, Adafruit_CC3000 cc3000 = Adafruit_CC3000(ADAFRUIT_CC3000_CS, ADAFRUIT_CC3000_IRQ, ADAFRUIT_CC3000_VBAT,
SPI_CLOCK_DIVIDER); // you can change this clock speed SPI_CLOCK_DIVIDER); // you can change this clock speed
Adafruit_CC3000_Client pushClient; Adafruit_CC3000_Client client;
Adafruit_CC3000_Server httpServer(LISTEN_PORT); Adafruit_CC3000_Server httpServer(LISTEN_PORT);
static struct pt pushThread;
int motor_left[] = {7, 8};
int enA = 12;
int motor_right[] = {4, 6};
int enB = 11;
int motion_global = 0;
/**********************************************************************************************
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 'EUHackothonRobot.h.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
***********************************************************************************************/
uint32_t sserver; uint32_t sserver;
byte server[4] = { XX, XX, XX, XX };
String host, jsonPayLoad;
dht DHT; dht DHT;
void setup()
{
if(CON_DEBUG) Serial.begin(9600);
pinMode(PIR_PIN, INPUT);
void setup() { pinMode(LDR_PIN, INPUT);
Serial.begin(115200); pinMode(TEMP_PIN, INPUT);
pinMode(PIR_PIN, INPUT); for(int i = 0; i < 2; i++){
pinMode(motor_left[i], OUTPUT);
for(int i = 0; i < 2; i++){ pinMode(motor_right[i], OUTPUT);
pinMode(motor_left[i], OUTPUT);
pinMode(motor_right[i], OUTPUT);
}
pinMode(enA, OUTPUT);
pinMode(enB, OUTPUT);
digitalWrite(enA, 100);
digitalWrite(enB, 100);
motor_stop();
PT_INIT(&pushThread);
connectHttp();
setupResource();
wdt_enable(WDTO_4S);
}
void loop() {
protothread1(&pushThread, 1000);
// listen();
// wdt_reset();
// Check connection
if( !cc3000.checkConnected() ){
while(1){
} }
}
wdt_reset(); pinMode(enA, OUTPUT);
drive(); pinMode(enB, OUTPUT);
digitalWrite(enA, 100);
} digitalWrite(enB, 100);
motor_stop();
do{
connectHttp();
}while( !cc3000.checkConnected() );
void drive(){ setupResource();
switch(motion_global){ httpServer.begin();
case 1 : drive_forward(); wdt_enable(WDTO_8S);
break;
case 2 : drive_backward();
break;
case 3 : turn_left();
break;
case 4 : turn_right();
break;
case 5 :
motor_stop();
break;
}
} }
void loop()
{
while( !cc3000.checkConnected() ){
connectHttp();
void updateDirectionVariable(int motionDir){ }
motion_global = motionDir;
}
static int protothread1(struct pt *pt, int interval) {
PT_BEGIN(pt);
while(1) { // never stop
/* each time the function is called the second boolean
* argument "millis() - timestamp > interval" is re-evaluated
* and if false the function exits after that. */
PT_WAIT_UNTIL(pt, listen() );
if (pushClient.connected()) { if(millis() - pollTimestamp > TURN_DELAY){
// batches all the required pin values together and pushes once
// Pushes data in 1 second interval
pushData();
wdt_reset(); wdt_reset();
} else { readControls();
pushClient.close(); drive();
cc3000.disconnect(); pollTimestamp = millis();
connectHttp();
}
}
PT_END(pt);
}
}
//Serial.println(F("looping"));
getTemperature();
pir =digitalRead(PIR_PIN);
getSonar();
ldr =analogRead(LDR_PIN);
if(millis() - pushTimestamp > PUSH_INTERVAL){
wdt_reset();
while (!client.connected()) {
setupClient();
}
pushData();
// Serial.print("looping");
pushTimestamp = millis();
}
wdt_reset();
}

@ -1,107 +0,0 @@
//int motionSense(){
// int motionDetect = digitalRead(PIR_PIN);
// if(DEBUG){
// Serial.print("MOTION : ");
// Serial.println(motionDetect);
// }
// return motionDetect;
//}
//int lightSense(){
// int lightLevel = analogRead(LDR_PIN);
// if(DEBUG){
// Serial.print("LIGHT : ");
// Serial.println(lightLevel);
// }
// return lightLevel;
//}
double getTemperature(){
int chk = DHT.read11(TEMP_PIN);
if(DEBUG){
Serial.println("-------------------------------");
Serial.println("Type,\tstatus,\tHumidity (%),\tTemperature (C)");
Serial.print("DHT11, \t");
switch (chk)
{
case DHTLIB_OK:
Serial.print("OK,\t");
break;
case DHTLIB_ERROR_CHECKSUM:
Serial.print("Checksum error,\t");
break;
case DHTLIB_ERROR_TIMEOUT:
Serial.print("Time out error,\t");
break;
case DHTLIB_ERROR_CONNECT:
Serial.print("Connect error,\t");
break;
case DHTLIB_ERROR_ACK_L:
Serial.print("Ack Low error,\t");
break;
case DHTLIB_ERROR_ACK_H:
Serial.print("Ack High error,\t");
break;
default:
Serial.print("Unknown error,\t");
break;
}
// DISPLAY DATA
Serial.print("\t");
Serial.print(DHT.temperature, 1);
Serial.print(",\t\t");
Serial.println(DHT.humidity, 1);
Serial.println("-------------------------------");
}
return DHT.temperature;
}
int getSonar()
{
long duration, inches, cm;
pinMode(SONAR_TRIG, OUTPUT);// attach pin 3 to Trig
digitalWrite(SONAR_TRIG, LOW);
delayMicroseconds(2);
digitalWrite(SONAR_TRIG, HIGH);
delayMicroseconds(5);
digitalWrite(SONAR_TRIG, LOW);
pinMode (SONAR_ECHO, INPUT);//attach pin 4 to Echo
duration = pulseIn(SONAR_ECHO, HIGH);
// convert the time into a distance
inches = microsecondsToInches(duration);
cm = microsecondsToCentimeters(duration);
if(DEBUG){
Serial.print("SONAR : ");
Serial.print(cm);
Serial.print(" , ");
Serial.println(inches);
Serial.println("-----------------------------------");
}
if (cm > MAX_DISTANCE || cm <= 0){
//Serial.println("Out of range");
noTone(BUZZER);
return -1;
} else {
tone(BUZZER, BUZZER_SOUND);
return cm;
}
}
long microsecondsToInches(long microseconds){
return microseconds / 74 / 2;
}
long microsecondsToCentimeters(long microseconds){
return microseconds / 29 / 2;
}

@ -372,6 +372,11 @@
<artifactId>org.wso2.carbon.device.mgt.iot.arduino.impl</artifactId> <artifactId>org.wso2.carbon.device.mgt.iot.arduino.impl</artifactId>
<version>${carbon.iot.device.mgt.version}</version> <version>${carbon.iot.device.mgt.version}</version>
</dependency> </dependency>
<dependency>
<groupId>org.wso2.carbon.iot</groupId>
<artifactId>org.wso2.carbon.device.mgt.iot.android.impl</artifactId>
<version>${carbon.iot.device.mgt.version}</version>
</dependency>
<dependency> <dependency>
<groupId>org.wso2.carbon.iot</groupId> <groupId>org.wso2.carbon.iot</groupId>
<artifactId>org.wso2.carbon.device.mgt.iot.digitaldisplay.impl</artifactId> <artifactId>org.wso2.carbon.device.mgt.iot.digitaldisplay.impl</artifactId>

Loading…
Cancel
Save