mirror of https://github.com/arendst/Tasmota.git
286 lines
11 KiB
Arduino
286 lines
11 KiB
Arduino
|
/****************************************************************************************************************************\
|
||
|
|
* Arduino project "TheoTinySensor" Copyright 2013 Theo Arends
|
||
|
|
* This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License
|
||
|
|
* as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||
|
|
*
|
||
|
|
* This program 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 General Public License for more details.
|
||
|
|
******************************************************************************************************************************
|
||
|
|
|
||
|
|
****************************************************************************************************************
|
||
|
|
* Purpose : Arduino Source code for Sensor based on Atmel ATTiny85, running on 8MHz
|
||
|
|
* Version : R201 - DHT11 or DHT22 and Vcc test
|
||
|
|
* Date : 20140414
|
||
|
|
* 20140507 - R202 - Verwijdering VCC_LOOP
|
||
|
|
*
|
||
|
|
* This code turns an Atmel ATTiny85 chip into a Sensor using the TheoV2 protocol.
|
||
|
|
* This code is not of any use without running a Unit within RF range to receive sensor data.
|
||
|
|
\***************************************************************************************************************/
|
||
|
|
|
||
|
|
#define SENSOR_TYPE 2 // 2 = DHT22 or DHT11 sensor
|
||
|
|
#define DHT22 // DHT22 Temperatuur en luchtvochtigheid
|
||
|
|
//#define DHT11 // DHT11 Temperatuur en luchtvochtigheid
|
||
|
|
|
||
|
|
// Uncomment for test purpose
|
||
|
|
//#define THEO_TEST
|
||
|
|
|
||
|
|
//*****************************************************************************
|
||
|
|
|
||
|
|
#ifdef THEO_TEST
|
||
|
|
#define CHANNEL 0 // 0 - 7, 0 discard by plugin
|
||
|
|
#define SEND_DELAY 2 // Max Send Delay in multiples of 4.4 seconds, so 2 = 2x4.4=9 seconds
|
||
|
|
#else
|
||
|
|
#define CHANNEL 1 // 0 - 7, 0 discard by plugin
|
||
|
|
#define SEND_DELAY 32 // Max Send Delay in multiples of 4.4 seconds, so 32 = 32x4.4=141 seconds
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#define VREF_35 10675 // Measured value for Vref at 3.5V Vcc * 10 (Chip dependent)
|
||
|
|
#define BATT_LOW 33 // 3.3V Battery low warning voltage * 10 (Functionality dependent)
|
||
|
|
|
||
|
|
//*****************************************************************************
|
||
|
|
|
||
|
|
#define DHT_PIN 1 // data to DHT11, fysieke pin 6 on ATTiny85
|
||
|
|
|
||
|
|
#define RF_TransmitDataPin 4 // data to RF Transmitter, fysieke pin 3 on ATTiny85
|
||
|
|
|
||
|
|
// ATMEL ATTINY85
|
||
|
|
// AI=Analog Input
|
||
|
|
// o-\/-+
|
||
|
|
// reset 1| |8 VCC
|
||
|
|
// Pin 3 (AI 3) PB3 2| |7
|
||
|
|
// Pin 4 (AI 2) PB4 3| |6 PB1 PWM Pin 1 - PCINT1
|
||
|
|
// GND 4| |5
|
||
|
|
// +----+
|
||
|
|
|
||
|
|
byte VccTest;
|
||
|
|
byte Voltage;
|
||
|
|
|
||
|
|
//*****************************************************************************
|
||
|
|
// Setup stuff
|
||
|
|
//*****************************************************************************
|
||
|
|
void setup()
|
||
|
|
{
|
||
|
|
VccTest = 255;
|
||
|
|
|
||
|
|
pinMode(RF_TransmitDataPin,OUTPUT);
|
||
|
|
|
||
|
|
pinMode(DHT_PIN, OUTPUT);
|
||
|
|
digitalWrite(DHT_PIN, HIGH); // Pull high
|
||
|
|
delay(3000);
|
||
|
|
|
||
|
|
Watchdog_setup(8); // Setup watchdog to notify us every 4.4 seconds
|
||
|
|
}
|
||
|
|
|
||
|
|
//*****************************************************************************
|
||
|
|
// Main loop
|
||
|
|
//*****************************************************************************
|
||
|
|
void loop()
|
||
|
|
{
|
||
|
|
int payload1 = 0;
|
||
|
|
int payload2 = 0;
|
||
|
|
|
||
|
|
VccTest++;
|
||
|
|
if (VccTest == 0) // Do not run the Vcc test too often to save Battery power
|
||
|
|
{
|
||
|
|
Voltage = ReadVcc();
|
||
|
|
if (Voltage <= BATT_LOW)
|
||
|
|
Voltage |= 0x80;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (GetPayload(payload1, payload2) == 0)
|
||
|
|
SendData(payload1, payload2);
|
||
|
|
|
||
|
|
// Watchdog_sleep(SEND_DELAY + CHANNEL); // Go to deep sleep mode for some time
|
||
|
|
Watchdog_sleep(SEND_DELAY - SENSOR_TYPE - CHANNEL); // Go to deep sleep mode for some time but not longer than 150 sec
|
||
|
|
}
|
||
|
|
|
||
|
|
//*****************************************************************************
|
||
|
|
// Sleep stuff
|
||
|
|
//*****************************************************************************
|
||
|
|
#include <avr/sleep.h>
|
||
|
|
#include <avr/wdt.h>
|
||
|
|
|
||
|
|
void Watchdog_setup(int ii)
|
||
|
|
{
|
||
|
|
// 0=16ms, 1=32ms, 2=64ms, 3=125ms, 4=250ms, 5=500ms, 6=1s, 7=2s, 8=4s, 9=8s
|
||
|
|
// The prescale value is held in bits 5,2,1,0
|
||
|
|
// This block moves ii into these bits
|
||
|
|
byte bb;
|
||
|
|
if (ii > 9 ) ii=9;
|
||
|
|
bb=ii & 7;
|
||
|
|
if (ii > 7) bb|= (1<<5);
|
||
|
|
bb|= (1<<WDCE);
|
||
|
|
|
||
|
|
MCUSR &= ~(1<<WDRF); // Reset the watchdog reset flag
|
||
|
|
WDTCR |= (1<<WDCE) | (1<<WDE); // Start timed sequence
|
||
|
|
WDTCR = bb; // Set new watchdog timeout value
|
||
|
|
WDTCR |= _BV(WDIE); // Enable interrupts instead of reset
|
||
|
|
}
|
||
|
|
|
||
|
|
void Watchdog_sleep(int waitCounter)
|
||
|
|
{
|
||
|
|
while (waitCounter != 0)
|
||
|
|
{
|
||
|
|
bitClear(ADCSRA,ADEN); // Switch Analog to Digital converter OFF
|
||
|
|
set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Set sleep mode
|
||
|
|
sleep_mode(); // System sleeps here
|
||
|
|
waitCounter--;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ISR(WDT_vect)
|
||
|
|
{
|
||
|
|
// Don't do anything here but we must include this
|
||
|
|
// block of code otherwise the interrupt calls an
|
||
|
|
// uninitialized interrupt handler.
|
||
|
|
}
|
||
|
|
|
||
|
|
//*****************************************************************************
|
||
|
|
// Send data via RF
|
||
|
|
//*****************************************************************************
|
||
|
|
#define RF_PULSE_0 500 // PWM: Tijdsduur van de puls bij verzenden van een '0' in uSec.
|
||
|
|
#define RF_PULSE_MID 1000 // PWM: Pulsen langer zijn '1'
|
||
|
|
#define RF_PULSE_1 1500 // PWM: Tijdsduur van de puls bij verzenden van een '1' in uSec. (3x RF_PULSE_0)
|
||
|
|
#define RF_SPACE 500 // PWM: Tijdsduur van de space tussen de bitspuls bij verzenden van een '1' in uSec.
|
||
|
|
#define TransmitRepeat 2
|
||
|
|
|
||
|
|
void SendData(int payload1, int payload2)
|
||
|
|
{
|
||
|
|
struct
|
||
|
|
{
|
||
|
|
byte Checksum; // Checksum over following bytes
|
||
|
|
byte Channel: 3; // 3 bits channel
|
||
|
|
byte Type: 5; // 5 bits type
|
||
|
|
byte Voltage; // Vcc like 45 = 4.5V, bit 8 is batt low
|
||
|
|
int Payload1;
|
||
|
|
int Payload2;
|
||
|
|
} DataBlock;
|
||
|
|
byte Size = sizeof(DataBlock);
|
||
|
|
|
||
|
|
DataBlock.Type = SENSOR_TYPE;
|
||
|
|
DataBlock.Channel = CHANNEL;
|
||
|
|
DataBlock.Voltage = Voltage;
|
||
|
|
DataBlock.Payload1 = payload1;
|
||
|
|
DataBlock.Payload2 = payload2;
|
||
|
|
byte c = 0, *B = (byte*)&DataBlock; // bereken checksum: crc-8 uit bovenstaande bytes in de struct
|
||
|
|
for (byte x = 1; x < Size; x++)
|
||
|
|
c +=*(B+x);
|
||
|
|
DataBlock.Checksum = c;
|
||
|
|
|
||
|
|
pinMode(RF_TransmitDataPin, OUTPUT);
|
||
|
|
digitalWrite(RF_TransmitDataPin, LOW); // 0
|
||
|
|
for (byte y = 0; y < TransmitRepeat; y++) // herhaal verzenden RF code
|
||
|
|
{
|
||
|
|
digitalWrite(RF_TransmitDataPin, HIGH); // 1
|
||
|
|
delayMicroseconds(RF_PULSE_1 * 4);
|
||
|
|
digitalWrite(RF_TransmitDataPin, LOW); // 0
|
||
|
|
delayMicroseconds(RF_SPACE * 2);
|
||
|
|
for (byte x = 0; x < Size; x++)
|
||
|
|
{
|
||
|
|
for (byte Bit = 0; Bit <= 7; Bit++)
|
||
|
|
{
|
||
|
|
digitalWrite(RF_TransmitDataPin, HIGH); // 1
|
||
|
|
if ((*(B + x) >> Bit) & 1)
|
||
|
|
delayMicroseconds(RF_PULSE_1);
|
||
|
|
else
|
||
|
|
delayMicroseconds(RF_PULSE_0);
|
||
|
|
digitalWrite(RF_TransmitDataPin, LOW); // 0
|
||
|
|
delayMicroseconds(RF_SPACE);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
delayMicroseconds(RF_PULSE_1 * 10);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//*****************************************************************************
|
||
|
|
// Measure battery voltage using internal bandgap voltage
|
||
|
|
//*****************************************************************************
|
||
|
|
byte ReadVcc()
|
||
|
|
{
|
||
|
|
int result;
|
||
|
|
|
||
|
|
bitSet(ADCSRA, ADEN); // switch Analog to Digital converter ON
|
||
|
|
ADMUX = 0x0C; // use VCC and internal bandgap (ATTiny85)
|
||
|
|
delayMicroseconds(250); // delay substantially improves accuracy
|
||
|
|
bitSet(ADCSRA, ADSC); // start conversion
|
||
|
|
while (bit_is_set(ADCSRA, ADSC)); // wait until ADSC is clear
|
||
|
|
bitClear(ADCSRA, ADEN); // Switch Analog to Digital converter OFF
|
||
|
|
result = ADCW;
|
||
|
|
return result ? VREF_35 / result : 0; // 35 = 3.5V
|
||
|
|
}
|
||
|
|
|
||
|
|
//*****************************************************************************
|
||
|
|
// DHT11 or DHT22 Temperature and humidity sensor support
|
||
|
|
//*****************************************************************************
|
||
|
|
byte GetPayload(int &temperature, int &humidity)
|
||
|
|
{
|
||
|
|
return GetDHT(temperature, humidity);
|
||
|
|
}
|
||
|
|
|
||
|
|
//*****************************************************************************
|
||
|
|
// DHT11 or DHT22 Temperature and humidity
|
||
|
|
// http://forums.adafruit.com/viewtopic.php?f=25&t=43933
|
||
|
|
// https://github.com/markruys/arduino-DHT
|
||
|
|
//*****************************************************************************
|
||
|
|
byte GetDHT(int &temperature, int &humidity)
|
||
|
|
{
|
||
|
|
unsigned long startTime = millis();
|
||
|
|
word rawHumidity;
|
||
|
|
word rawTemperature;
|
||
|
|
word data;
|
||
|
|
|
||
|
|
digitalWrite(DHT_PIN, LOW); // Send start signal
|
||
|
|
pinMode(DHT_PIN, OUTPUT);
|
||
|
|
#ifdef DHT22
|
||
|
|
delayMicroseconds(800);
|
||
|
|
#else
|
||
|
|
delay(18);
|
||
|
|
#endif
|
||
|
|
pinMode(DHT_PIN, INPUT);
|
||
|
|
digitalWrite(DHT_PIN, HIGH); // Switch bus to receive data
|
||
|
|
// We're going to read 83 edges:
|
||
|
|
// - First a FALLING, RISING, and FALLING edge for the start bit
|
||
|
|
// - Then 40 bits: RISING and then a FALLING edge per bit
|
||
|
|
// To keep our code simple, we accept any HIGH or LOW reading if it's max 85 usecs long
|
||
|
|
for (int8_t i = -3 ; i < 2 * 40; i++)
|
||
|
|
{
|
||
|
|
byte age;
|
||
|
|
|
||
|
|
startTime = micros();
|
||
|
|
do
|
||
|
|
{
|
||
|
|
age = (unsigned long)(micros() - startTime);
|
||
|
|
if (age > 90) return 1;
|
||
|
|
}
|
||
|
|
while (digitalRead(DHT_PIN) == (i & 1) ? HIGH : LOW);
|
||
|
|
if (i >= 0 && (i & 1))
|
||
|
|
{
|
||
|
|
data <<= 1; // Now we are being fed our 40 bits
|
||
|
|
if (age > 30) data |= 1; // A zero max 30 usecs, a one at least 68 usecs. We got a one
|
||
|
|
}
|
||
|
|
switch (i)
|
||
|
|
{
|
||
|
|
case 31:
|
||
|
|
rawHumidity = data;
|
||
|
|
break;
|
||
|
|
case 63:
|
||
|
|
rawTemperature = data;
|
||
|
|
data = 0;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Verify checksum
|
||
|
|
if ((byte)(((byte)rawHumidity) + (rawHumidity >> 8) + ((byte)rawTemperature) + (rawTemperature >> 8)) != data)
|
||
|
|
return 2;
|
||
|
|
#ifdef DHT22
|
||
|
|
int t = (rawTemperature & 0x7fff) * 10;
|
||
|
|
temperature = rawTemperature & 0x8000 ? - t : t;
|
||
|
|
// humidity = (rawHumidity / 10) * 100; // round to whole
|
||
|
|
humidity = rawHumidity * 10;
|
||
|
|
#else
|
||
|
|
humidity = (rawHumidity >> 8) * 100;
|
||
|
|
temperature = (rawTemperature >> 8) * 100;
|
||
|
|
#endif
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|