From dfd8fdec4ab7c27701801ce192d551f83ee354e9 Mon Sep 17 00:00:00 2001 From: Harald Pichler Date: Fri, 20 May 2016 11:18:19 +0200 Subject: [PATCH] initial upload --- examples/osd/arduino-bmp085/Barometer.cpp | 175 +++++++++++++++ examples/osd/arduino-bmp085/Barometer.h | 58 +++++ .../Barometer_Sensor/Barometer.cpp | 175 +++++++++++++++ .../Barometer_Sensor/Barometer.h | 58 +++++ .../Barometer_Sensor/Barometer_Sensor.ino | 49 ++++ examples/osd/arduino-bmp085/Makefile | 71 ++++++ examples/osd/arduino-bmp085/README.md | 11 + examples/osd/arduino-bmp085/arduino-example.c | 2 + examples/osd/arduino-bmp085/flash.sh | 2 + examples/osd/arduino-bmp085/project-conf.h | 106 +++++++++ .../arduino-bmp085/resources/res-bmp085alt.c | 79 +++++++ .../arduino-bmp085/resources/res-bmp085atm.c | 79 +++++++ .../resources/res-bmp085press.c | 79 +++++++ .../arduino-bmp085/resources/res-bmp085temp.c | 79 +++++++ examples/osd/arduino-bmp085/run.sh | 5 + examples/osd/arduino-bmp085/sketch.pde | 86 +++++++ .../osd/arduino-weather/Adafruit_HTU21DF.cpp | 100 +++++++++ .../osd/arduino-weather/Adafruit_HTU21DF.h | 44 ++++ examples/osd/arduino-weather/BH1750FVI.cpp | 209 ++++++++++++++++++ examples/osd/arduino-weather/BH1750FVI.h | 115 ++++++++++ examples/osd/arduino-weather/Barometer.cpp | 175 +++++++++++++++ examples/osd/arduino-weather/Barometer.h | 58 +++++ examples/osd/arduino-weather/Makefile | 71 ++++++ examples/osd/arduino-weather/README.md | 11 + .../osd/arduino-weather/arduino-example.c | 2 + examples/osd/arduino-weather/flash.sh | 2 + examples/osd/arduino-weather/project-conf.h | 106 +++++++++ .../arduino-weather/resources/res-bh1750.c | 80 +++++++ .../arduino-weather/resources/res-bmp085alt.c | 79 +++++++ .../arduino-weather/resources/res-bmp085atm.c | 79 +++++++ .../resources/res-bmp085press.c | 79 +++++++ .../arduino-weather/resources/res-htu21dhum.c | 80 +++++++ .../resources/res-htu21dtemp.c | 79 +++++++ examples/osd/arduino-weather/run.sh | 5 + examples/osd/arduino-weather/sketch.pde | 128 +++++++++++ 35 files changed, 2616 insertions(+) create mode 100644 examples/osd/arduino-bmp085/Barometer.cpp create mode 100644 examples/osd/arduino-bmp085/Barometer.h create mode 100644 examples/osd/arduino-bmp085/Barometer_Sensor/Barometer.cpp create mode 100644 examples/osd/arduino-bmp085/Barometer_Sensor/Barometer.h create mode 100644 examples/osd/arduino-bmp085/Barometer_Sensor/examples/Barometer_Sensor/Barometer_Sensor.ino create mode 100644 examples/osd/arduino-bmp085/Makefile create mode 100644 examples/osd/arduino-bmp085/README.md create mode 100644 examples/osd/arduino-bmp085/arduino-example.c create mode 100755 examples/osd/arduino-bmp085/flash.sh create mode 100644 examples/osd/arduino-bmp085/project-conf.h create mode 100644 examples/osd/arduino-bmp085/resources/res-bmp085alt.c create mode 100644 examples/osd/arduino-bmp085/resources/res-bmp085atm.c create mode 100644 examples/osd/arduino-bmp085/resources/res-bmp085press.c create mode 100644 examples/osd/arduino-bmp085/resources/res-bmp085temp.c create mode 100755 examples/osd/arduino-bmp085/run.sh create mode 100644 examples/osd/arduino-bmp085/sketch.pde create mode 100644 examples/osd/arduino-weather/Adafruit_HTU21DF.cpp create mode 100644 examples/osd/arduino-weather/Adafruit_HTU21DF.h create mode 100644 examples/osd/arduino-weather/BH1750FVI.cpp create mode 100644 examples/osd/arduino-weather/BH1750FVI.h create mode 100644 examples/osd/arduino-weather/Barometer.cpp create mode 100644 examples/osd/arduino-weather/Barometer.h create mode 100644 examples/osd/arduino-weather/Makefile create mode 100644 examples/osd/arduino-weather/README.md create mode 100644 examples/osd/arduino-weather/arduino-example.c create mode 100755 examples/osd/arduino-weather/flash.sh create mode 100644 examples/osd/arduino-weather/project-conf.h create mode 100644 examples/osd/arduino-weather/resources/res-bh1750.c create mode 100644 examples/osd/arduino-weather/resources/res-bmp085alt.c create mode 100644 examples/osd/arduino-weather/resources/res-bmp085atm.c create mode 100644 examples/osd/arduino-weather/resources/res-bmp085press.c create mode 100644 examples/osd/arduino-weather/resources/res-htu21dhum.c create mode 100644 examples/osd/arduino-weather/resources/res-htu21dtemp.c create mode 100755 examples/osd/arduino-weather/run.sh create mode 100644 examples/osd/arduino-weather/sketch.pde diff --git a/examples/osd/arduino-bmp085/Barometer.cpp b/examples/osd/arduino-bmp085/Barometer.cpp new file mode 100644 index 000000000..ec8b294a8 --- /dev/null +++ b/examples/osd/arduino-bmp085/Barometer.cpp @@ -0,0 +1,175 @@ +/* + Barometer library V1.0 + 2010 Copyright (c) Seeed Technology Inc. All right reserved. + + Original Author: LG + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#include "Barometer.h" +#include +#include + +void Barometer::init(void) +{ + Wire.begin(); +// Serial.print("Temperaturet: "); + ac1 = bmp085ReadInt(0xAA); + ac2 = bmp085ReadInt(0xAC); + ac3 = bmp085ReadInt(0xAE); + ac4 = bmp085ReadInt(0xB0); + ac5 = bmp085ReadInt(0xB2); + ac6 = bmp085ReadInt(0xB4); + b1 = bmp085ReadInt(0xB6); + b2 = bmp085ReadInt(0xB8); + mb = bmp085ReadInt(0xBA); + mc = bmp085ReadInt(0xBC); + md = bmp085ReadInt(0xBE); +// Serial.print("Temperaturet2: "); +} +// Read 1 byte from the BMP085 at 'address' +// Return: the read byte; +char Barometer::bmp085Read(unsigned char address) +{ + //Wire.begin(); + //unsigned char data; + Wire.beginTransmission(BMP085_ADDRESS); + Wire.write(address); + Wire.endTransmission(); + + Wire.requestFrom(BMP085_ADDRESS, 1); + while(!Wire.available()); + return Wire.read(); +} +// Read 2 bytes from the BMP085 +// First byte will be from 'address' +// Second byte will be from 'address'+1 +int Barometer::bmp085ReadInt(unsigned char address) +{ + unsigned char msb, lsb; + Wire.beginTransmission(BMP085_ADDRESS); + Wire.write(address); + Wire.endTransmission(); + Wire.requestFrom(BMP085_ADDRESS, 2); + while(Wire.available()<2); + msb = Wire.read(); + lsb = Wire.read(); + return (int) msb<<8 | lsb; +} +// Read the uncompensated temperature value +unsigned int Barometer::bmp085ReadUT() +{ + unsigned int ut; + Wire.beginTransmission(BMP085_ADDRESS); + Wire.write(0xF4); + Wire.write(0x2E); + Wire.endTransmission(); + delay(5); + ut = bmp085ReadInt(0xF6); + return ut; +} +// Read the uncompensated pressure value +unsigned long Barometer::bmp085ReadUP() +{ + unsigned char msb, lsb, xlsb; + unsigned long up = 0; + Wire.beginTransmission(BMP085_ADDRESS); + Wire.write(0xF4); + Wire.write(0x34 + (OSS<<6)); + Wire.endTransmission(); + delay(2 + (3<> (8-OSS); + return up; +} +void Barometer::writeRegister(int deviceAddress, byte address, byte val) +{ + Wire.beginTransmission(deviceAddress); // start transmission to device + Wire.write(address); // send register address + Wire.write(val); // send value to write + Wire.endTransmission(); // end transmission +} +int Barometer::readRegister(int deviceAddress, byte address) +{ + int v; + Wire.beginTransmission(deviceAddress); + Wire.write(address); // register to read + Wire.endTransmission(); + + Wire.requestFrom(deviceAddress, 1); // read a byte + + while(!Wire.available()) { + // waiting + } + + v = Wire.read(); + return v; +} +float Barometer::calcAltitude(float pressure) +{ + float A = pressure/101325; + float B = 1/5.25588; + float C = pow(A,B); + C = 1 - C; + C = C /0.0000225577; + return C; +} +float Barometer::bmp085GetTemperature(unsigned int ut) +{ + long x1, x2; + + x1 = (((long)ut - (long)ac6)*(long)ac5) >> 15; + x2 = ((long)mc << 11)/(x1 + md); + PressureCompensate = x1 + x2; + + float temp = ((PressureCompensate + 8)>>4); + temp = temp /10; + + return temp; +} +long Barometer::bmp085GetPressure(unsigned long up) +{ + long x1, x2, x3, b3, b6, p; + unsigned long b4, b7; + b6 = PressureCompensate - 4000; + x1 = (b2 * (b6 * b6)>>12)>>11; + x2 = (ac2 * b6)>>11; + x3 = x1 + x2; + b3 = (((((long)ac1)*4 + x3)<>2; + + // Calculate B4 + x1 = (ac3 * b6)>>13; + x2 = (b1 * ((b6 * b6)>>12))>>16; + x3 = ((x1 + x2) + 2)>>2; + b4 = (ac4 * (unsigned long)(x3 + 32768))>>15; + + b7 = ((unsigned long)(up - b3) * (50000>>OSS)); + if (b7 < 0x80000000) + p = (b7<<1)/b4; + else + p = (b7/b4)<<1; + + x1 = (p>>8) * (p>>8); + x1 = (x1 * 3038)>>16; + x2 = (-7357 * p)>>16; + p += (x1 + x2 + 3791)>>4; + + long temp = p; + return temp; +} diff --git a/examples/osd/arduino-bmp085/Barometer.h b/examples/osd/arduino-bmp085/Barometer.h new file mode 100644 index 000000000..161702718 --- /dev/null +++ b/examples/osd/arduino-bmp085/Barometer.h @@ -0,0 +1,58 @@ +/* + Barometer library V1.0 + 2010 Copyright (c) Seeed Technology Inc. All right reserved. + + Original Author: LG + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#ifndef __BAROMETER_H__ +#define __BAROMETER_H__ + +#include +#include + +const unsigned char OSS = 0; +#define BMP085_ADDRESS 0x77 +class Barometer +{ +public: + void init(void); + long PressureCompensate; + float bmp085GetTemperature(unsigned int ut); + long bmp085GetPressure(unsigned long up); + float calcAltitude(float pressure); + unsigned int bmp085ReadUT(void); + unsigned long bmp085ReadUP(void); + +private: + int ac1; + int ac2; + int ac3; + unsigned int ac4; + unsigned int ac5; + unsigned int ac6; + int b1; + int b2; + int mb; + int mc; + int md; + char bmp085Read(unsigned char address); + int bmp085ReadInt(unsigned char address); + void writeRegister(int deviceAddress, byte address, byte val); + int readRegister(int deviceAddress, byte address); +}; + +#endif diff --git a/examples/osd/arduino-bmp085/Barometer_Sensor/Barometer.cpp b/examples/osd/arduino-bmp085/Barometer_Sensor/Barometer.cpp new file mode 100644 index 000000000..208f8b5a5 --- /dev/null +++ b/examples/osd/arduino-bmp085/Barometer_Sensor/Barometer.cpp @@ -0,0 +1,175 @@ +/* + Barometer library V1.0 + 2010 Copyright (c) Seeed Technology Inc. All right reserved. + + Original Author: LG + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#include "Barometer.h" +#include +#include + +void Barometer::init(void) +{ + Wire.begin(); + Serial.print("Temperaturet: "); + ac1 = bmp085ReadInt(0xAA); + ac2 = bmp085ReadInt(0xAC); + ac3 = bmp085ReadInt(0xAE); + ac4 = bmp085ReadInt(0xB0); + ac5 = bmp085ReadInt(0xB2); + ac6 = bmp085ReadInt(0xB4); + b1 = bmp085ReadInt(0xB6); + b2 = bmp085ReadInt(0xB8); + mb = bmp085ReadInt(0xBA); + mc = bmp085ReadInt(0xBC); + md = bmp085ReadInt(0xBE); + Serial.print("Temperaturet2: "); +} +// Read 1 byte from the BMP085 at 'address' +// Return: the read byte; +char Barometer::bmp085Read(unsigned char address) +{ + //Wire.begin(); + unsigned char data; + Wire.beginTransmission(BMP085_ADDRESS); + Wire.write(address); + Wire.endTransmission(); + + Wire.requestFrom(BMP085_ADDRESS, 1); + while(!Wire.available()); + return Wire.read(); +} +// Read 2 bytes from the BMP085 +// First byte will be from 'address' +// Second byte will be from 'address'+1 +int Barometer::bmp085ReadInt(unsigned char address) +{ + unsigned char msb, lsb; + Wire.beginTransmission(BMP085_ADDRESS); + Wire.write(address); + Wire.endTransmission(); + Wire.requestFrom(BMP085_ADDRESS, 2); + while(Wire.available()<2); + msb = Wire.read(); + lsb = Wire.read(); + return (int) msb<<8 | lsb; +} +// Read the uncompensated temperature value +unsigned int Barometer::bmp085ReadUT() +{ + unsigned int ut; + Wire.beginTransmission(BMP085_ADDRESS); + Wire.write(0xF4); + Wire.write(0x2E); + Wire.endTransmission(); + delay(5); + ut = bmp085ReadInt(0xF6); + return ut; +} +// Read the uncompensated pressure value +unsigned long Barometer::bmp085ReadUP() +{ + unsigned char msb, lsb, xlsb; + unsigned long up = 0; + Wire.beginTransmission(BMP085_ADDRESS); + Wire.write(0xF4); + Wire.write(0x34 + (OSS<<6)); + Wire.endTransmission(); + delay(2 + (3<> (8-OSS); + return up; +} +void Barometer::writeRegister(int deviceAddress, byte address, byte val) +{ + Wire.beginTransmission(deviceAddress); // start transmission to device + Wire.write(address); // send register address + Wire.write(val); // send value to write + Wire.endTransmission(); // end transmission +} +int Barometer::readRegister(int deviceAddress, byte address) +{ + int v; + Wire.beginTransmission(deviceAddress); + Wire.write(address); // register to read + Wire.endTransmission(); + + Wire.requestFrom(deviceAddress, 1); // read a byte + + while(!Wire.available()) { + // waiting + } + + v = Wire.read(); + return v; +} +float Barometer::calcAltitude(float pressure) +{ + float A = pressure/101325; + float B = 1/5.25588; + float C = pow(A,B); + C = 1 - C; + C = C /0.0000225577; + return C; +} +float Barometer::bmp085GetTemperature(unsigned int ut) +{ + long x1, x2; + + x1 = (((long)ut - (long)ac6)*(long)ac5) >> 15; + x2 = ((long)mc << 11)/(x1 + md); + PressureCompensate = x1 + x2; + + float temp = ((PressureCompensate + 8)>>4); + temp = temp /10; + + return temp; +} +long Barometer::bmp085GetPressure(unsigned long up) +{ + long x1, x2, x3, b3, b6, p; + unsigned long b4, b7; + b6 = PressureCompensate - 4000; + x1 = (b2 * (b6 * b6)>>12)>>11; + x2 = (ac2 * b6)>>11; + x3 = x1 + x2; + b3 = (((((long)ac1)*4 + x3)<>2; + + // Calculate B4 + x1 = (ac3 * b6)>>13; + x2 = (b1 * ((b6 * b6)>>12))>>16; + x3 = ((x1 + x2) + 2)>>2; + b4 = (ac4 * (unsigned long)(x3 + 32768))>>15; + + b7 = ((unsigned long)(up - b3) * (50000>>OSS)); + if (b7 < 0x80000000) + p = (b7<<1)/b4; + else + p = (b7/b4)<<1; + + x1 = (p>>8) * (p>>8); + x1 = (x1 * 3038)>>16; + x2 = (-7357 * p)>>16; + p += (x1 + x2 + 3791)>>4; + + long temp = p; + return temp; +} diff --git a/examples/osd/arduino-bmp085/Barometer_Sensor/Barometer.h b/examples/osd/arduino-bmp085/Barometer_Sensor/Barometer.h new file mode 100644 index 000000000..161702718 --- /dev/null +++ b/examples/osd/arduino-bmp085/Barometer_Sensor/Barometer.h @@ -0,0 +1,58 @@ +/* + Barometer library V1.0 + 2010 Copyright (c) Seeed Technology Inc. All right reserved. + + Original Author: LG + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#ifndef __BAROMETER_H__ +#define __BAROMETER_H__ + +#include +#include + +const unsigned char OSS = 0; +#define BMP085_ADDRESS 0x77 +class Barometer +{ +public: + void init(void); + long PressureCompensate; + float bmp085GetTemperature(unsigned int ut); + long bmp085GetPressure(unsigned long up); + float calcAltitude(float pressure); + unsigned int bmp085ReadUT(void); + unsigned long bmp085ReadUP(void); + +private: + int ac1; + int ac2; + int ac3; + unsigned int ac4; + unsigned int ac5; + unsigned int ac6; + int b1; + int b2; + int mb; + int mc; + int md; + char bmp085Read(unsigned char address); + int bmp085ReadInt(unsigned char address); + void writeRegister(int deviceAddress, byte address, byte val); + int readRegister(int deviceAddress, byte address); +}; + +#endif diff --git a/examples/osd/arduino-bmp085/Barometer_Sensor/examples/Barometer_Sensor/Barometer_Sensor.ino b/examples/osd/arduino-bmp085/Barometer_Sensor/examples/Barometer_Sensor/Barometer_Sensor.ino new file mode 100644 index 000000000..7fe3b3ec5 --- /dev/null +++ b/examples/osd/arduino-bmp085/Barometer_Sensor/examples/Barometer_Sensor/Barometer_Sensor.ino @@ -0,0 +1,49 @@ +/* Barometer demo V1.0 +* Based largely on code by Jim Lindblom +* Get pressure, altitude, and temperature from the BMP085. +* Serial.print it out at 9600 baud to serial monitor. +* +* By:http://www.seeedstudio.com +*/ +#include "Barometer.h" +#include +float temperature; +float pressure; +float atm; +float altitude; +Barometer myBarometer; +void setup(){ + Serial.begin(9600); + myBarometer.init(); + +} + +void loop() +{ + temperature = myBarometer.bmp085GetTemperature(myBarometer.bmp085ReadUT()); //Get the temperature, bmp085ReadUT MUST be called first + pressure = myBarometer.bmp085GetPressure(myBarometer.bmp085ReadUP());//Get the temperature + altitude = myBarometer.calcAltitude(pressure); //Uncompensated caculation - in Meters + atm = pressure / 101325; + + Serial.print("Temperature: "); + Serial.print(temperature, 2); //display 2 decimal places + Serial.println("deg C"); + + Serial.print("Pressure: "); + Serial.print(pressure, 0); //whole number only. + Serial.println(" Pa"); + + Serial.print("Ralated Atmosphere: "); + Serial.println(atm, 4); //display 4 decimal places + + Serial.print("Altitude: "); + Serial.print(altitude, 2); //display 2 decimal places + Serial.println(" m"); + + Serial.println(); + + delay(1000); //wait a second and get values again. +} + + + diff --git a/examples/osd/arduino-bmp085/Makefile b/examples/osd/arduino-bmp085/Makefile new file mode 100644 index 000000000..b74569ff2 --- /dev/null +++ b/examples/osd/arduino-bmp085/Makefile @@ -0,0 +1,71 @@ +# Set this to the name of your sketch (without extension .pde) +SKETCH=sketch +EXE=arduino-example + +all: $(EXE) + +CONTIKI=../../.. + +# Contiki IPv6 configuration +CONTIKI_WITH_IPV6 = 1 + +CFLAGS += -DPROJECT_CONF_H=\"project-conf.h\" +LFLAGS += -lm + +PROJECT_SOURCEFILES += ${SKETCH}.cpp Barometer.cpp + +# automatically build RESTful resources +REST_RESOURCES_DIR = ./resources +REST_RESOURCES_DIR_COMMON = ../resources-common +REST_RESOURCES_FILES= $(notdir \ + $(shell find $(REST_RESOURCES_DIR) -name '*.c') \ + $(shell find $(REST_RESOURCES_DIR_COMMON) -name '*.c') \ + ) + +PROJECTDIRS += $(REST_RESOURCES_DIR) $(REST_RESOURCES_DIR_COMMON) +PROJECT_SOURCEFILES += $(REST_RESOURCES_FILES) + +# variable for Makefile.include +ifneq ($(TARGET), minimal-net) +CFLAGS += -DUIP_CONF_IPV6_RPL=1 +else +# minimal-net does not support RPL under Linux and is mostly used to test CoAP only +${info INFO: compiling without RPL} +CFLAGS += -DUIP_CONF_IPV6_RPL=0 +CFLAGS += -DHARD_CODED_ADDRESS=\"fdfd::10\" +${info INFO: compiling with large buffers} +CFLAGS += -DUIP_CONF_BUFFER_SIZE=2048 +CFLAGS += -DREST_MAX_CHUNK_SIZE=1024 +CFLAGS += -DCOAP_MAX_HEADER_SIZE=640 +endif + +# linker optimizations +SMALL=1 + + +# REST Engine shall use Erbium CoAP implementation +APPS += er-coap +APPS += rest-engine +APPS += arduino + +include $(CONTIKI)/Makefile.include +include $(CONTIKI)/apps/arduino/Makefile.include + +$(CONTIKI)/tools/tunslip6: $(CONTIKI)/tools/tunslip6.c + (cd $(CONTIKI)/tools && $(MAKE) tunslip6) + +connect-router: $(CONTIKI)/tools/tunslip6 + sudo $(CONTIKI)/tools/tunslip6 aaaa::1/64 + +connect-router-cooja: $(CONTIKI)/tools/tunslip6 + sudo $(CONTIKI)/tools/tunslip6 -a 127.0.0.1 aaaa::1/64 + +connect-minimal: + sudo ip address add fdfd::1/64 dev tap0 + +avr-size: $(EXE).$(TARGET).sz + +flash: $(EXE).$(TARGET).u $(EXE).$(TARGET).eu + +.PHONY: flash avr-size +.PRECIOUS: $(EXE).$(TARGET).hex $(EXE).$(TARGET).eep diff --git a/examples/osd/arduino-bmp085/README.md b/examples/osd/arduino-bmp085/README.md new file mode 100644 index 000000000..e1490ed05 --- /dev/null +++ b/examples/osd/arduino-bmp085/README.md @@ -0,0 +1,11 @@ +Arduino compatibility example +============================= + +This example shows that it is now possible to re-use arduino sketches in +Contiki. This example documents the necessary magic. Arduino specifies +two routines, `setup` and `loop`. Before `setup` is called, the +framework initializes hardware. In original Arduino, all this is done in +a `main` function (in C). For contiki we define a process that does the +same. + +See the documentation file in apps/contiki-compat/README.md diff --git a/examples/osd/arduino-bmp085/arduino-example.c b/examples/osd/arduino-bmp085/arduino-example.c new file mode 100644 index 000000000..ea74dd8b8 --- /dev/null +++ b/examples/osd/arduino-bmp085/arduino-example.c @@ -0,0 +1,2 @@ +#include +AUTOSTART_PROCESSES(&arduino_sketch); diff --git a/examples/osd/arduino-bmp085/flash.sh b/examples/osd/arduino-bmp085/flash.sh new file mode 100755 index 000000000..e82962073 --- /dev/null +++ b/examples/osd/arduino-bmp085/flash.sh @@ -0,0 +1,2 @@ +#!/bin/bash +make TARGET=osd-merkur-128 flash diff --git a/examples/osd/arduino-bmp085/project-conf.h b/examples/osd/arduino-bmp085/project-conf.h new file mode 100644 index 000000000..e25aed53c --- /dev/null +++ b/examples/osd/arduino-bmp085/project-conf.h @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2010, Swedish Institute of Computer Science. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * + */ + +#ifndef PROJECT_RPL_WEB_CONF_H_ +#define PROJECT_RPL_WEB_CONF_H_ + +#define PLATFORM_HAS_LEDS 1 +//#define PLATFORM_HAS_BUTTON 1 +#define PLATFORM_HAS_BATTERY 1 + +#define SICSLOWPAN_CONF_FRAG 1 + +#define LOOP_INTERVAL (10 * CLOCK_SECOND) + +/* Save energy */ +//#define RDC_CONF_PT_YIELD_OFF + +/* For Debug: Dont allow MCU sleeping between channel checks */ +//#undef RDC_CONF_MCU_SLEEP +//#define RDC_CONF_MCU_SLEEP 0 + +/* Disabling RDC for demo purposes. Core updates often require more memory. */ +/* For projects, optimize memory and enable RDC again. */ +// #undef NETSTACK_CONF_RDC +//#define NETSTACK_CONF_RDC nullrdc_driver + +/* Increase rpl-border-router IP-buffer when using more than 64. */ +#undef REST_MAX_CHUNK_SIZE +#define REST_MAX_CHUNK_SIZE 64 + +/* Estimate your header size, especially when using Proxy-Uri. */ +/* +#undef COAP_MAX_HEADER_SIZE +#define COAP_MAX_HEADER_SIZE 70 +*/ + +/* The IP buffer size must fit all other hops, in particular the border router. */ + +#undef UIP_CONF_BUFFER_SIZE +#define UIP_CONF_BUFFER_SIZE 256 + + +/* Multiplies with chunk size, be aware of memory constraints. */ +#undef COAP_MAX_OPEN_TRANSACTIONS +#define COAP_MAX_OPEN_TRANSACTIONS 4 + +/* Must be <= open transaction number, default is COAP_MAX_OPEN_TRANSACTIONS-1. */ +/* +#undef COAP_MAX_OBSERVERS +#define COAP_MAX_OBSERVERS 2 +*/ + +/* Filtering .well-known/core per query can be disabled to save space. */ +/* +#undef COAP_LINK_FORMAT_FILTERING +#define COAP_LINK_FORMAT_FILTERING 0 +*/ + +/* Save some memory for the sky platform. */ +/* +#undef NBR_TABLE_CONF_MAX_NEIGHBORS +#define NBR_TABLE_CONF_MAX_NEIGHBORS 10 +#undef UIP_CONF_MAX_ROUTES +#define UIP_CONF_MAX_ROUTES 10 +*/ + +/* Reduce 802.15.4 frame queue to save RAM. */ +/* +#undef QUEUEBUF_CONF_NUM +#define QUEUEBUF_CONF_NUM 4 +*/ + +/* +#undef SICSLOWPAN_CONF_FRAG +#define SICSLOWPAN_CONF_FRAG 1 +*/ + +#endif /* PROJECT_RPL_WEB_CONF_H_ */ diff --git a/examples/osd/arduino-bmp085/resources/res-bmp085alt.c b/examples/osd/arduino-bmp085/resources/res-bmp085alt.c new file mode 100644 index 000000000..de90eae4f --- /dev/null +++ b/examples/osd/arduino-bmp085/resources/res-bmp085alt.c @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Barometer resource + * \author + * Harald Pichler + */ + +#include "contiki.h" + +#include +#include "rest-engine.h" +#include "Arduino.h" + +static void res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/* A simple getter example. Returns the reading from the sensor with a simple etag */ +RESOURCE(res_bmp085alt, + "title=\"alt status\";rt=\"alt\"", + res_get_handler, + NULL, + NULL, + NULL); + +extern char bmp085alt_s[8]; + +static void +res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + unsigned int accept = -1; + REST.get_header_accept(request, &accept); + + if(accept == -1 || accept == REST.type.TEXT_PLAIN) { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%s", bmp085alt_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else if(accept == REST.type.APPLICATION_JSON) { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'temperature':%s}", bmp085alt_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else { + REST.set_response_status(response, REST.status.NOT_ACCEPTABLE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} diff --git a/examples/osd/arduino-bmp085/resources/res-bmp085atm.c b/examples/osd/arduino-bmp085/resources/res-bmp085atm.c new file mode 100644 index 000000000..b97cffe6e --- /dev/null +++ b/examples/osd/arduino-bmp085/resources/res-bmp085atm.c @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Barometer resource + * \author + * Harald Pichler + */ + +#include "contiki.h" + +#include +#include "rest-engine.h" +#include "Arduino.h" + +static void res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/* A simple getter example. Returns the reading from the sensor with a simple etag */ +RESOURCE(res_bmp085atm, + "title=\"atm status\";rt=\"atm\"", + res_get_handler, + NULL, + NULL, + NULL); + +extern char bmp085atm_s[8]; + +static void +res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + unsigned int accept = -1; + REST.get_header_accept(request, &accept); + + if(accept == -1 || accept == REST.type.TEXT_PLAIN) { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%s", bmp085atm_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else if(accept == REST.type.APPLICATION_JSON) { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'temperature':%s}", bmp085atm_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else { + REST.set_response_status(response, REST.status.NOT_ACCEPTABLE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} diff --git a/examples/osd/arduino-bmp085/resources/res-bmp085press.c b/examples/osd/arduino-bmp085/resources/res-bmp085press.c new file mode 100644 index 000000000..6a02f4bf0 --- /dev/null +++ b/examples/osd/arduino-bmp085/resources/res-bmp085press.c @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Barometer resource + * \author + * Harald Pichler + */ + +#include "contiki.h" + +#include +#include "rest-engine.h" +#include "Arduino.h" + +static void res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/* A simple getter example. Returns the reading from the sensor with a simple etag */ +RESOURCE(res_bmp085press, + "title=\"pressure status\";rt=\"pressure\"", + res_get_handler, + NULL, + NULL, + NULL); + +extern char bmp085press_s[8]; + +static void +res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + unsigned int accept = -1; + REST.get_header_accept(request, &accept); + + if(accept == -1 || accept == REST.type.TEXT_PLAIN) { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%s", bmp085press_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else if(accept == REST.type.APPLICATION_JSON) { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'pressure':%s}", bmp085press_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else { + REST.set_response_status(response, REST.status.NOT_ACCEPTABLE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} diff --git a/examples/osd/arduino-bmp085/resources/res-bmp085temp.c b/examples/osd/arduino-bmp085/resources/res-bmp085temp.c new file mode 100644 index 000000000..f0e45f810 --- /dev/null +++ b/examples/osd/arduino-bmp085/resources/res-bmp085temp.c @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Barometer resource + * \author + * Harald Pichler + */ + +#include "contiki.h" + +#include +#include "rest-engine.h" +#include "Arduino.h" + +static void res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/* A simple getter example. Returns the reading from the sensor with a simple etag */ +RESOURCE(res_bmp085temp, + "title=\"Temperature status\";rt=\"Temperatur\"", + res_get_handler, + NULL, + NULL, + NULL); + +extern char bmp085temp_s[8]; + +static void +res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + unsigned int accept = -1; + REST.get_header_accept(request, &accept); + + if(accept == -1 || accept == REST.type.TEXT_PLAIN) { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%s", bmp085temp_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else if(accept == REST.type.APPLICATION_JSON) { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'temperature':%s}", bmp085temp_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else { + REST.set_response_status(response, REST.status.NOT_ACCEPTABLE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} diff --git a/examples/osd/arduino-bmp085/run.sh b/examples/osd/arduino-bmp085/run.sh new file mode 100755 index 000000000..5d5cbbbb4 --- /dev/null +++ b/examples/osd/arduino-bmp085/run.sh @@ -0,0 +1,5 @@ +#!/bin/bash +# For the ages-old bootloader (before 2014) you want to use +# BOOTLOADER_GET_MAC=0x0001f3a0 as parameter to make below. +make clean TARGET=osd-merkur-128 +make TARGET=osd-merkur-128 diff --git a/examples/osd/arduino-bmp085/sketch.pde b/examples/osd/arduino-bmp085/sketch.pde new file mode 100644 index 000000000..c84a488a9 --- /dev/null +++ b/examples/osd/arduino-bmp085/sketch.pde @@ -0,0 +1,86 @@ +/* + * Sample arduino sketch using contiki features. + * We turn the LED off + * We allow read the moisture sensor + * Unfortunately sleeping for long times in loop() isn't currently + * possible, something turns off the CPU (including PWM outputs) if a + * Proto-Thread is taking too long. We need to find out how to sleep in + * a Contiki-compatible way. + * Note that for a normal arduino sketch you won't have to include any + * of the contiki-specific files here, the sketch should just work. + */ + +#include +#include "Barometer.h" + +extern "C" { +#include "arduino-process.h" +#include "rest-engine.h" + +extern resource_t res_bmp085temp,res_bmp085press,res_bmp085atm,res_bmp085alt, res_battery; + +float bmp085temp; +float bmp085press; +float bmp085atm; +float bmp085alt; +char bmp085temp_s[8]; +char bmp085press_s[8]; +char bmp085atm_s[8]; +char bmp085alt_s[8]; + +Barometer myBarometer; + +#define LED_PIN 4 +} + +void setup (void) +{ + // switch off the led + pinMode(LED_PIN, OUTPUT); + digitalWrite(LED_PIN, HIGH); + // BMP085 sensor + myBarometer.init(); + // init coap resourcen + rest_init_engine (); + rest_activate_resource (&res_bmp085temp, "s/temp"); + rest_activate_resource (&res_bmp085press, "s/press"); + rest_activate_resource (&res_bmp085atm, "s/atm"); + rest_activate_resource (&res_bmp085alt, "s/alt"); + rest_activate_resource (&res_battery, "s/battery"); +} + +// at project-conf.h +// LOOP_INTERVAL (10 * CLOCK_SECOND) +void loop (void) +{ + mcu_sleep_off(); + bmp085temp = myBarometer.bmp085GetTemperature(myBarometer.bmp085ReadUT()); //Get the temperature, bmp085ReadUT MUST be called first + bmp085press = myBarometer.bmp085GetPressure(myBarometer.bmp085ReadUP());//Get the temperature + bmp085alt = myBarometer.calcAltitude(bmp085press); //Uncompensated caculation - in Meters + bmp085atm = bmp085press / 101325; + + dtostrf(bmp085temp , 6, 2, bmp085temp_s ); + dtostrf(bmp085press , 6, 2, bmp085press_s ); + dtostrf(bmp085alt , 6, 2, bmp085alt_s ); + dtostrf(bmp085atm , 6, 2, bmp085atm_s ); + // remove space + if(bmp085temp_s[0]==' '){ + memcpy (bmp085temp_s,bmp085temp_s+1,strlen(bmp085temp_s)+1); + } + if(bmp085press_s[0]==' '){ + memcpy (bmp085press_s,bmp085press_s+1,strlen(bmp085press_s)+1); + } + if(bmp085alt_s[0]==' '){ + memcpy (bmp085alt_s,bmp085alt_s+1,strlen(bmp085alt_s)+1); + } + if(bmp085atm_s[0]==' '){ + memcpy (bmp085atm_s,bmp085atm_s+1,strlen(bmp085atm_s)+1); + } + +// Debug Print + printf("Temp: %s",bmp085temp_s); + printf("\t\tPress: %s\n",bmp085press_s); + printf("\t\tAltitude: %s\n",bmp085alt_s); + printf("\t\tatm: %s\n",bmp085atm_s); + mcu_sleep_on(); +} diff --git a/examples/osd/arduino-weather/Adafruit_HTU21DF.cpp b/examples/osd/arduino-weather/Adafruit_HTU21DF.cpp new file mode 100644 index 000000000..84bbeb066 --- /dev/null +++ b/examples/osd/arduino-weather/Adafruit_HTU21DF.cpp @@ -0,0 +1,100 @@ +/*************************************************** + This is a library for the HTU21DF Humidity & Temp Sensor + + Designed specifically to work with the HTU21DF sensor from Adafruit + ----> https://www.adafruit.com/products/1899 + + These displays use I2C to communicate, 2 pins are required to + interface + Adafruit invests time and resources providing this open source code, + please support Adafruit and open-source hardware by purchasing + products from Adafruit! + + Written by Limor Fried/Ladyada for Adafruit Industries. + BSD license, all text above must be included in any redistribution + ****************************************************/ + +#include "Adafruit_HTU21DF.h" +#if defined(__AVR__) +#include +#endif + +Adafruit_HTU21DF::Adafruit_HTU21DF() { +} + + +boolean Adafruit_HTU21DF::begin(void) { + Wire.begin(); + + reset(); + + Wire.beginTransmission(HTU21DF_I2CADDR); + Wire.write(HTU21DF_READREG); + Wire.endTransmission(); + Wire.requestFrom(HTU21DF_I2CADDR, 1); + return (Wire.read() == 0x2); // after reset should be 0x2 +} + +void Adafruit_HTU21DF::reset(void) { + Wire.beginTransmission(HTU21DF_I2CADDR); + Wire.write(HTU21DF_RESET); + Wire.endTransmission(); + delay(15); +} + + +float Adafruit_HTU21DF::readTemperature(void) { + + // OK lets ready! + Wire.beginTransmission(HTU21DF_I2CADDR); + Wire.write(HTU21DF_READTEMP); + Wire.endTransmission(); + + delay(50); // add delay between request and actual read! + + Wire.requestFrom(HTU21DF_I2CADDR, 3); + while (!Wire.available()) {} + + uint16_t t = Wire.read(); + t <<= 8; + t |= Wire.read(); + + uint8_t crc = Wire.read(); + + float temp = t; + temp *= 175.72; + temp /= 65536; + temp -= 46.85; + + return temp; +} + + +float Adafruit_HTU21DF::readHumidity(void) { + // OK lets ready! + Wire.beginTransmission(HTU21DF_I2CADDR); + Wire.write(HTU21DF_READHUM); + Wire.endTransmission(); + + delay(50); // add delay between request and actual read! + + Wire.requestFrom(HTU21DF_I2CADDR, 3); + while (!Wire.available()) {} + + uint16_t h = Wire.read(); + h <<= 8; + h |= Wire.read(); + + uint8_t crc = Wire.read(); + + float hum = h; + hum *= 125; + hum /= 65536; + hum -= 6; + + return hum; +} + + + +/*********************************************************************/ diff --git a/examples/osd/arduino-weather/Adafruit_HTU21DF.h b/examples/osd/arduino-weather/Adafruit_HTU21DF.h new file mode 100644 index 000000000..fe8870e39 --- /dev/null +++ b/examples/osd/arduino-weather/Adafruit_HTU21DF.h @@ -0,0 +1,44 @@ +/*************************************************** + This is a library for the HTU21D-F Humidity & Temp Sensor + + Designed specifically to work with the HTU21D-F sensor from Adafruit + ----> https://www.adafruit.com/products/1899 + + These displays use I2C to communicate, 2 pins are required to + interface + Adafruit invests time and resources providing this open source code, + please support Adafruit and open-source hardware by purchasing + products from Adafruit! + + Written by Limor Fried/Ladyada for Adafruit Industries. + BSD license, all text above must be included in any redistribution + ****************************************************/ + +//#if (ARDUINO >= 100) + #include "Arduino.h" +//#else +// #include "WProgram.h" +//#endif +#include "Wire.h" + +#define HTU21DF_I2CADDR 0x40 +#define HTU21DF_READTEMP 0xE3 +#define HTU21DF_READHUM 0xE5 +#define HTU21DF_WRITEREG 0xE6 +#define HTU21DF_READREG 0xE7 +#define HTU21DF_RESET 0xFE + + + +class Adafruit_HTU21DF { + public: + Adafruit_HTU21DF(); + boolean begin(void); + float readTemperature(void); + float readHumidity(void); + void reset(void); + private: + boolean readData(void); + float humidity, temp; +}; + diff --git a/examples/osd/arduino-weather/BH1750FVI.cpp b/examples/osd/arduino-weather/BH1750FVI.cpp new file mode 100644 index 000000000..fd871371a --- /dev/null +++ b/examples/osd/arduino-weather/BH1750FVI.cpp @@ -0,0 +1,209 @@ +#include "BH1750FVI.h" +//#if ARDUINO >= 100 + #include "Arduino.h" +//#else +// #include "WProgram.h" +//#endif + +#include + +void BH1750FVI::begin(byte mode, byte addr, double sens, int pin){ + if(pin>=0 && pin<55){ + pinMode(pin, OUTPUT); + if(addr==BH_AddrL) digitalWrite(pin, LOW); + if(addr==BH_AddrH) digitalWrite(pin, HIGH); + } + byte sensitivity; + if(sens> 5); + MTreg_loByte = BH_MTrLb | (sensitivity & 0b00011111); + switch(mode){ + case BH_ContL: + case BH_ContH: + case BH_Conth: + startOngoingSamples(mode); + break; + case BH_SingH: + case BH_Singh: + case BH_SingL: + startSingleSample(mode); + break; + default: + mode = BH_EasyH; + startOngoingSamples(mode); + break; + } + sampleUnseen = false; + lastSampleStart = 0; +} + +word BH1750FVI::startOngoingSamples(char mode){ + if(mode==BH_NoMod) mode=currentMode; + byte lowLevelMode = mode; + if(lowLevelMode==BH_EasyH) lowLevelMode=BH_ContH; + switch(mode){ + case BH_EasyH: + case BH_ContH: + case BH_Conth: + case BH_ContL: + i2cWrite(BH_PowOn); + i2cWrite(MTreg_hiByte); + i2cWrite(MTreg_loByte); + i2cWrite(lowLevelMode); + lastSampleStart = millis(); + currentMode = mode; + return setSensitivity(currentSensitivity); + break; + default: + return 0; + } +} + +word BH1750FVI::startSingleSample(char mode){ + if(mode==BH_NoMod){ + mode=currentMode; + } + switch(mode){ + case BH_SingH: + case BH_Singh: + case BH_SingL: + i2cWrite(BH_PowOn); + i2cWrite(MTreg_hiByte); + i2cWrite(MTreg_loByte); + i2cWrite(mode); + lastSampleStart = millis(); + currentMode = mode; + return setSensitivity(currentSensitivity); + break; + default: + return 0; + } +} + +bool BH1750FVI::sampleIsFresh(){ + if(sampleUnseen) return true; + else if((millis() > (lastSampleStart+currentSamplingTime))){ + sampleUnseen = true; + return true; + } + else return false; +} + +word BH1750FVI::getLightLevel(char mode){ + unsigned long int Intensity_value; + sampleUnseen = false; + Intensity_value = i2cRead(); + if(mode!='r'){ + Intensity_value = (Intensity_value*5)/6; + if(mode!='c'){ + Intensity_value = (Intensity_value*69)/currentSensitivity; + } + /*this next adjustment is not useful in practice. if you're using + a half-scale mode, you want the extra sensitivity. I'm leaving it + here for reference. + switch(currentMode){ + case BH_Singh: + case BH_Conth: + Intensity_value /= 2; + }*/ + Intensity_value = constrain(Intensity_value, 0, 65535); + } + switch(currentMode){ + case BH_ContH: + case BH_Conth: + case BH_ContL: + case BH_EasyH: + //this is a fake previous sample time that will keep pace with + //the actual BH1750FVI's sampling rate, but isn't necessarily + //synchronized to the earliest time each new sample is available. + //if you want true synchronized timing, use a single-sample mode. + lastSampleStart = millis(); + } + return (word)Intensity_value; +} + +word BH1750FVI::setSensitivity(double sens){ + if(sens<((double)(BH_MinSv/2))){ + sens = constrain(sens, + ((double)BH_MinSv/(double)BH_DefSv), + ((double)BH_MaxSv/(double)BH_DefSv) + ); + sens = sens*(double)BH_DefSv; + } + else{ + sens = constrain(sens, (double)BH_MinSv, (double)BH_MaxSv); + } + return setSensitivity((byte)round(sens)); +} + +word BH1750FVI::setSensitivity(float sens){ + return setSensitivity((double)sens); +} + +word BH1750FVI::setSensitivity(int sens){ + sens = constrain(sens, 1, BH_MaxSv); + return setSensitivity((byte)sens); +} + +word BH1750FVI::setSensitivity(byte sens){ + if(sens<(BH_MinSv/2)){ + sens = BH_DefSv*(constrain(sens, (byte)1, (byte)3)); + } + else{ + sens = constrain(sens, BH_MinSv, BH_MaxSv); + } + switch(currentMode){ + case BH_ContL: + case BH_SingL: + currentSamplingTime = (word)((BH_FastD*(unsigned long int)sens)/BH_DefSv); + break; + default: + currentSamplingTime = (word)((((unsigned long int)BH_SlowD)*((unsigned long int)sens))/BH_DefSv); + break; + } + MTreg_hiByte = BH_MTrHb | (sens >> 5); + MTreg_loByte = BH_MTrLb | (sens & 0b00011111); + currentSensitivity = sens; + sampleUnseen = false; + return currentSamplingTime; +} + +void BH1750FVI::powerDown(){ + i2cWrite(BH_PowOf); +} + +/*I2C INTERFACE + These two functions were originally based on code written by + https://github.com/claws/ and + https://github.com/Genotronex/ +*/ +void BH1750FVI::i2cWrite(byte dataToSend){ + Wire.beginTransmission(address); + Wire.write(dataToSend); + Wire.endTransmission(); +} + +word BH1750FVI::i2cRead(){ + word value; + Wire.beginTransmission(address); + Wire.requestFrom(address, (byte)2); + if(Wire.available()){ + value = Wire.read(); + if(Wire.available()){ + value <<= 8; + value |= Wire.read(); + } + else value=0; + } + else value=0; + Wire.endTransmission(); + return value; +} diff --git a/examples/osd/arduino-weather/BH1750FVI.h b/examples/osd/arduino-weather/BH1750FVI.h new file mode 100644 index 000000000..acdf62102 --- /dev/null +++ b/examples/osd/arduino-weather/BH1750FVI.h @@ -0,0 +1,115 @@ +#ifndef BH1750FVI_h +#define BH1750FVI_h + +//#if ARDUINO >= 100 + #include "Arduino.h" +//#else +// #include "WProgram.h" +//#endif + +#include + +//device address options +#define BH_AddrL 0x23 // Device address when addr pin is LOW +#define BH_AddrH 0x5C // Device address when addr pin is HIGH + +//power codes +#define BH_PowOf 0x00 // power-off code +#define BH_PowOn 0x01 // power-on code +#define BH_Reset 0x07 // code to reset the light reading register to zero + +//mode codes +#define BH_NoMod 0x02 // No mode specified. Keeps mode the same as before. +#define BH_EasyH 0x03 // 'easy' mode. basically the same as ContH +#define BH_ContH 0x10 // continuous full-scale, high-resolution sampling +#define BH_Conth 0x11 // continuous with twice the resolution but half the max value +#define BH_ContL 0x13 // continuous full-scale, low-resolution sampling. faster. +#define BH_SingH 0x20 // take one high-resolution, full-scale sample then turn off +#define BH_Singh 0x21 // take one high-resolution, half-scale sample then turn off +#define BH_SingL 0x23 // take one low-resolution, full-scale sample then turn off + // (happens to be the same as the low address value) + +//sensitivity codes +#define BH_MTrHb 0x40 // last 3 bits must be masked to 3 MSB of desired value +#define BH_MTrLb 0x60 // last 5 bits must be masked to 5 LSB of desired value +#define BH_MinSv 31 // minimum sensitivity register value, yields Lux * 0.45 +#define BH_MaxSv 254 // maximum sensitivity register value, yields Lux * 3.68 +#define BH_DefSv 69 // default sensitivity register value, yields Lux * 1.00 + +//timing delays. they're actually longer than the datasheet says. +#define BH_FastD 18 // basic delay in microseconds for a fast sample +#define BH_SlowD 125 // basic delay in microseconds for a slow sample + +class BH1750FVI { + public: + /*BEGIN + this is intended to be as error-tolerant as possible. if you don't supply + a mode, the default mode will be 'easy'. the sensitivity obviously defaults + to 1.0 (byte value of 69). Default address selection is LOW, which is how + the BH1750FVI should default if you don't connect anything to its ADDR pin. + */void begin(byte mode=BH_EasyH, byte addr=BH_AddrL, double sens=BH_DefSv, int addrPin=-1); + + /*FRESH SAMPLE POLLING + Check whether you have already looked at the current sample. + */bool sampleIsFresh(); + + /*ACTUALLY GET A READING FROM THE SENSOR + This is probably all you wanted from this library. Return value is an + unsigned 16 bit integer with units of Lux. There are three possible modes: + 'r' raw numerical reading, no units, you get what you get + 'c' convert units to Lux or half-Lux, depending on the mode, but don't + compensate for the sensitivity setting. This allows sensitivity to + be used as enclosure optics calibration/compensation. + 't' true Lux (or half-Lux) reading, regardless of sensitivity settings. + */word getLightLevel(char adjustments='c'); + + word retrieveSample(); + + /*CONTINUOUS SAMPLING + Return value of this start function is the delay time between refreshes of + the ambient light reading. After you call this function, you can use getLightLevel() + to read the most recent ambient light level. If you try to run this ongoing start + function with a one-time mode argument, it will do nothing and return 0. + */word startOngoingSamples(char mode=BH_NoMod); + + /*ONE-TIME SAMPLE START + Return value of this start function is the delay time before the new ambient + light reading will be available. You can check whether the new sample is ready + yet using sampleIsFresh(). Retrieve that single sample with getLightLevel(). + If you give this one-time start function a continuous mode argument, it will + do nothing and return 0. + */word startSingleSample(char mode=BH_NoMod); + + /*SENSITIVITY SETTINGS + This function lets you change the 'sensitivity' of the BH1750FVI by changing + its sampling time up or down. The sensitivity is stored as a number between + 31 and 254, with a default value of 69. This is intended to compensate for + having the chip installed in an enclosure that blocks some ambient light. + The floating point versions of the function allow the sensitivity to be + given as a ratio between ~0.45 and ~3.68. The return value is the number of + milliseconds that the chip will take to create a new light level reading. + */word setSensitivity(double sens); + word setSensitivity(float sens); + word setSensitivity(int sens); + word setSensitivity(byte sens=BH_DefSv); + + /*POWERDOWN FUNCTION + In case you want to turn off the BH1750FVI to save power. Other commands will wake + the chip back up. Single sample modes automatically turn off the chip after sampling, + but you can still read the value from it without waking it up. + */void powerDown(); + + private: + void init(byte mode, byte addr, byte sens); + void i2cWrite(byte dataToSend); + word i2cRead(); + byte address; + byte currentMode; + byte currentSensitivity; + bool sampleUnseen; + byte MTreg_hiByte; + byte MTreg_loByte; + unsigned long int lastSampleStart; + word currentSamplingTime; +}; +#endif diff --git a/examples/osd/arduino-weather/Barometer.cpp b/examples/osd/arduino-weather/Barometer.cpp new file mode 100644 index 000000000..ec8b294a8 --- /dev/null +++ b/examples/osd/arduino-weather/Barometer.cpp @@ -0,0 +1,175 @@ +/* + Barometer library V1.0 + 2010 Copyright (c) Seeed Technology Inc. All right reserved. + + Original Author: LG + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#include "Barometer.h" +#include +#include + +void Barometer::init(void) +{ + Wire.begin(); +// Serial.print("Temperaturet: "); + ac1 = bmp085ReadInt(0xAA); + ac2 = bmp085ReadInt(0xAC); + ac3 = bmp085ReadInt(0xAE); + ac4 = bmp085ReadInt(0xB0); + ac5 = bmp085ReadInt(0xB2); + ac6 = bmp085ReadInt(0xB4); + b1 = bmp085ReadInt(0xB6); + b2 = bmp085ReadInt(0xB8); + mb = bmp085ReadInt(0xBA); + mc = bmp085ReadInt(0xBC); + md = bmp085ReadInt(0xBE); +// Serial.print("Temperaturet2: "); +} +// Read 1 byte from the BMP085 at 'address' +// Return: the read byte; +char Barometer::bmp085Read(unsigned char address) +{ + //Wire.begin(); + //unsigned char data; + Wire.beginTransmission(BMP085_ADDRESS); + Wire.write(address); + Wire.endTransmission(); + + Wire.requestFrom(BMP085_ADDRESS, 1); + while(!Wire.available()); + return Wire.read(); +} +// Read 2 bytes from the BMP085 +// First byte will be from 'address' +// Second byte will be from 'address'+1 +int Barometer::bmp085ReadInt(unsigned char address) +{ + unsigned char msb, lsb; + Wire.beginTransmission(BMP085_ADDRESS); + Wire.write(address); + Wire.endTransmission(); + Wire.requestFrom(BMP085_ADDRESS, 2); + while(Wire.available()<2); + msb = Wire.read(); + lsb = Wire.read(); + return (int) msb<<8 | lsb; +} +// Read the uncompensated temperature value +unsigned int Barometer::bmp085ReadUT() +{ + unsigned int ut; + Wire.beginTransmission(BMP085_ADDRESS); + Wire.write(0xF4); + Wire.write(0x2E); + Wire.endTransmission(); + delay(5); + ut = bmp085ReadInt(0xF6); + return ut; +} +// Read the uncompensated pressure value +unsigned long Barometer::bmp085ReadUP() +{ + unsigned char msb, lsb, xlsb; + unsigned long up = 0; + Wire.beginTransmission(BMP085_ADDRESS); + Wire.write(0xF4); + Wire.write(0x34 + (OSS<<6)); + Wire.endTransmission(); + delay(2 + (3<> (8-OSS); + return up; +} +void Barometer::writeRegister(int deviceAddress, byte address, byte val) +{ + Wire.beginTransmission(deviceAddress); // start transmission to device + Wire.write(address); // send register address + Wire.write(val); // send value to write + Wire.endTransmission(); // end transmission +} +int Barometer::readRegister(int deviceAddress, byte address) +{ + int v; + Wire.beginTransmission(deviceAddress); + Wire.write(address); // register to read + Wire.endTransmission(); + + Wire.requestFrom(deviceAddress, 1); // read a byte + + while(!Wire.available()) { + // waiting + } + + v = Wire.read(); + return v; +} +float Barometer::calcAltitude(float pressure) +{ + float A = pressure/101325; + float B = 1/5.25588; + float C = pow(A,B); + C = 1 - C; + C = C /0.0000225577; + return C; +} +float Barometer::bmp085GetTemperature(unsigned int ut) +{ + long x1, x2; + + x1 = (((long)ut - (long)ac6)*(long)ac5) >> 15; + x2 = ((long)mc << 11)/(x1 + md); + PressureCompensate = x1 + x2; + + float temp = ((PressureCompensate + 8)>>4); + temp = temp /10; + + return temp; +} +long Barometer::bmp085GetPressure(unsigned long up) +{ + long x1, x2, x3, b3, b6, p; + unsigned long b4, b7; + b6 = PressureCompensate - 4000; + x1 = (b2 * (b6 * b6)>>12)>>11; + x2 = (ac2 * b6)>>11; + x3 = x1 + x2; + b3 = (((((long)ac1)*4 + x3)<>2; + + // Calculate B4 + x1 = (ac3 * b6)>>13; + x2 = (b1 * ((b6 * b6)>>12))>>16; + x3 = ((x1 + x2) + 2)>>2; + b4 = (ac4 * (unsigned long)(x3 + 32768))>>15; + + b7 = ((unsigned long)(up - b3) * (50000>>OSS)); + if (b7 < 0x80000000) + p = (b7<<1)/b4; + else + p = (b7/b4)<<1; + + x1 = (p>>8) * (p>>8); + x1 = (x1 * 3038)>>16; + x2 = (-7357 * p)>>16; + p += (x1 + x2 + 3791)>>4; + + long temp = p; + return temp; +} diff --git a/examples/osd/arduino-weather/Barometer.h b/examples/osd/arduino-weather/Barometer.h new file mode 100644 index 000000000..161702718 --- /dev/null +++ b/examples/osd/arduino-weather/Barometer.h @@ -0,0 +1,58 @@ +/* + Barometer library V1.0 + 2010 Copyright (c) Seeed Technology Inc. All right reserved. + + Original Author: LG + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#ifndef __BAROMETER_H__ +#define __BAROMETER_H__ + +#include +#include + +const unsigned char OSS = 0; +#define BMP085_ADDRESS 0x77 +class Barometer +{ +public: + void init(void); + long PressureCompensate; + float bmp085GetTemperature(unsigned int ut); + long bmp085GetPressure(unsigned long up); + float calcAltitude(float pressure); + unsigned int bmp085ReadUT(void); + unsigned long bmp085ReadUP(void); + +private: + int ac1; + int ac2; + int ac3; + unsigned int ac4; + unsigned int ac5; + unsigned int ac6; + int b1; + int b2; + int mb; + int mc; + int md; + char bmp085Read(unsigned char address); + int bmp085ReadInt(unsigned char address); + void writeRegister(int deviceAddress, byte address, byte val); + int readRegister(int deviceAddress, byte address); +}; + +#endif diff --git a/examples/osd/arduino-weather/Makefile b/examples/osd/arduino-weather/Makefile new file mode 100644 index 000000000..79a367a8c --- /dev/null +++ b/examples/osd/arduino-weather/Makefile @@ -0,0 +1,71 @@ +# Set this to the name of your sketch (without extension .pde) +SKETCH=sketch +EXE=arduino-example + +all: $(EXE) + +CONTIKI=../../.. + +# Contiki IPv6 configuration +CONTIKI_WITH_IPV6 = 1 + +CFLAGS += -DPROJECT_CONF_H=\"project-conf.h\" +LFLAGS += -lm + +PROJECT_SOURCEFILES += ${SKETCH}.cpp Barometer.cpp BH1750FVI.cpp Adafruit_HTU21DF.cpp + +# automatically build RESTful resources +REST_RESOURCES_DIR = ./resources +REST_RESOURCES_DIR_COMMON = ../resources-common +REST_RESOURCES_FILES= $(notdir \ + $(shell find $(REST_RESOURCES_DIR) -name '*.c') \ + $(shell find $(REST_RESOURCES_DIR_COMMON) -name '*.c') \ + ) + +PROJECTDIRS += $(REST_RESOURCES_DIR) $(REST_RESOURCES_DIR_COMMON) +PROJECT_SOURCEFILES += $(REST_RESOURCES_FILES) + +# variable for Makefile.include +ifneq ($(TARGET), minimal-net) +CFLAGS += -DUIP_CONF_IPV6_RPL=1 +else +# minimal-net does not support RPL under Linux and is mostly used to test CoAP only +${info INFO: compiling without RPL} +CFLAGS += -DUIP_CONF_IPV6_RPL=0 +CFLAGS += -DHARD_CODED_ADDRESS=\"fdfd::10\" +${info INFO: compiling with large buffers} +CFLAGS += -DUIP_CONF_BUFFER_SIZE=2048 +CFLAGS += -DREST_MAX_CHUNK_SIZE=1024 +CFLAGS += -DCOAP_MAX_HEADER_SIZE=640 +endif + +# linker optimizations +SMALL=1 + + +# REST Engine shall use Erbium CoAP implementation +APPS += er-coap +APPS += rest-engine +APPS += arduino + +include $(CONTIKI)/Makefile.include +include $(CONTIKI)/apps/arduino/Makefile.include + +$(CONTIKI)/tools/tunslip6: $(CONTIKI)/tools/tunslip6.c + (cd $(CONTIKI)/tools && $(MAKE) tunslip6) + +connect-router: $(CONTIKI)/tools/tunslip6 + sudo $(CONTIKI)/tools/tunslip6 aaaa::1/64 + +connect-router-cooja: $(CONTIKI)/tools/tunslip6 + sudo $(CONTIKI)/tools/tunslip6 -a 127.0.0.1 aaaa::1/64 + +connect-minimal: + sudo ip address add fdfd::1/64 dev tap0 + +avr-size: $(EXE).$(TARGET).sz + +flash: $(EXE).$(TARGET).u $(EXE).$(TARGET).eu + +.PHONY: flash avr-size +.PRECIOUS: $(EXE).$(TARGET).hex $(EXE).$(TARGET).eep diff --git a/examples/osd/arduino-weather/README.md b/examples/osd/arduino-weather/README.md new file mode 100644 index 000000000..e1490ed05 --- /dev/null +++ b/examples/osd/arduino-weather/README.md @@ -0,0 +1,11 @@ +Arduino compatibility example +============================= + +This example shows that it is now possible to re-use arduino sketches in +Contiki. This example documents the necessary magic. Arduino specifies +two routines, `setup` and `loop`. Before `setup` is called, the +framework initializes hardware. In original Arduino, all this is done in +a `main` function (in C). For contiki we define a process that does the +same. + +See the documentation file in apps/contiki-compat/README.md diff --git a/examples/osd/arduino-weather/arduino-example.c b/examples/osd/arduino-weather/arduino-example.c new file mode 100644 index 000000000..ea74dd8b8 --- /dev/null +++ b/examples/osd/arduino-weather/arduino-example.c @@ -0,0 +1,2 @@ +#include +AUTOSTART_PROCESSES(&arduino_sketch); diff --git a/examples/osd/arduino-weather/flash.sh b/examples/osd/arduino-weather/flash.sh new file mode 100755 index 000000000..e82962073 --- /dev/null +++ b/examples/osd/arduino-weather/flash.sh @@ -0,0 +1,2 @@ +#!/bin/bash +make TARGET=osd-merkur-128 flash diff --git a/examples/osd/arduino-weather/project-conf.h b/examples/osd/arduino-weather/project-conf.h new file mode 100644 index 000000000..e25aed53c --- /dev/null +++ b/examples/osd/arduino-weather/project-conf.h @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2010, Swedish Institute of Computer Science. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * + */ + +#ifndef PROJECT_RPL_WEB_CONF_H_ +#define PROJECT_RPL_WEB_CONF_H_ + +#define PLATFORM_HAS_LEDS 1 +//#define PLATFORM_HAS_BUTTON 1 +#define PLATFORM_HAS_BATTERY 1 + +#define SICSLOWPAN_CONF_FRAG 1 + +#define LOOP_INTERVAL (10 * CLOCK_SECOND) + +/* Save energy */ +//#define RDC_CONF_PT_YIELD_OFF + +/* For Debug: Dont allow MCU sleeping between channel checks */ +//#undef RDC_CONF_MCU_SLEEP +//#define RDC_CONF_MCU_SLEEP 0 + +/* Disabling RDC for demo purposes. Core updates often require more memory. */ +/* For projects, optimize memory and enable RDC again. */ +// #undef NETSTACK_CONF_RDC +//#define NETSTACK_CONF_RDC nullrdc_driver + +/* Increase rpl-border-router IP-buffer when using more than 64. */ +#undef REST_MAX_CHUNK_SIZE +#define REST_MAX_CHUNK_SIZE 64 + +/* Estimate your header size, especially when using Proxy-Uri. */ +/* +#undef COAP_MAX_HEADER_SIZE +#define COAP_MAX_HEADER_SIZE 70 +*/ + +/* The IP buffer size must fit all other hops, in particular the border router. */ + +#undef UIP_CONF_BUFFER_SIZE +#define UIP_CONF_BUFFER_SIZE 256 + + +/* Multiplies with chunk size, be aware of memory constraints. */ +#undef COAP_MAX_OPEN_TRANSACTIONS +#define COAP_MAX_OPEN_TRANSACTIONS 4 + +/* Must be <= open transaction number, default is COAP_MAX_OPEN_TRANSACTIONS-1. */ +/* +#undef COAP_MAX_OBSERVERS +#define COAP_MAX_OBSERVERS 2 +*/ + +/* Filtering .well-known/core per query can be disabled to save space. */ +/* +#undef COAP_LINK_FORMAT_FILTERING +#define COAP_LINK_FORMAT_FILTERING 0 +*/ + +/* Save some memory for the sky platform. */ +/* +#undef NBR_TABLE_CONF_MAX_NEIGHBORS +#define NBR_TABLE_CONF_MAX_NEIGHBORS 10 +#undef UIP_CONF_MAX_ROUTES +#define UIP_CONF_MAX_ROUTES 10 +*/ + +/* Reduce 802.15.4 frame queue to save RAM. */ +/* +#undef QUEUEBUF_CONF_NUM +#define QUEUEBUF_CONF_NUM 4 +*/ + +/* +#undef SICSLOWPAN_CONF_FRAG +#define SICSLOWPAN_CONF_FRAG 1 +*/ + +#endif /* PROJECT_RPL_WEB_CONF_H_ */ diff --git a/examples/osd/arduino-weather/resources/res-bh1750.c b/examples/osd/arduino-weather/resources/res-bh1750.c new file mode 100644 index 000000000..ae47f07a5 --- /dev/null +++ b/examples/osd/arduino-weather/resources/res-bh1750.c @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Moisture resource + * \author + * Harald Pichler + */ + +#include "contiki.h" + +#include +#include "rest-engine.h" +#include "Arduino.h" + +static void res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/* A simple getter example. Returns the reading from the sensor with a simple etag */ +RESOURCE(res_bh1750, + "title=\"Lux status\";rt=\"Lux\"", + res_get_handler, + NULL, + NULL, + NULL); + +extern uint16_t lux; + + +static void +res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + unsigned int accept = -1; + REST.get_header_accept(request, &accept); + + if(accept == -1 || accept == REST.type.TEXT_PLAIN) { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%d", lux); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else if(accept == REST.type.APPLICATION_JSON) { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'lux':%d}", lux); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else { + REST.set_response_status(response, REST.status.NOT_ACCEPTABLE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} diff --git a/examples/osd/arduino-weather/resources/res-bmp085alt.c b/examples/osd/arduino-weather/resources/res-bmp085alt.c new file mode 100644 index 000000000..de90eae4f --- /dev/null +++ b/examples/osd/arduino-weather/resources/res-bmp085alt.c @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Barometer resource + * \author + * Harald Pichler + */ + +#include "contiki.h" + +#include +#include "rest-engine.h" +#include "Arduino.h" + +static void res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/* A simple getter example. Returns the reading from the sensor with a simple etag */ +RESOURCE(res_bmp085alt, + "title=\"alt status\";rt=\"alt\"", + res_get_handler, + NULL, + NULL, + NULL); + +extern char bmp085alt_s[8]; + +static void +res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + unsigned int accept = -1; + REST.get_header_accept(request, &accept); + + if(accept == -1 || accept == REST.type.TEXT_PLAIN) { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%s", bmp085alt_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else if(accept == REST.type.APPLICATION_JSON) { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'temperature':%s}", bmp085alt_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else { + REST.set_response_status(response, REST.status.NOT_ACCEPTABLE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} diff --git a/examples/osd/arduino-weather/resources/res-bmp085atm.c b/examples/osd/arduino-weather/resources/res-bmp085atm.c new file mode 100644 index 000000000..b97cffe6e --- /dev/null +++ b/examples/osd/arduino-weather/resources/res-bmp085atm.c @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Barometer resource + * \author + * Harald Pichler + */ + +#include "contiki.h" + +#include +#include "rest-engine.h" +#include "Arduino.h" + +static void res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/* A simple getter example. Returns the reading from the sensor with a simple etag */ +RESOURCE(res_bmp085atm, + "title=\"atm status\";rt=\"atm\"", + res_get_handler, + NULL, + NULL, + NULL); + +extern char bmp085atm_s[8]; + +static void +res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + unsigned int accept = -1; + REST.get_header_accept(request, &accept); + + if(accept == -1 || accept == REST.type.TEXT_PLAIN) { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%s", bmp085atm_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else if(accept == REST.type.APPLICATION_JSON) { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'temperature':%s}", bmp085atm_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else { + REST.set_response_status(response, REST.status.NOT_ACCEPTABLE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} diff --git a/examples/osd/arduino-weather/resources/res-bmp085press.c b/examples/osd/arduino-weather/resources/res-bmp085press.c new file mode 100644 index 000000000..6a02f4bf0 --- /dev/null +++ b/examples/osd/arduino-weather/resources/res-bmp085press.c @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Barometer resource + * \author + * Harald Pichler + */ + +#include "contiki.h" + +#include +#include "rest-engine.h" +#include "Arduino.h" + +static void res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/* A simple getter example. Returns the reading from the sensor with a simple etag */ +RESOURCE(res_bmp085press, + "title=\"pressure status\";rt=\"pressure\"", + res_get_handler, + NULL, + NULL, + NULL); + +extern char bmp085press_s[8]; + +static void +res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + unsigned int accept = -1; + REST.get_header_accept(request, &accept); + + if(accept == -1 || accept == REST.type.TEXT_PLAIN) { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%s", bmp085press_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else if(accept == REST.type.APPLICATION_JSON) { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'pressure':%s}", bmp085press_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else { + REST.set_response_status(response, REST.status.NOT_ACCEPTABLE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} diff --git a/examples/osd/arduino-weather/resources/res-htu21dhum.c b/examples/osd/arduino-weather/resources/res-htu21dhum.c new file mode 100644 index 000000000..f66c71c74 --- /dev/null +++ b/examples/osd/arduino-weather/resources/res-htu21dhum.c @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Moisture resource + * \author + * Harald Pichler + */ + +#include "contiki.h" + +#include +#include "rest-engine.h" +#include "Arduino.h" + +static void res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/* A simple getter example. Returns the reading from the sensor with a simple etag */ +RESOURCE(res_htu21dhum, + "title=\"Moisture status\";rt=\"Moisture\"", + res_get_handler, + NULL, + NULL, + NULL); + +extern char htu21d_hum_s[8]; + + +static void +res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + unsigned int accept = -1; + REST.get_header_accept(request, &accept); + + if(accept == -1 || accept == REST.type.TEXT_PLAIN) { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%s", htu21d_hum_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else if(accept == REST.type.APPLICATION_JSON) { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'moisture':%s}", htu21d_hum_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else { + REST.set_response_status(response, REST.status.NOT_ACCEPTABLE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} diff --git a/examples/osd/arduino-weather/resources/res-htu21dtemp.c b/examples/osd/arduino-weather/resources/res-htu21dtemp.c new file mode 100644 index 000000000..cdc9a9a7d --- /dev/null +++ b/examples/osd/arduino-weather/resources/res-htu21dtemp.c @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Moisture resource + * \author + * Harald Pichler + */ + +#include "contiki.h" + +#include +#include "rest-engine.h" +#include "Arduino.h" + +static void res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/* A simple getter example. Returns the reading from the sensor with a simple etag */ +RESOURCE(res_htu21dtemp, + "title=\"Temperature status\";rt=\"Temperatur\"", + res_get_handler, + NULL, + NULL, + NULL); + +extern char htu21d_temp_s[8]; + +static void +res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + unsigned int accept = -1; + REST.get_header_accept(request, &accept); + + if(accept == -1 || accept == REST.type.TEXT_PLAIN) { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%s", htu21d_temp_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else if(accept == REST.type.APPLICATION_JSON) { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'temperature':%s}", htu21d_temp_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else { + REST.set_response_status(response, REST.status.NOT_ACCEPTABLE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} diff --git a/examples/osd/arduino-weather/run.sh b/examples/osd/arduino-weather/run.sh new file mode 100755 index 000000000..5d5cbbbb4 --- /dev/null +++ b/examples/osd/arduino-weather/run.sh @@ -0,0 +1,5 @@ +#!/bin/bash +# For the ages-old bootloader (before 2014) you want to use +# BOOTLOADER_GET_MAC=0x0001f3a0 as parameter to make below. +make clean TARGET=osd-merkur-128 +make TARGET=osd-merkur-128 diff --git a/examples/osd/arduino-weather/sketch.pde b/examples/osd/arduino-weather/sketch.pde new file mode 100644 index 000000000..513557347 --- /dev/null +++ b/examples/osd/arduino-weather/sketch.pde @@ -0,0 +1,128 @@ +/* + * Sample arduino sketch using contiki features. + * We turn the LED off + * We allow read the moisture sensor + * Unfortunately sleeping for long times in loop() isn't currently + * possible, something turns off the CPU (including PWM outputs) if a + * Proto-Thread is taking too long. We need to find out how to sleep in + * a Contiki-compatible way. + * Note that for a normal arduino sketch you won't have to include any + * of the contiki-specific files here, the sketch should just work. + */ + +#include +#include "Barometer.h" +#include "Adafruit_HTU21DF.h" +#include "BH1750FVI.h" + +extern "C" { +#include "arduino-process.h" +#include "rest-engine.h" + +extern resource_t res_bh1750, res_htu21dtemp, res_htu21dhum, res_bmp085press,res_bmp085atm,res_bmp085alt, res_battery; + +float bmp085temp; +float bmp085press; +float bmp085atm; +float bmp085alt; +char bmp085temp_s[8]; +char bmp085press_s[8]; +char bmp085atm_s[8]; +char bmp085alt_s[8]; + +Barometer myBarometer; + +float htu21d_hum; +float htu21d_temp; +char htu21d_hum_s[8]; +char htu21d_temp_s[8]; + +Adafruit_HTU21DF htu = Adafruit_HTU21DF(); + +uint16_t lux; + +BH1750FVI lightMeter; + +#define LED_PIN 4 +} + +void setup (void) +{ + // switch off the led + pinMode(LED_PIN, OUTPUT); + digitalWrite(LED_PIN, HIGH); + // BH1750 sensor + Wire.begin(); + lightMeter.begin(); + // BMP085 sensor + myBarometer.init(); + // htu21d sensor + if (!htu.begin()) { + printf("Couldn't find sensor htu21d !"); + } + // init coap resourcen + rest_init_engine (); + rest_activate_resource (&res_bmp085press, "s/press"); + rest_activate_resource (&res_bmp085atm, "s/atm"); + rest_activate_resource (&res_bmp085alt, "s/alt"); + rest_activate_resource (&res_htu21dtemp, "s/temp"); + rest_activate_resource (&res_htu21dhum, "s/hum"); + rest_activate_resource (&res_bh1750, "s/lux"); + rest_activate_resource (&res_battery, "s/battery"); +} + +// at project-conf.h +// LOOP_INTERVAL (10 * CLOCK_SECOND) +void loop (void) +{ + mcu_sleep_off(); + // BMP085 Sensor + bmp085temp = myBarometer.bmp085GetTemperature(myBarometer.bmp085ReadUT()); //Get the temperature, bmp085ReadUT MUST be called first + bmp085press = myBarometer.bmp085GetPressure(myBarometer.bmp085ReadUP());//Get the temperature + bmp085alt = myBarometer.calcAltitude(bmp085press); //Uncompensated caculation - in Meters + bmp085atm = bmp085press / 101325; + + dtostrf(bmp085temp , 6, 2, bmp085temp_s ); + dtostrf(bmp085press , 6, 2, bmp085press_s ); + dtostrf(bmp085alt , 6, 2, bmp085alt_s ); + dtostrf(bmp085atm , 6, 2, bmp085atm_s ); + // remove space + if(bmp085temp_s[0]==' '){ + memcpy (bmp085temp_s,bmp085temp_s+1,strlen(bmp085temp_s)+1); + } + if(bmp085press_s[0]==' '){ + memcpy (bmp085press_s,bmp085press_s+1,strlen(bmp085press_s)+1); + } + if(bmp085alt_s[0]==' '){ + memcpy (bmp085alt_s,bmp085alt_s+1,strlen(bmp085alt_s)+1); + } + if(bmp085atm_s[0]==' '){ + memcpy (bmp085atm_s,bmp085atm_s+1,strlen(bmp085atm_s)+1); + } + // HTU21d Sensor + htu21d_temp = htu.readTemperature(); + htu21d_hum = htu.readHumidity(); + dtostrf(htu21d_temp , 6, 2, htu21d_temp_s ); + dtostrf(htu21d_hum , 6, 2, htu21d_hum_s ); + // remove space + if(htu21d_temp_s[0]==' '){ + memcpy (htu21d_temp_s,htu21d_temp_s+1,strlen(htu21d_temp_s)+1); + } + if(htu21d_hum_s[0]==' '){ + memcpy (htu21d_hum_s,htu21d_hum_s+1,strlen(htu21d_hum_s)+1); + } + // BH1750 + lux = lightMeter.getLightLevel(); + +// Debug Print + printf("BMP085"); + printf("\t\tPress: %s\n",bmp085press_s); + printf("\t\tAltitude: %s\n",bmp085alt_s); + printf("\t\tatm: %s\n",bmp085atm_s); + printf("\t\tHTU21d"); + printf("\t\tTemp: %s",htu21d_temp_s); + printf("\t\tHum: %s\n",htu21d_hum_s); + printf("\t\tBH1750"); + printf("Lux: %d\n",lux); + mcu_sleep_on(); +}