Initial commit no BLE

testeurInstant/PCF8574.cpp

+/*
+ * See header file for details
+ *
+ *  This program is free software: you can redistribute it and/or modify\n
+ *  it under the terms of the GNU General Public License as published by\n
+ *  the Free Software Foundation, either version 3 of the License, or\n
+ *  (at your option) any later version.\n
+ * 
+ *  This program is distributed in the hope that it will be useful,\n
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of\n
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n
+ *  GNU General Public License for more details.\n
+ * 
+ *  You should have received a copy of the GNU General Public License\n
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.\n
+ */
+
+/* Dependencies */
+#include <Wire.h>
+#include "PCF8574.h"
+
+PCF8574::PCF8574() :
+		_PORT(0), _PIN(0), _DDR(0), _address(0)
+#ifdef PCF8574_INTERRUPT_SUPPORT
+		, _oldPIN(0), _isrIgnore(0), _pcintPin(0), _intMode(), _intCallback()
+#endif
+{
+}
+
+void PCF8574::begin(uint8_t address) {
+
+	/* Store the I2C address and init the Wire library */
+	_address = address;
+	Wire.begin();
+	readGPIO();
+}
+
+void PCF8574::pinMode(uint8_t pin, uint8_t mode) {
+
+	/* Switch according mode */
+	switch (mode) {
+	case INPUT:
+		_DDR &= ~(1 << pin);
+		_PORT &= ~(1 << pin);
+		break;
+
+	case INPUT_PULLUP:
+		_DDR &= ~(1 << pin);
+		_PORT |= (1 << pin);
+		break;
+
+	case OUTPUT:
+		_DDR |= (1 << pin);
+		_PORT &= ~(1 << pin);
+		break;
+
+	default:
+		break;
+	}
+
+	/* Update GPIO values */
+	updateGPIO();
+}
+
+void PCF8574::digitalWrite(uint8_t pin, uint8_t value) {
+
+	/* Set PORT bit value */
+	if (value)
+		_PORT |= (1 << pin);
+	else
+		_PORT &= ~(1 << pin);
+
+	/* Update GPIO values */
+	updateGPIO();
+}
+
+uint8_t PCF8574::digitalRead(uint8_t pin) {
+
+	/* Read GPIO */
+	readGPIO();
+
+#ifdef PCF8574_INTERRUPT_SUPPORT
+	/* Check for interrupt (manual detection) */
+	//checkForInterrupt();
+#endif
+
+	/* Read and return the pin state */
+	return (_PIN & (1 << pin)) ? HIGH : LOW;
+}
+
+void PCF8574::write(uint8_t value) {
+
+	/* Store pins values and apply */
+	_PORT = value;
+
+	/* Update GPIO values */
+	updateGPIO();
+}
+
+uint8_t PCF8574::read() {
+
+	/* Read GPIO */
+	readGPIO();
+
+#ifdef PCF8574_INTERRUPT_SUPPORT
+	/* Check for interrupt (manual detection) */
+	//checkForInterrupt();
+#endif
+
+	/* Return current pins values */
+	return _PIN;
+}
+
+void PCF8574::pullUp(uint8_t pin) {
+
+	/* Same as pinMode(INPUT_PULLUP) */
+	pinMode(pin, INPUT_PULLUP); // /!\ pinMode form THE LIBRARY
+}
+
+void PCF8574::pullDown(uint8_t pin) {
+
+	/* Same as pinMode(INPUT) */
+	pinMode(pin, INPUT); // /!\ pinMode form THE LIBRARY
+}
+
+void PCF8574::clear() {
+
+	/* User friendly wrapper for write() */
+	write(0x00);
+}
+
+void PCF8574::set() {
+
+	/* User friendly wrapper for write() */
+	write(0xFF);
+}
+
+void PCF8574::toggle(uint8_t pin) {
+
+	/* Toggle pin state */
+	_PORT ^= (1 << pin);
+
+	/* Update GPIO values */
+	updateGPIO();
+}
+
+void PCF8574::blink(uint8_t pin, uint16_t count, uint32_t duration) {
+
+	/* Compute steps duration */
+	duration /= count * 2;
+
+	/* Loop n times */
+	while (count--) {
+
+		/* Toggle pin 2 times */
+		toggle(pin);
+		delay(duration);
+		toggle(pin);
+		delay(duration);
+	}
+}
+
+#ifdef PCF8574_INTERRUPT_SUPPORT
+void PCF8574::enableInterrupt(uint8_t pin, void (*selfCheckFunction)(void)) {
+
+	/* Store interrupt pin number */
+	_pcintPin = pin;
+
+	/* Setup interrupt pin */
+#if ARDUINO >= 100
+	::pinMode(pin, INPUT_PULLUP); // /!\ pinMode form THE ARDUINO CORE
+#else
+	::pinMode(pin, INPUT); // /!\ pinMode form THE ARDUINO CORE
+	::digitalWrite(pin, HIGH); // /!\ digitalWrite form THE ARDUINO CORE
+#endif
+
+	/* Attach interrupt handler */
+	PCattachInterrupt(pin, selfCheckFunction, FALLING);
+}
+
+void PCF8574::disableInterrupt() {
+
+	/* Detach interrupt handler */
+	PCdetachInterrupt(_pcintPin);
+}
+
+void PCF8574::checkForInterrupt() {
+
+	/* Avoid nested interrupt triggered by I2C read/write */
+	if(_isrIgnore)
+		return;
+	else
+		_isrIgnore = 1;
+		
+	/* Re-enable interrupts to allow Wire library to work */
+	sei();
+
+	/* Read current pins values */
+	readGPIO();
+
+	/* Check all pins */
+	for (uint8_t i = 0; i < 8; ++i) {
+
+		/* Check for interrupt handler */
+		if (!_intCallback[i])
+			continue;
+
+		/* Check for interrupt event */
+		switch (_intMode[i]) {
+		case CHANGE:
+			if ((1 << i) & (_PIN ^ _oldPIN))
+				_intCallback[i]();
+			break;
+
+		case LOW:
+			if (!(_PIN & (1 << i)))
+				_intCallback[i]();
+			break;
+
+		case FALLING:
+			if ((_oldPIN & (1 << i)) && !(_PIN & (1 << i)))
+				_intCallback[i]();
+			break;
+
+		case RISING:
+			if (!(_oldPIN & (1 << i)) && (_PIN & (1 << i)))
+				_intCallback[i]();
+			break;
+		}
+	}
+	
+	/* Turn off ISR ignore flag */
+	_isrIgnore = 0;
+}
+
+void PCF8574::attachInterrupt(uint8_t pin, void (*userFunc)(void),
+		uint8_t mode) {
+
+	/* Store interrupt mode and callback */
+	_intMode[pin] = mode;
+	_intCallback[pin] = userFunc;
+}
+
+void PCF8574::detachInterrupt(uint8_t pin) {
+
+	/* Void interrupt handler */
+	_intCallback[pin] = 0;
+}
+#endif
+
+void PCF8574::readGPIO() {
+
+#ifdef PCF8574_INTERRUPT_SUPPORT
+	/* Store old _PIN value */
+	_oldPIN = _PIN;
+#endif
+
+	/* Start request, wait for data and receive GPIO values as byte */
+	Wire.requestFrom(_address, (uint8_t) 0x01);
+	while (Wire.available() < 1)
+		;
+	_PIN = I2CREAD();
+}
+
+void PCF8574::updateGPIO() {
+
+	/* Read current GPIO states */
+	//readGPIO(); // Experimental
+
+	/* Compute new GPIO states */
+	//uint8_t value = ((_PIN & ~_DDR) & ~(~_DDR & _PORT)) | _PORT; // Experimental
+	uint8_t value = (_PIN & ~_DDR) | _PORT;
+
+	/* Start communication and send GPIO values as byte */
+	Wire.beginTransmission(_address);
+	I2CWRITE(value);
+	Wire.endTransmission();
+}

testeurInstant/PCF8574.h

+/**
+ * @brief PCF8574 arduino library
+ * @author SkyWodd <skywodd@gmail.com>
+ * @version 2.0
+ * @link http://skyduino.wordpress.com/
+ *
+ * @section intro_sec Introduction
+ * This class is designed to allow user to use PCF8574 gpio expander like any standard arduino pins.\n
+ * This class provided standards arduino functions like pinMode, digitalWrite, digitalRead, ...\n
+ * This new version is fully optimized and documented.\n
+ * \n
+ * Please report bug to <skywodd at gmail.com>
+ *
+ * @section license_sec License
+ *  This program is free software: you can redistribute it and/or modify\n
+ *  it under the terms of the GNU General Public License as published by\n
+ *  the Free Software Foundation, either version 3 of the License, or\n
+ *  (at your option) any later version.\n
+ * \n
+ *  This program is distributed in the hope that it will be useful,\n
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of\n
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n
+ *  GNU General Public License for more details.\n
+ * \n
+ *  You should have received a copy of the GNU General Public License\n
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.\n
+ *
+ * @section other_sec Others notes and compatibility warning
+ * Compatible with arduino 1.0.x and >=0023\n
+ * Retro-compatible with the previous library version
+ */
+#ifndef PCF8574_H
+#define PCF8574_H
+
+/** Comment this define to disable interrupt support */
+//#ifndef PCF8574_INTERRUPT_SUPPORT
+//#define PCF8574_INTERRUPT_SUPPORT
+//#include "PCint.h"
+//#include "pins_arduino.h"
+//#endif
+
+/* Retro-compatibility with arduino 0023 and previous version */
+#if ARDUINO >= 100
+#include "Arduino.h"
+#define I2CWRITE(x) Wire.write(x)
+#define I2CREAD() Wire.read()
+#else
+#include "WProgram.h"
+#define I2CWRITE(x) Wire.send(x)
+#define I2CREAD() Wire.receive()
+#define INPUT_PULLUP 2
+#endif
+
+/**
+ * @brief PCF8574 Arduino class
+ */
+class PCF8574 {
+public:
+	/**
+	 * Create a new PCF8574 instance
+	 */
+	PCF8574();
+
+	/**
+	 * Start the I2C controller and store the PCF8574 chip address
+	 */
+	void begin(uint8_t address = 0x21);
+
+	/**
+	 * Set the direction of a pin (OUTPUT, INPUT or INPUT_PULLUP)
+	 * 
+	 * @param pin The pin to set
+	 * @param mode The new mode of the pin
+	 * @remarks INPUT_PULLUP does physicaly the same thing as INPUT (no software pull-up resistors available) but is REQUIRED if you use external pull-up resistor
+	 */
+	void pinMode(uint8_t pin, uint8_t mode);
+
+	/**
+	 * Set the state of a pin (HIGH or LOW)
+	 * 
+	 * @param pin The pin to set
+	 * @param value The new state of the pin
+	 * @remarks Software pull-up resistors are not available on the PCF8574
+	 */
+	void digitalWrite(uint8_t pin, uint8_t value);
+
+	/**
+	 * Read the state of a pin
+	 * 
+	 * @param pin The pin to read back
+	 * @return
+	 */
+	uint8_t digitalRead(uint8_t pin);
+
+	/**
+	 * Set the state of all pins in one go
+	 * 
+	 * @param value The new value of all pins (1 bit = 1 pin, '1' = HIGH, '0' = LOW)
+	 */
+	void write(uint8_t value);
+
+	/**
+	 * Read the state of all pins in one go
+	 * 
+	 * @return The current value of all pins (1 bit = 1 pin, '1' = HIGH, '0' = LOW)
+	 */
+	uint8_t read();
+
+	/**
+	 * Exactly like write(0x00), set all pins to LOW
+	 */
+	void clear();
+
+	/**
+	 * Exactly like write(0xFF), set all pins to HIGH
+	 */
+	void set();
+
+	/**
+	 * Toggle the state of a pin
+	 */
+	void toggle(uint8_t pin);
+
+	/**
+	 * Mark a pin as "pulled up"
+	 * 
+	 * @warning DO NOTHING - FOR RETRO COMPATIBILITY PURPOSE ONLY
+	 * @deprecated
+	 * @param pin Pin the mark as "pulled up"
+	 */
+	void pullUp(uint8_t pin);
+
+	/**
+	 * Mark a pin as "pulled down"
+	 * 
+	 * @warning DO NOTHING - FOR RETRO COMPATIBILITY PURPOSE ONLY
+	 * @deprecated
+	 * @param pin Pin the mark as "pulled down"
+	 */
+	void pullDown(uint8_t pin);
+
+	/**
+	 * Make a pin blink N times for T duration
+	 * 
+	 * @warning Blocking function, not recommended for new code
+	 * @deprecated
+	 * @param pin The pin to blink
+	 * @param count The number of ON/OFF couples to execute
+	 * @param duration The duration of the whole blink action in milliseconds
+	 */
+	void blink(uint8_t pin, uint16_t count, uint32_t duration);
+
+#ifdef PCF8574_INTERRUPT_SUPPORT
+	/**
+	 * Enable interrupts support and setup interrupts handler
+	 * 
+	 * @remarks Any pin can be used as "INT" pin, internally the library use PCINT to work.
+	 * @warning The check wrapping routine must be provided by user and define in the global scope space.
+	 * @param pin The pin OF YOUR ARDUINO (not the PCF8574) to use as "INT" pin for interrupts detection
+	 * @param selfCheckFunction The wrapping routine used to process interrupts events.
+	 * @remarks For best performances you should avoid this "user friendly" fonction and use the standard attachInterrupt() fonction ;)
+	 * @remarks If multiple PCF8574 are wired on the same "INT" pin this function should be called only one time
+	 */
+	void enableInterrupt(uint8_t pin, void (*selfCheckFunction)(void));
+
+	/**
+	 * Disable interrupts support
+	 */
+	void disableInterrupt();
+
+	/**
+	 * Check for interrupt and process routine
+	 * 
+	 * @remarks Call this routine from your wrapping routine to detect and process interrupts (if any) of this PCF8574 instance.
+	 */
+	void checkForInterrupt();
+
+	/**
+	 * Attach a function to an interrupt event of a pin of the PCF8574
+	 * 
+	 * @param pin The pin to attach the interrupt event on
+	 * @param userFunc The callback function to call when the interrupt event is triggered
+	 * @param mode The interrupt mode to check for, only interrupts events coming from the specified pin and with the specified mode will call the callback function.
+	 * @remarks 1 PCF8574 pin = 1 interrupt, multiple interrupts on the same pin is not supported
+	 */
+	void attachInterrupt(uint8_t pin, void (*userFunc)(void), uint8_t mode);
+
+	/**
+	 * Detach any interrupt attached to the specified pin
+	 * 
+	 * @param pin The pin to detach any interrupt from
+	 */
+	void detachInterrupt(uint8_t pin);
+#endif
+
+protected:
+	/** Output pins values */
+	volatile uint8_t _PORT;
+
+	/** Current input pins values */
+	volatile uint8_t _PIN;
+
+	/** Pins modes values (OUTPUT or INPUT) */
+	volatile uint8_t _DDR;
+
+	/** PCF8574 I2C address */
+	uint8_t _address;
+
+#ifdef PCF8574_INTERRUPT_SUPPORT
+	/** Old value of _PIN variable */
+	volatile uint8_t _oldPIN;
+	
+	/** ISR ignore flag */
+	volatile uint8_t _isrIgnore;
+
+	/** PCINT pin used for "INT" pin handling */
+	uint8_t _pcintPin;
+
+	/** Interrupts modes of pins ( LOW, CHANGE, FALLING, RISING)  */
+	uint8_t _intMode[8];
+
+	/** Interrupts callback functions */
+	void (*_intCallback[8])(void);
+#endif
+
+	/** 
+	 * Read GPIO states and store them in _PIN variable
+	 *
+	 * @remarks Before reading current GPIO states, current _PIN variable value is moved to _oldPIN variable
+	 */
+	void readGPIO();
+
+	/** 
+	 * Write value of _PORT variable to the GPIO
+	 * 
+	 * @remarks Only pin marked as OUTPUT are set, for INPUT pins their value are unchanged
+	 * @warning To work properly (and avoid any states conflicts) readGPIO() MUST be called before call this function !
+	 */
+	void updateGPIO();
+};
+
+#endif

testeurInstant/SHTSensor.cpp

+/*
+ *  Copyright (c) 2016, Sensirion AG <andreas.brauchli@sensirion.com>
+ *  Copyright (c) 2015-2016, Johannes Winkelmann <jw@smts.ch>
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are met:
+ *      * Redistributions of source code must retain the above copyright
+ *        notice, this list of conditions and the following disclaimer.
+ *      * 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.
+ *      * Neither the name of the <organization> 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 COPYRIGHT HOLDERS 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 <COPYRIGHT HOLDER> 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.
+ */
+
+#include <inttypes.h>
+#include <Wire.h>
+#include <Arduino.h>
+
+#include "SHTSensor.h"
+
+
+//
+// class SHTSensorDriver
+//
+
+SHTSensorDriver::~SHTSensorDriver()
+{
+}
+
+bool SHTSensorDriver::readSample()
+{
+  return false;
+}
+
+
+//
+// class SHTI2cSensor
+//
+
+const uint8_t SHTI2cSensor::CMD_SIZE            = 2;
+const uint8_t SHTI2cSensor::EXPECTED_DATA_SIZE  = 6;
+const uint8_t SHTI2cSensor::MAX_I2C_READ_TRIES  = 5;
+
+bool SHTI2cSensor::readFromI2c(uint8_t i2cAddress,
+                               const uint8_t *i2cCommand,
+                               uint8_t commandLength, uint8_t *data,
+                               uint8_t dataLength)
+{
+  Wire.beginTransmission(i2cAddress);
+  for (int i = 0; i < commandLength; ++i) {
+    if (Wire.write(i2cCommand[i]) != 1) {
+      return false;
+    }
+  }
+
+  if (Wire.endTransmission(false) != 0) {
+    return false;
+  }
+
+  Wire.requestFrom(i2cAddress, dataLength);
+
+  // there should be no reason for this to not be ready, since we're using clock
+  // stretching mode, but just in case we'll try a few times
+  uint8_t tries = 1;
+  while (Wire.available() < dataLength) {
+    delay(1);
+    if (tries++ >= MAX_I2C_READ_TRIES) {
+      return false;
+    }
+  }
+
+  for (int i = 0; i < dataLength; ++i) {
+    data[i] = Wire.read();
+  }
+  return true;
+}
+
+uint8_t SHTI2cSensor::crc8(const uint8_t *data, uint8_t len)
+{
+  // adapted from SHT21 sample code from
+  // http://www.sensirion.com/en/products/humidity-temperature/download-center/
+
+  uint8_t crc = 0xff;
+  uint8_t byteCtr;
+  for (byteCtr = 0; byteCtr < len; ++byteCtr) {
+    crc ^= data[byteCtr];
+    for (uint8_t bit = 8; bit > 0; --bit) {
+      if (crc & 0x80) {
+        crc = (crc << 1) ^ 0x31;
+      } else {
+        crc = (crc << 1);
+      }
+    }
+  }
+  return crc;
+}
+
+
+bool SHTI2cSensor::readSample()
+{
+  uint8_t data[EXPECTED_DATA_SIZE];
+  uint8_t cmd[CMD_SIZE];
+
+  cmd[0] = mI2cCommand >> 8;
+  cmd[1] = mI2cCommand & 0xff;
+
+  if (!readFromI2c(mI2cAddress, cmd, CMD_SIZE, data,
+                   EXPECTED_DATA_SIZE)) {
+    return false;
+  }
+
+  // -- Important: assuming each 2 byte of data is followed by 1 byte of CRC
+
+  // check CRC for both RH and T
+  if (crc8(&data[0], 2) != data[2] || crc8(&data[3], 2) != data[5]) {
+    return false;
+  }
+
+  // convert to Temperature/Humidity
+  uint16_t val;
+  val = (data[0] << 8) + data[1];
+  mTemperature = mA + mB * (val / mC);
+
+  val = (data[3] << 8) + data[4];
+  mHumidity = mX * (val / mY);
+
+  return true;
+}
+
+
+//
+// class SHTC1Sensor
+//
+
+class SHTC1Sensor : public SHTI2cSensor
+{
+public:
+    SHTC1Sensor()
+        // Using clock stretching, high precision, T first
+        : SHTI2cSensor(0x70, 0x7ca2, -45, 175, 65535, 100, 65535)
+    {
+    }
+};
+
+
+//
+// class SHT3xSensor
+//
+
+class SHT3xSensor : public SHTI2cSensor
+{
+private:
+  static const uint16_t SHT3X_ACCURACY_HIGH    = 0x2c06;
+  static const uint16_t SHT3X_ACCURACY_MEDIUM  = 0x2c0d;
+  static const uint16_t SHT3X_ACCURACY_LOW     = 0x2c10;
+
+public:
+  static const uint8_t SHT3X_I2C_ADDRESS_44 = 0x44;
+  static const uint8_t SHT3X_I2C_ADDRESS_45 = 0x45;
+
+  SHT3xSensor(uint8_t i2cAddress = SHT3X_I2C_ADDRESS_44)
+      : SHTI2cSensor(i2cAddress, SHT3X_ACCURACY_HIGH,
+                     -45, 175, 65535, 100, 65535)
+  {
+  }
+