Commit 8c47718d authored by Maxime Robin's avatar Maxime Robin

Initial commit no BLE

parents
/*
* 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();
}
/**
* @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
/*
* 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)
{
}