community
/
product-iots
10
0
Fork 4
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Few tweaks on fire alarm, arduino and sensebot after testing

Browse Source
merge-requests/1/head
ayyoob 10 years ago
parent 92358c4135
commit bbd09ae509
20 changed files with 848 additions and 1246 deletions
Show Stats Download Patch File Download Diff File

47
modules/distribution/src/sketches/arduino/ArduinoBoardSketch.h
Unescape View File

@ -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 "linksys" // cannot be longer than 32 characters!
#define WLAN_PASS "ramsgate717"
#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

89
modules/distribution/src/sketches/arduino/ArduinoBoardSketch.ino
Unescape View File

@ -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(); cpuTemperature=getBoardTemp();
delay(POLL_INTERVAL);
boolean valid = readControls();
responseMsg=""; if(millis() - pushTimestamp > PUSH_INTERVAL){
} else { while (!client.connected()) {
if(DEBUG) { setupClient();
Serial.println("client not found...");
Serial.println("disconnecting.");
} }
pushClient.close(); pushData();
pollClient.close();
cc3000.disconnect();
connectHttp(); pushTimestamp = millis();
} }
//Serial.println("PUSHED");
delay(1000);
}
if(millis() - pollTimestamp > POLL_INTERVAL){
while (!client.connected()) {
setupClient();
}
readControls();
pollTimestamp = millis();
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. //Serial.println("LOOPING");
return (t); wdt_reset();
} }

39
modules/distribution/src/sketches/arduino/Arduinoboardwifi.h
Unescape View File

@ -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

71
modules/distribution/src/sketches/arduino/Connect.ino
Unescape View File

@ -1,4 +1,5 @@
/********************************************************************************************** #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 };
@ -11,8 +12,8 @@
// 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() {
@ -24,28 +25,28 @@ void connectHttp() {
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
/***********************************************************************************************/ /***********************************************************************************************/
@ -74,22 +75,15 @@ void connectHttp() {
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("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("-------------------------------------"));
} }
@ -148,3 +142,16 @@ bool displayConnectionDetails(void)
return true; 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"));
}
}

37
modules/distribution/src/sketches/arduino/PollServer.ino
Unescape View File

@ -1,26 +1,25 @@
boolean readControls() { #include "ArduinoBoardSketch.h"
// String responseMsg; void readControls() {
// String responseMsg;
pollClient.fastrprint(F("GET "));
pollClient.fastrprint(SERVICE_EPOINT); client.fastrprint(F("GET "));
pollClient.fastrprint(F("readcontrols/")); client.fastrprint(SERVICE_EPOINT);
pollClient.fastrprint(DEVICE_ID); client.fastrprint(F("readcontrols/"));
pollClient.fastrprint(F("?owner=")); client.fastrprint(DEVICE_ID);
pollClient.fastrprint(DEVICE_OWNER); client.fastrprint(F("?owner="));
pollClient.fastrprint(F(" HTTP/1.1")); pollClient.fastrprint(F("\n")); client.fastrprint(DEVICE_OWNER);
pollClient.fastrprint(host.c_str()); pollClient.fastrprint(F("\n")); client.fastrprint(F(" HTTP/1.1")); client.fastrprint(F("\n"));
pollClient.println(); client.fastrprint(host.c_str()); client.fastrprint(F("\n"));
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 index = responseMsg.lastIndexOf(":");
int newLine = responseMsg.lastIndexOf("\n"); int newLine = responseMsg.lastIndexOf("\n");
subStrn = responseMsg.substring(index + 1); subStrn = responseMsg.substring(index + 1);
@ -42,14 +41,8 @@ boolean readControls() {
digitalWrite(6, LOW); digitalWrite(6, LOW);
} }
if (responseMsg.equals("BULB")) {
return false;
}
return true;
} }

86
modules/distribution/src/sketches/arduino/PushData.ino
Unescape View File

@ -1,86 +0,0 @@
/**********************************************************************************************
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(){
String payLoad = "Data";
payLoad = payLoad + "\",\"value\":\"";
payLoad+=getBoardTemp();
payLoad += "\"}";
pushClient.fastrprint(F("POST "));
pushClient.fastrprint(SERVICE_EPOINT); pushClient.fastrprint(F("pushdata"));
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("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();
}
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);
while (pushClient.available()) {
char response = pushClient.read();
if(DEBUG) Serial.print(response);
}
if(DEBUG) {
Serial.println();
Serial.println("-------------------------------");
}
payLoad = "";
}

121
modules/distribution/src/sketches/firealarm_wifi/Connect.ino
Unescape View File

@ -1,4 +1,5 @@
/**********************************************************************************************
/**********************************************************************************************
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 };
@ -10,14 +11,14 @@
// 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
// b8:27:eb:88:37:7a
uint32_t ipAddress;
String connecting = "connecting.... ";
void connectWifi() { //mac - c0:4a:00:1a:08:da
/* Initialise the module */ // c0:4a:00:1a:03:f8
// b8:27:eb:88:37:7a
void connectHttp() {
/* Initialise the module */
if(DEBUG) Serial.println(F("\nInitializing...")); if(DEBUG) Serial.println(F("\nInitializing..."));
if (!cc3000.begin()) if (!cc3000.begin())
{ {
@ -25,28 +26,28 @@ void connectWifi() {
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
/***********************************************************************************************/ /***********************************************************************************************/
@ -62,11 +63,9 @@ void connectWifi() {
while(1); while(1);
} }
wdt_reset();
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!
@ -77,42 +76,16 @@ void connectWifi() {
delay(1000); delay(1000);
} }
wdt_reset();
// deviceIP = String((uint8_t)(ipAddress >> 24)) + "."
// + String((uint8_t)(ipAddress >> 16)) + "."
// + String((uint8_t)(ipAddress >> 8)) + "."
// + String((uint8_t)ipAddress);
if(DEBUG) {
Serial.print("(String) IP: ");
// Serial.println(deviceIP);
}
if( cc3000.checkConnected() ){
// pinMode(13, HIGH);
connectToAndUpServer();
}
}
void connectToAndUpServer() {
pushClient = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT pushClient = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT
wdt_reset();
httpServer.begin();
wdt_reset();
if(CON_DEBUG) Serial.println(F("Listening for connections..."));
if (pushClient.connected()) { if (pushClient.connected()) {
registerIP(); if(true) Serial.println(F("pushClient Connected to server"));
wdt_reset();
if(CON_DEBUG) Serial.println("PushClient Connected to server");
} else { } else {
if(CON_DEBUG) Serial.println(F("PushClient Connection failed")); if(CON_DEBUG) Serial.println(F("pushClient Connection failed"));
reconnectInterval = millis();
} }
if(CON_DEBUG) Serial.println(F("-------------------------------------")); if(CON_DEBUG) Serial.println(F("-------------------------------------"));
} }
@ -120,14 +93,14 @@ void connectToAndUpServer() {
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) {
@ -137,6 +110,7 @@ void setupResource(){
} }
} }
String getHostIP(byte server[4]){ String getHostIP(byte server[4]){
String hostIP = String(server[0]); String hostIP = String(server[0]);
@ -161,12 +135,25 @@ bool displayConnectionDetails(void)
{ {
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; 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"));
}
}

25
modules/distribution/src/sketches/firealarm_wifi/FireAlarmWifiAgent.h
Unescape View File

@ -32,27 +32,38 @@
// too high or your server could be slow to respond. // too high or your server could be slow to respond.
//#define WLAN_SSID "YourAP-SSID" // cannot be longer than 32 characters!
//#define WLAN_PASS "Your-Password"
#define WLAN_SECURITY WLAN_SEC_WPA2
#define WLAN_SSID "linksys" // cannot be longer than 32 characters!
#define WLAN_PASS "ramsgate717"
#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/"
#define TEMP_PIN A5 #define TEMP_PIN A5
#define BULB_PIN A4 #define BULB_PIN A4
#define FAN_PIN A3 #define FAN_PIN A3
#define DEBUG false #define DEBUG false
#define CON_DEBUG true #define CON_DEBUG true
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 #endif

139
modules/distribution/src/sketches/firealarm_wifi/FireAlarmWifiAgent.ino
Unescape View File

@ -4,153 +4,78 @@
#include <avr/wdt.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_Server httpServer(LISTEN_PORT); Adafruit_CC3000_Server httpServer(LISTEN_PORT);
static struct pt pushThread;
static unsigned long reconnectInterval = 0;
static unsigned long pushInterval = 0;
//String deviceIP;
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
***********************************************************************************************/ ***********************************************************************************************/
//byte server[4] = { 10, 100, 7, 38 };
byte server[4] = { 192, 168, 2, 1 };
int digitalPins[] = { TEMP_PIN, BULB_PIN, FAN_PIN };
String host, jsonPayLoad;
String responseMsg, subStrn;
void setup() { void setup() {
if(CON_DEBUG) Serial.begin(115200); if (CON_DEBUG) Serial.begin(9600);
pinMode(BULB_PIN, OUTPUT); pinMode(BULB_PIN, OUTPUT);
pinMode(FAN_PIN, OUTPUT); pinMode(FAN_PIN, OUTPUT);
// pinMode(13, OUTPUT); pinMode(TEMP_PIN, INPUT);
PT_INIT(&pushThread);
setupResource(); setupResource();
while( !cc3000.checkConnected() ){ do {
connectWifi(); connectHttp();
} while (!cc3000.checkConnected());
while (!pushClient.connected()) {
setupClient();
} }
registerIP();
httpServer.begin();
wdt_enable(WDTO_8S); wdt_enable(WDTO_8S);
} }
void loop() { void loop() {
while (!cc3000.checkConnected()) {
connectHttp();
}
wdt_reset();
if (millis() - pushTimestamp > PUSH_INTERVAL) {
wdt_reset();
while (!pushClient.connected()) {
setupClient();
}
pushData();
pushTimestamp = millis();
}
readControls();
wdt_reset(); wdt_reset();
protothread1(&pushThread); // Pushes data and waits for control signals to be received
if ( subStrn.equals("ON") ) { if (subStrn.equals("ON")) {
if (responseMsg.equals("BULB")) { if (responseMsg.equals("BULB")) {
digitalWrite(BULB_PIN, HIGH); digitalWrite(BULB_PIN, HIGH);
} else if (responseMsg.equals("FAN")) { } else if (responseMsg.equals("FAN")) {
digitalWrite(FAN_PIN, HIGH); digitalWrite(FAN_PIN, HIGH);
} }
} else if ( subStrn.equals("OFF") ) { } else if (subStrn.equals("OFF")) {
if (responseMsg.equals("BULB")) { if (responseMsg.equals("BULB")) {
digitalWrite(BULB_PIN, LOW); digitalWrite(BULB_PIN, LOW);
} else if (responseMsg.equals("FAN")) { } else if (responseMsg.equals("FAN")) {
digitalWrite(FAN_PIN, LOW); 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;
}
static int protothread1(struct pt *pt) {
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, listen() );
if (pushClient.connected()) {
if ((millis() - pushInterval) > 2000) {
pushData();
pushInterval = millis();
wdt_reset(); wdt_reset();
}
} else {
if(DEBUG) {
Serial.println("client not found...");
Serial.println("disconnecting.");
}
pushClient.flush();
if(CON_DEBUG) Serial.println("Disconnection!!!!");
if ( (millis() - reconnectInterval) > 3000 ) {
if (cc3000.checkConnected()) {
connectToAndUpServer();
} else {
// pinMode(13, LOW);
while(1);
}
}
}
}
PT_END(pt);
} }

34
modules/distribution/src/sketches/firealarm_wifi/Listener.ino
Unescape View File

@ -1,17 +1,13 @@
uint8_t buffer[BUFFER_SIZE+1]; uint8_t buffer[BUFFER_SIZE + 1];
int bufindex = 0; 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 +33,7 @@ boolean listen() {
if (strcmp(action, "GET") == 0) { if (strcmp(action, "GET") == 0) {
responseMsg = path; responseMsg = path;
if(DEBUG) { if (DEBUG) {
Serial.println(responseMsg); Serial.println(responseMsg);
} }
@ -46,7 +42,7 @@ boolean listen() {
subStrn = responseMsg.substring(index + 1); subStrn = responseMsg.substring(index + 1);
responseMsg = responseMsg.substring(newLine + 1, index); responseMsg = responseMsg.substring(newLine + 1, index);
if(DEBUG) { if (DEBUG) {
Serial.print(responseMsg); Serial.print(responseMsg);
Serial.print(" - "); Serial.print(" - ");
Serial.println(subStrn); Serial.println(subStrn);
@ -55,7 +51,7 @@ boolean listen() {
} }
if (responseMsg == "TEMP") { if (responseMsg == "TEMP") {
int temperature = (uint8_t)getTemperature(); int temperature = (uint8_t) getTemperature();
client.fastrprintln(F("HTTP/1.1 200 OK")); client.fastrprintln(F("HTTP/1.1 200 OK"));
client.fastrprintln(F("Connection: close")); client.fastrprintln(F("Connection: close"));
@ -70,31 +66,29 @@ boolean listen() {
Serial.println(F("Client disconnected")); Serial.println(F("Client disconnected"));
client.close(); client.close();
wdt_reset(); wdt_reset();
return false;
} else {
return true;
} }
} }
bool parseRequest(uint8_t* buf, int bufSize, char* action, char* path) { 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. // Check if the request ends with \r\n to signal end of first line.
if (bufSize < 2) if (bufSize < 2)
return false; return false;
if (buf[bufSize-2] == '\r' && buf[bufSize-1] == '\n') { if (buf[bufSize - 2] == '\r' && buf[bufSize - 1] == '\n') {
parseFirstLine((char*)buf, action, path); parseFirstLine((char *) buf, action, path);
return true; return true;
} }
return false; return false;
} }
// Parse the action and path from the first line of an HTTP request. // Parse the action and path from the first line of an HTTP request.
void parseFirstLine(char* line, char* action, char* path) { void parseFirstLine(char *line, char *action, char *path) {
// Parse first word up to whitespace as action. // Parse first word up to whitespace as action.
char* lineaction = strtok(line, " "); char *lineaction = strtok(line, " ");
if (lineaction != NULL) if (lineaction != NULL)
strncpy(action, lineaction, MAX_ACTION); strncpy(action, lineaction, MAX_ACTION);
// Parse second word up to whitespace as path. // Parse second word up to whitespace as path.
char* linepath = strtok(NULL, " "); char *linepath = strtok(NULL, " ");
if (linepath != NULL) if (linepath != NULL)
strncpy(path, linepath, MAX_PATH); strncpy(path, linepath, MAX_PATH);
} }

3
modules/distribution/src/sketches/firealarm_wifi/PollServer.ino
Unescape View File

@ -26,7 +26,8 @@ void registerIP() {
Serial.print(host); Serial.println(); Serial.println(); Serial.print(host); Serial.println(); Serial.println();
} }
delay(1000); delay(100);
pushClient.flush(); pushClient.flush();
pushClient.close();
} }

80
modules/distribution/src/sketches/firealarm_wifi/PushData.ino
Unescape View File

@ -1,29 +1,15 @@
/**********************************************************************************************
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 += (uint8_t)getTemperature();
payLoad += ":"; payLoad += ":";
} payLoad += ( digitalRead(BULB_PIN) == HIGH )?"ON":"OFF";
payLoad += ":";
} payLoad += ( digitalRead(FAN_PIN) == HIGH )?"ON":"OFF";
payLoad += "\"}"; payLoad += "\"}";
pushClient.fastrprint(F("POST ")); pushClient.fastrprint(F("POST "));
@ -76,16 +62,16 @@ void pushData(){
pushClient.fastrprint(F("\n")); pushClient.fastrprint(F("\n"));
if(DEBUG) Serial.println(); if(DEBUG) Serial.println();
delay(1000); delay(100);
wdt_reset(); wdt_reset();
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) { if(DEBUG) {
Serial.println(); Serial.println();
@ -95,5 +81,49 @@ void pushData(){
payLoad = ""; payLoad = "";
} }
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;
}

0
modules/distribution/src/sketches/firealarm_wifi/sketch.properties
Unescape View File

92
modules/distribution/src/sketches/sensebot_wifi/Connect.ino
Unescape View File

@ -1,4 +1,5 @@
/**********************************************************************************************
/**********************************************************************************************
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 };
@ -10,10 +11,11 @@
// 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 */
@ -24,28 +26,28 @@ void connectHttp() {
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
/***********************************************************************************************/ /***********************************************************************************************/
@ -63,7 +65,7 @@ void connectHttp() {
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!
@ -74,17 +76,15 @@ void connectHttp() {
delay(1000); delay(1000);
} }
pushClient = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT client = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT
if (client.connected()) {
if (pushClient.connected()) { if(true) Serial.println(F("client Connected to server"));
if(CON_DEBUG) Serial.println("PushClient 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"));
} }
httpServer.begin();
Serial.println(F("Listening for connections..."));
if(CON_DEBUG) Serial.println(F("-------------------------------------")); if(CON_DEBUG) Serial.println(F("-------------------------------------"));
} }
@ -93,14 +93,14 @@ void connectHttp() {
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) {
@ -110,6 +110,7 @@ void setupResource(){
} }
} }
String getHostIP(byte server[4]){ String getHostIP(byte server[4]){
String hostIP = String(server[0]); String hostIP = String(server[0]);
@ -134,12 +135,25 @@ bool displayConnectionDetails(void)
{ {
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; 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"));
}
}

23
modules/distribution/src/sketches/sensebot_wifi/MotorControls.ino → modules/distribution/src/sketches/sensebot_wifi/Drive.ino
Unescape View File

@ -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;
}
}

21
modules/distribution/src/sketches/sensebot_wifi/Listener.ino → modules/distribution/src/sketches/sensebot_wifi/HttpServer.ino
Unescape View File

@ -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;
} }
} }

92
modules/distribution/src/sketches/sensebot_wifi/PushData.ino
Unescape View File

@ -1,92 +0,0 @@
/**********************************************************************************************
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(){
String payLoad = "Data";
payLoad = payLoad + "\",\"value\":\"";
int temperature = (uint8_t)getTemperature();
payLoad += temperature;
payLoad += ":";
payLoad += digitalRead(PIR_PIN);
payLoad += ":";
payLoad += getSonar(); // returns distance if < MAX_DISTANCE else returns -1,
// Pushed accordingly inside JAX-RS
payLoad += ":";
payLoad += analogRead(LDR_PIN);
payLoad += "\"}";
pushClient.fastrprint(F("POST "));
pushClient.fastrprint(SERVICE_EPOINT); pushClient.fastrprint(F("pushsensordata"));
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() + 2;
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("pushsensordata");
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("\r\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 = "";
}

75
modules/distribution/src/sketches/sensebot_wifi/SenseBotWifiAgent.h
Unescape View File

@ -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 "linksys" // cannot be longer than 32 characters!
#define WLAN_PASS "APPassword" #define WLAN_PASS "ramsgate717"
#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

121
modules/distribution/src/sketches/sensebot_wifi/SenseBotWifiAgent.ino
Unescape View File

@ -1,49 +1,24 @@
#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);
void setup() {
Serial.begin(115200);
pinMode(PIR_PIN, INPUT); pinMode(PIR_PIN, INPUT);
pinMode(LDR_PIN, INPUT);
pinMode(TEMP_PIN, INPUT);
for(int i = 0; i < 2; i++){ for(int i = 0; i < 2; i++){
pinMode(motor_left[i], OUTPUT); pinMode(motor_left[i], OUTPUT);
pinMode(motor_right[i], OUTPUT); pinMode(motor_right[i], OUTPUT);
@ -55,79 +30,47 @@ void setup() {
digitalWrite(enB, 100); digitalWrite(enB, 100);
motor_stop(); motor_stop();
PT_INIT(&pushThread); do{
connectHttp(); connectHttp();
}while( !cc3000.checkConnected() );
setupResource(); setupResource();
wdt_enable(WDTO_4S); httpServer.begin();
wdt_enable(WDTO_8S);
} }
void loop()
{
while( !cc3000.checkConnected() ){
connectHttp();
void loop() {
protothread1(&pushThread, 1000);
// listen();
// wdt_reset();
// Check connection
if( !cc3000.checkConnected() ){
while(1){
}
} }
if(millis() - pollTimestamp > TURN_DELAY){
wdt_reset(); wdt_reset();
readControls();
drive(); drive();
pollTimestamp = millis();
}
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;
} }
} //Serial.println(F("looping"));
getTemperature();
pir =digitalRead(PIR_PIN);
void updateDirectionVariable(int motionDir){ getSonar();
motion_global = motionDir; ldr =analogRead(LDR_PIN);
}
if(millis() - pushTimestamp > PUSH_INTERVAL){
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()) {
// batches all the required pin values together and pushes once
// Pushes data in 1 second interval
pushData();
wdt_reset(); wdt_reset();
} else { while (!client.connected()) {
pushClient.close(); setupClient();
cc3000.disconnect();
connectHttp();
} }
pushData();
// Serial.print("looping");
pushTimestamp = millis();
} }
PT_END(pt);
}
wdt_reset();
}

107
modules/distribution/src/sketches/sensebot_wifi/Sensors.ino
Unescape View File

@ -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;
}
Write Preview
Loading…
Cancel
Save