Few tweaks on fire alarm, arduino and sensebot after testing

merge-requests/1/head
ayyoob 10 years ago
parent 92358c4135
commit bbd09ae509

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

@ -1,99 +1,56 @@
#include "Arduinoboardwifi.h"
#include "ArduinoBoardSketch.h"
#include <Adafruit_CC3000.h>
#include <SPI.h>
#include <avr/wdt.h>
Adafruit_CC3000 cc3000 = Adafruit_CC3000(ADAFRUIT_CC3000_CS, ADAFRUIT_CC3000_IRQ, ADAFRUIT_CC3000_VBAT,
SPI_CLOCK_DIVIDER); // you can change this clock speed
Adafruit_CC3000_Client pushClient;
Adafruit_CC3000_Client pollClient;
Adafruit_CC3000_Client client;
uint32_t sserver;
/**********************************************************************************************
0. Check with a sample Wifi code of the Adafruit_CC3000 library to ensure that the sheild is working
1. Set the ip of the server(byte array below) where the Web-Rest API for the FireAlarm is running
2. Check whether the "SERVICE_EPOINT" is correct in the 'FireAlarmWifiAgent.h' file
3. Check whether the "SERVICE_PORT" is the same (9763) for the server running. Change it if needed
4. Check whether the pins have been attached accordingly in the Arduino
5. Check whether all reqquired pins are added to the 'digitalPins' array
***********************************************************************************************/
byte server[4] = { 192, 168, 1, 101 };
String host, jsonPayLoad, replyMsg;
String responseMsg, subStrn;
void setup()
{
Serial.begin(9600);
Serial.println(F("Internal Temperature Sensor"));
pinMode(6, OUTPUT);
connectHttp();
setupResource();
wdt_enable(WDTO_8S);
}
void loop()
{
while( !cc3000.checkConnected() ){
connectHttp();
if (pushClient.connected() && pollClient.connected()) {
pushData();
delay(POLL_INTERVAL);
}
cpuTemperature=getBoardTemp();
boolean valid = readControls();
responseMsg="";
} else {
if(DEBUG) {
Serial.println("client not found...");
Serial.println("disconnecting.");
if(millis() - pushTimestamp > PUSH_INTERVAL){
while (!client.connected()) {
setupClient();
}
pushClient.close();
pollClient.close();
cc3000.disconnect();
pushData();
connectHttp();
pushTimestamp = millis();
}
delay(1000);
}
//Serial.println("PUSHED");
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.
return (t);
//Serial.println("LOOPING");
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,4 +1,5 @@
/**********************************************************************************************
#include "ArduinoBoardSketch.h"
/**********************************************************************************************
Use the below variables when required to set a static IP for the WifiSheild
***********************************************************************************************/
// byte dns2[] = { 8, 8, 8, 8 };
@ -11,8 +12,8 @@
// 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
// c0:4a:00:1a:03:f8
// b8:27:eb:88:37:7a
String connecting = "connecting.... ";
void connectHttp() {
@ -24,28 +25,28 @@ void connectHttp() {
while(1);
}
// if( cc3000.setMacAddress(mac) ) { // Set your own mac and print it to re-check
// uint8_t address[6];
// cc3000.getMacAddress(address);
// if(DEBUG){
// Serial.print(address[0], HEX); Serial.print(":");
// Serial.print(address[1], HEX); Serial.print(":");
// Serial.print(address[2], HEX); Serial.print(":");
// Serial.print(address[3], HEX); Serial.print(":");
// Serial.print(address[4], HEX); Serial.print(":");
// Serial.println(address[5], HEX);
// }
// }
// if( cc3000.setMacAddress(mac) ) { // Set your own mac and print it to re-check
// uint8_t address[6];
// cc3000.getMacAddress(address);
// if(DEBUG){
// Serial.print(address[0], HEX); Serial.print(":");
// Serial.print(address[1], HEX); Serial.print(":");
// Serial.print(address[2], HEX); Serial.print(":");
// Serial.print(address[3], HEX); Serial.print(":");
// Serial.print(address[4], HEX); Serial.print(":");
// Serial.println(address[5], HEX);
// }
// }
/**********************************************************************************************
Only required if using static IP for the WifiSheild
***********************************************************************************************/
// ip = cc3000.IP2U32(deviceIP[0], deviceIP[1], deviceIP[2], deviceIP[3]);
// ddns = cc3000.IP2U32(dns2[0], dns2[1], dns2[2], dns2[3]);
// ssubnet = cc3000.IP2U32(subnet[0], subnet[1], subnet[2], subnet[3]);
// ggateway = cc3000.IP2U32(gateway[0], gateway[1], gateway[2], gateway[3]);
// cc3000.setStaticIPAddress(ip, ssubnet, ggateway, ddns); // required for setting static IP
// ip = cc3000.IP2U32(deviceIP[0], deviceIP[1], deviceIP[2], deviceIP[3]);
// ddns = cc3000.IP2U32(dns2[0], dns2[1], dns2[2], dns2[3]);
// ssubnet = cc3000.IP2U32(subnet[0], subnet[1], subnet[2], subnet[3]);
// ggateway = cc3000.IP2U32(gateway[0], gateway[1], gateway[2], gateway[3]);
// cc3000.setStaticIPAddress(ip, ssubnet, ggateway, ddns); // required for setting static IP
/***********************************************************************************************/
@ -74,22 +75,15 @@ void connectHttp() {
delay(1000);
}
pushClient = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT
if (pushClient.connected()) {
if(CON_DEBUG) Serial.println("PushClient Connected to server");
client = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT
if (client.connected()) {
if(CON_DEBUG) Serial.println("client Connected to server");
} else {
cc3000.disconnect();
if(CON_DEBUG) Serial.println(F("PushClient Connection failed"));
if(CON_DEBUG) Serial.println(F("client 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("-------------------------------------"));
}
@ -148,3 +142,16 @@ bool displayConnectionDetails(void)
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"));
}
}

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

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

@ -1,4 +1,5 @@
/**********************************************************************************************
/**********************************************************************************************
Use the below variables when required to set a static IP for the WifiSheild
***********************************************************************************************/
// byte dns2[] = { 8, 8, 8, 8 };
@ -10,14 +11,14 @@
// 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() {
/* Initialise the module */
//mac - c0:4a:00:1a:08:da
// c0:4a:00:1a:03:f8
// b8:27:eb:88:37:7a
void connectHttp() {
/* Initialise the module */
if(DEBUG) Serial.println(F("\nInitializing..."));
if (!cc3000.begin())
{
@ -25,28 +26,28 @@ void connectWifi() {
while(1);
}
// if( cc3000.setMacAddress(mac) ) { // Set your own mac and print it to re-check
// uint8_t address[6];
// cc3000.getMacAddress(address);
// if(DEBUG){
// Serial.print(address[0], HEX); Serial.print(":");
// Serial.print(address[1], HEX); Serial.print(":");
// Serial.print(address[2], HEX); Serial.print(":");
// Serial.print(address[3], HEX); Serial.print(":");
// Serial.print(address[4], HEX); Serial.print(":");
// Serial.println(address[5], HEX);
// }
// }
cc3000.setMacAddress(mac); // Set your own mac and print it to re-check
// uint8_t address[6];
// cc3000.getMacAddress(address);
// if(DEBUG){
// Serial.print(address[0], HEX); Serial.print(":");
// Serial.print(address[1], HEX); Serial.print(":");
// Serial.print(address[2], HEX); Serial.print(":");
// Serial.print(address[3], HEX); Serial.print(":");
// Serial.print(address[4], HEX); Serial.print(":");
// Serial.println(address[5], HEX);
// }
// }
/**********************************************************************************************
Only required if using static IP for the WifiSheild
***********************************************************************************************/
// ip = cc3000.IP2U32(deviceIP[0], deviceIP[1], deviceIP[2], deviceIP[3]);
// ddns = cc3000.IP2U32(dns2[0], dns2[1], dns2[2], dns2[3]);
// ssubnet = cc3000.IP2U32(subnet[0], subnet[1], subnet[2], subnet[3]);
// ggateway = cc3000.IP2U32(gateway[0], gateway[1], gateway[2], gateway[3]);
// cc3000.setStaticIPAddress(ip, ssubnet, ggateway, ddns); // required for setting static IP
// ip = cc3000.IP2U32(deviceIP[0], deviceIP[1], deviceIP[2], deviceIP[3]);
// ddns = cc3000.IP2U32(dns2[0], dns2[1], dns2[2], dns2[3]);
// ssubnet = cc3000.IP2U32(subnet[0], subnet[1], subnet[2], subnet[3]);
// ggateway = cc3000.IP2U32(gateway[0], gateway[1], gateway[2], gateway[3]);
// cc3000.setStaticIPAddress(ip, ssubnet, ggateway, ddns); // required for setting static IP
/***********************************************************************************************/
@ -62,11 +63,9 @@ void connectWifi() {
while(1);
}
wdt_reset();
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())
{
delay(100); // ToDo: Insert a DHCP timeout!
@ -77,42 +76,16 @@ void connectWifi() {
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
wdt_reset();
httpServer.begin();
wdt_reset();
if(CON_DEBUG) Serial.println(F("Listening for connections..."));
if (pushClient.connected()) {
registerIP();
wdt_reset();
if(CON_DEBUG) Serial.println("PushClient Connected to server");
if(true) Serial.println(F("pushClient Connected to server"));
} else {
if(CON_DEBUG) Serial.println(F("PushClient Connection failed"));
reconnectInterval = millis();
if(CON_DEBUG) Serial.println(F("pushClient Connection failed"));
}
if(CON_DEBUG) Serial.println(F("-------------------------------------"));
}
@ -120,14 +93,14 @@ void connectToAndUpServer() {
void setupResource(){
String hostIP = getHostIP(server);
String port = String(SERVICE_PORT);
//
host = "Host: " + hostIP + ":" + port;
if(DEBUG) Serial.println(host);
// if(DEBUG) Serial.println(host);
jsonPayLoad = "{\"owner\":\"";
jsonPayLoad += String(DEVICE_OWNER);
jsonPayLoad += DEVICE_OWNER;
jsonPayLoad += "\",\"deviceId\":\"";
jsonPayLoad += String(DEVICE_ID);
jsonPayLoad += DEVICE_ID;
jsonPayLoad += "\",\"reply\":\"";
if(DEBUG) {
@ -137,6 +110,7 @@ void setupResource(){
}
}
String getHostIP(byte server[4]){
String hostIP = String(server[0]);
@ -161,12 +135,25 @@ bool displayConnectionDetails(void)
{
if(CON_DEBUG) {
Serial.print(F("\nIP Addr: ")); cc3000.printIPdotsRev(ipAddress);
// Serial.print(F("\nNetmask: ")); cc3000.printIPdotsRev(netmask);
// Serial.print(F("\nGateway: ")); cc3000.printIPdotsRev(gateway);
// Serial.print(F("\nDHCPsrv: ")); cc3000.printIPdotsRev(dhcpserv);
// Serial.print(F("\nDNSserv: ")); cc3000.printIPdotsRev(dnsserv);
Serial.print(F("\nNetmask: ")); cc3000.printIPdotsRev(netmask);
Serial.print(F("\nGateway: ")); cc3000.printIPdotsRev(gateway);
Serial.print(F("\nDHCPsrv: ")); cc3000.printIPdotsRev(dhcpserv);
Serial.print(F("\nDNSserv: ")); cc3000.printIPdotsRev(dnsserv);
Serial.println();
}
return true;
}
}
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"));
}
}

@ -32,27 +32,38 @@
// 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
#define IDLE_TIMEOUT_MS 3000
#define DEVICE_OWNER "${DEVICE_OWNER}" //"SHABIRMEAN"
#define DEVICE_ID "${DEVICE_ID}" //"vbhenqyt85yq"
#define DEVICE_OWNER "${DEVICE_OWNER}"
#define DEVICE_ID "${DEVICE_ID}"
#define DEVICE_TOKEN "${DEVICE_TOKEN}"
#define SERVICE_PORT 9763
#define SERVICE_EPOINT "/firealarm/controller/"
#define TEMP_PIN A5
#define BULB_PIN A4
#define FAN_PIN A3
#define DEBUG false
#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

@ -4,153 +4,78 @@
#include <avr/wdt.h>
#include <SPI.h>
#include "dht.h"
#include <pt.h>
Adafruit_CC3000 cc3000 = Adafruit_CC3000(ADAFRUIT_CC3000_CS, ADAFRUIT_CC3000_IRQ, ADAFRUIT_CC3000_VBAT,
SPI_CLOCK_DIVIDER); // you can change this clock speed
Adafruit_CC3000_Client pushClient;
Adafruit_CC3000_Server httpServer(LISTEN_PORT);
static struct pt pushThread;
static unsigned long reconnectInterval = 0;
static unsigned long pushInterval = 0;
//String deviceIP;
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] = { 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() {
if(CON_DEBUG) Serial.begin(115200);
if (CON_DEBUG) Serial.begin(9600);
pinMode(BULB_PIN, OUTPUT);
pinMode(FAN_PIN, OUTPUT);
// pinMode(13, OUTPUT);
PT_INIT(&pushThread);
pinMode(TEMP_PIN, INPUT);
setupResource();
while( !cc3000.checkConnected() ){
connectWifi();
do {
connectHttp();
} while (!cc3000.checkConnected());
while (!pushClient.connected()) {
setupClient();
}
registerIP();
httpServer.begin();
wdt_enable(WDTO_8S);
}
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();
protothread1(&pushThread); // Pushes data and waits for control signals to be received
if ( subStrn.equals("ON") ) {
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") ) {
} 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;
}
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();
}
} 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);
}

@ -1,17 +1,13 @@
uint8_t buffer[BUFFER_SIZE+1];
uint8_t buffer[BUFFER_SIZE + 1];
int bufindex = 0;
char action[MAX_ACTION+1];
char path[MAX_PATH+1];
char action[MAX_ACTION + 1];
char path[MAX_PATH + 1];
boolean listen() {
void readControls() {
// Try to get a client which is connected.
Adafruit_CC3000_ClientRef client = httpServer.available();
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;
memset(&buffer, 0, sizeof(buffer));
@ -37,7 +33,7 @@ boolean listen() {
if (strcmp(action, "GET") == 0) {
responseMsg = path;
if(DEBUG) {
if (DEBUG) {
Serial.println(responseMsg);
}
@ -46,7 +42,7 @@ boolean listen() {
subStrn = responseMsg.substring(index + 1);
responseMsg = responseMsg.substring(newLine + 1, index);
if(DEBUG) {
if (DEBUG) {
Serial.print(responseMsg);
Serial.print(" - ");
Serial.println(subStrn);
@ -55,7 +51,7 @@ boolean listen() {
}
if (responseMsg == "TEMP") {
int temperature = (uint8_t)getTemperature();
int temperature = (uint8_t) getTemperature();
client.fastrprintln(F("HTTP/1.1 200 OK"));
client.fastrprintln(F("Connection: close"));
@ -70,31 +66,29 @@ boolean listen() {
Serial.println(F("Client disconnected"));
client.close();
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.
if (bufSize < 2)
return false;
if (buf[bufSize-2] == '\r' && buf[bufSize-1] == '\n') {
parseFirstLine((char*)buf, action, path);
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) {
void parseFirstLine(char *line, char *action, char *path) {
// Parse first word up to whitespace as action.
char* lineaction = strtok(line, " ");
char *lineaction = strtok(line, " ");
if (lineaction != NULL)
strncpy(action, lineaction, MAX_ACTION);
// Parse second word up to whitespace as path.
char* linepath = strtok(NULL, " ");
char *linepath = strtok(NULL, " ");
if (linepath != NULL)
strncpy(path, linepath, MAX_PATH);
}

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

@ -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(){
String payLoad = "Data";
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 += ( digitalRead(BULB_PIN) == HIGH )?"ON":"OFF";
payLoad += ":";
payLoad += ( digitalRead(FAN_PIN) == HIGH )?"ON":"OFF";
payLoad += "\"}";
pushClient.fastrprint(F("POST "));
@ -76,16 +62,16 @@ void pushData(){
pushClient.fastrprint(F("\n"));
if(DEBUG) Serial.println();
delay(1000);
delay(100);
wdt_reset();
if(true) {
while (pushClient.available()) {
char response = pushClient.read();
if(DEBUG) Serial.print(response);
}
}
// if(true) {
// while (pushClient.available()) {
// char response = pushClient.read();
// if(DEBUG) Serial.print(response);
// }
// }
if(DEBUG) {
Serial.println();
@ -95,5 +81,49 @@ void pushData(){
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;
}

@ -1,4 +1,5 @@
/**********************************************************************************************
/**********************************************************************************************
Use the below variables when required to set a static IP for the WifiSheild
***********************************************************************************************/
// byte dns2[] = { 8, 8, 8, 8 };
@ -10,10 +11,11 @@
// uint32_t ip, ddns, ssubnet, ggateway;
// byte mac[6] = { 0xC0, 0x4A, 0x00, 0x1A, 0x08, 0xDA }; //mac - c0:4a:00:1a:08:da
// c0:4a:00:1a:03:f8
// b8:27:eb:88:37:7a
String connecting = "connecting.... ";
byte mac[6] = { 0xc0, 0x4a, 0x00, 0x1a, 0x08, 0xaa };
//mac - c0:4a:00:1a:08:da
// c0:4a:00:1a:03:f8
// b8:27:eb:88:37:7a
void connectHttp() {
/* Initialise the module */
@ -24,28 +26,28 @@ void connectHttp() {
while(1);
}
// if( cc3000.setMacAddress(mac) ) { // Set your own mac and print it to re-check
// uint8_t address[6];
// cc3000.getMacAddress(address);
// if(DEBUG){
// Serial.print(address[0], HEX); Serial.print(":");
// Serial.print(address[1], HEX); Serial.print(":");
// Serial.print(address[2], HEX); Serial.print(":");
// Serial.print(address[3], HEX); Serial.print(":");
// Serial.print(address[4], HEX); Serial.print(":");
// Serial.println(address[5], HEX);
// }
// }
cc3000.setMacAddress(mac); // Set your own mac and print it to re-check
// uint8_t address[6];
// cc3000.getMacAddress(address);
// if(DEBUG){
// Serial.print(address[0], HEX); Serial.print(":");
// Serial.print(address[1], HEX); Serial.print(":");
// Serial.print(address[2], HEX); Serial.print(":");
// Serial.print(address[3], HEX); Serial.print(":");
// Serial.print(address[4], HEX); Serial.print(":");
// Serial.println(address[5], HEX);
// }
// }
/**********************************************************************************************
Only required if using static IP for the WifiSheild
***********************************************************************************************/
// ip = cc3000.IP2U32(deviceIP[0], deviceIP[1], deviceIP[2], deviceIP[3]);
// ddns = cc3000.IP2U32(dns2[0], dns2[1], dns2[2], dns2[3]);
// ssubnet = cc3000.IP2U32(subnet[0], subnet[1], subnet[2], subnet[3]);
// ggateway = cc3000.IP2U32(gateway[0], gateway[1], gateway[2], gateway[3]);
// cc3000.setStaticIPAddress(ip, ssubnet, ggateway, ddns); // required for setting static IP
// ip = cc3000.IP2U32(deviceIP[0], deviceIP[1], deviceIP[2], deviceIP[3]);
// ddns = cc3000.IP2U32(dns2[0], dns2[1], dns2[2], dns2[3]);
// ssubnet = cc3000.IP2U32(subnet[0], subnet[1], subnet[2], subnet[3]);
// ggateway = cc3000.IP2U32(gateway[0], gateway[1], gateway[2], gateway[3]);
// cc3000.setStaticIPAddress(ip, ssubnet, ggateway, ddns); // required for setting static IP
/***********************************************************************************************/
@ -63,7 +65,7 @@ void connectHttp() {
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())
{
delay(100); // ToDo: Insert a DHCP timeout!
@ -74,17 +76,15 @@ void connectHttp() {
delay(1000);
}
pushClient = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT
if (pushClient.connected()) {
if(CON_DEBUG) Serial.println("PushClient Connected to server");
client = cc3000.connectTCP(sserver, SERVICE_PORT); //SERVICE_PORT
if (client.connected()) {
if(true) Serial.println(F("client Connected to server"));
} else {
cc3000.disconnect();
if(CON_DEBUG) Serial.println(F("PushClient Connection failed"));
if(CON_DEBUG) Serial.println(F("client Connection failed"));
}
httpServer.begin();
Serial.println(F("Listening for connections..."));
if(CON_DEBUG) Serial.println(F("-------------------------------------"));
}
@ -93,14 +93,14 @@ void connectHttp() {
void setupResource(){
String hostIP = getHostIP(server);
String port = String(SERVICE_PORT);
//
host = "Host: " + hostIP + ":" + port;
if(DEBUG) Serial.println(host);
// if(DEBUG) Serial.println(host);
jsonPayLoad = "{\"owner\":\"";
jsonPayLoad += String(DEVICE_OWNER);
jsonPayLoad += DEVICE_OWNER;
jsonPayLoad += "\",\"deviceId\":\"";
jsonPayLoad += String(DEVICE_ID);
jsonPayLoad += DEVICE_ID;
jsonPayLoad += "\",\"reply\":\"";
if(DEBUG) {
@ -110,6 +110,7 @@ void setupResource(){
}
}
String getHostIP(byte server[4]){
String hostIP = String(server[0]);
@ -134,12 +135,25 @@ bool displayConnectionDetails(void)
{
if(CON_DEBUG) {
Serial.print(F("\nIP Addr: ")); cc3000.printIPdotsRev(ipAddress);
// Serial.print(F("\nNetmask: ")); cc3000.printIPdotsRev(netmask);
// Serial.print(F("\nGateway: ")); cc3000.printIPdotsRev(gateway);
// Serial.print(F("\nDHCPsrv: ")); cc3000.printIPdotsRev(dhcpserv);
// Serial.print(F("\nDNSserv: ")); cc3000.printIPdotsRev(dnsserv);
Serial.print(F("\nNetmask: ")); cc3000.printIPdotsRev(netmask);
Serial.print(F("\nGateway: ")); cc3000.printIPdotsRev(gateway);
Serial.print(F("\nDHCPsrv: ")); cc3000.printIPdotsRev(dhcpserv);
Serial.print(F("\nDNSserv: ")); cc3000.printIPdotsRev(dnsserv);
Serial.println();
}
return true;
}
}
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"));
}
}

@ -1,4 +1,11 @@
void updateDirectionVariable(int motionDir){
motion_global = motionDir;
}
void motor_stop(){
digitalWrite(motor_left[0], LOW);
digitalWrite(motor_left[1], LOW);
@ -53,3 +60,19 @@ void turn_left(){
updateDirectionVariable(0);
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 path[MAX_PATH+1];
boolean listen()
void readControls()
{
// Try to get a client which is connected.
Adafruit_CC3000_ClientRef client = httpServer.available();
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.
if(client){
bufindex = 0;
memset(&buffer, 0, sizeof(buffer));
@ -37,7 +32,7 @@ boolean listen()
// Serial.print(F("Path: ")); Serial.println(path);
if (strcmp(action, "GET") == 0) {
String urlPath = path;
urlPath = path;
urlPath.replace("/move/","");
urlPath.replace("/","");
@ -61,15 +56,11 @@ boolean listen()
// Wait a short period to make sure the response had time to send before
// the connection is closed (the CC3000 sends data asyncronously).
delay(100);
// Close the connection when done.
Serial.println(F("Client disconnected"));
delay(200);
client.close();
return false;
} else {
return true;
}
}

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

@ -1,37 +1,27 @@
#ifndef SenseBotWifiAgent_H
#define SenseBotWifiAgent_H
#ifndef ArduinoWifiAgent_H
#define ArduinoWifiAgent_H
#if (ARDUINO >= 100)
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
#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 "YourAccessPointSSID" // cannot be longer than 32 characters!
#define WLAN_PASS "APPassword"
#define WLAN_SSID "linksys" // cannot be longer than 32 characters!
#define WLAN_PASS "ramsgate717"
#define WLAN_SECURITY WLAN_SEC_WPA2
// Security can be WLAN_SEC_UNSEC, WLAN_SEC_WEP, WLAN_SEC_WPA or 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
#define IDLE_TIMEOUT_MS 3000
#define DEVICE_OWNER "${DEVICE_OWNER}"
#define DEVICE_ID "${DEVICE_ID}"
#define DEVICE_TOKEN "${DEVICE_TOKEN}"
/**********************************************************************************************
The following two parameters are used when pushing data via the API in the API Manager
***********************************************************************************************/
#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 SERVICE_PORT 9763
#define SERVICE_EPOINT "/sensebot/controller/"
#define BUZZER A0
#define LDR_PIN A1
@ -45,27 +35,40 @@
#define TURN_DELAY 100
#define LISTEN_PORT 80 // What TCP port to listen on for connections.
// The HTTP protocol uses port 80 by default.
#define PUSH_INTERVAL 30000
#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 MAX_PATH 10
#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 TIMEOUT_MS 500
#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

@ -1,49 +1,24 @@
#include "SenseBotWifiAgent.h"
#include <Adafruit_CC3000.h>
#include <avr/wdt.h>
#include <SPI.h>
#include <avr/wdt.h>
#include "dht.h"
#include <pt.h>
Adafruit_CC3000 cc3000 = Adafruit_CC3000(ADAFRUIT_CC3000_CS, ADAFRUIT_CC3000_IRQ, ADAFRUIT_CC3000_VBAT,
SPI_CLOCK_DIVIDER); // you can change this clock speed
Adafruit_CC3000_Client pushClient;
Adafruit_CC3000_Client client;
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;
byte server[4] = { XX, XX, XX, XX };
String host, jsonPayLoad;
dht DHT;
void setup()
{
if(CON_DEBUG) Serial.begin(9600);
void setup() {
Serial.begin(115200);
pinMode(PIR_PIN, INPUT);
pinMode(LDR_PIN, INPUT);
pinMode(TEMP_PIN, INPUT);
for(int i = 0; i < 2; i++){
pinMode(motor_left[i], OUTPUT);
pinMode(motor_right[i], OUTPUT);
@ -55,79 +30,47 @@ void setup() {
digitalWrite(enB, 100);
motor_stop();
PT_INIT(&pushThread);
do{
connectHttp();
}while( !cc3000.checkConnected() );
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();
readControls();
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;
}
}
void updateDirectionVariable(int motionDir){
motion_global = motionDir;
}
//Serial.println(F("looping"));
getTemperature();
pir =digitalRead(PIR_PIN);
getSonar();
ldr =analogRead(LDR_PIN);
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();
if(millis() - pushTimestamp > PUSH_INTERVAL){
wdt_reset();
} else {
pushClient.close();
cc3000.disconnect();
connectHttp();
while (!client.connected()) {
setupClient();
}
pushData();
// Serial.print("looping");
pushTimestamp = millis();
}
PT_END(pt);
}
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;
}
Loading…
Cancel
Save