185 lines
6.3 KiB
C++
185 lines
6.3 KiB
C++
/*
|
|
RCSwitch - Arduino libary for remote control outlet switches
|
|
Copyright (c) 2011 Suat Özgür. All right reserved.
|
|
|
|
Contributors:
|
|
- Andre Koehler / info(at)tomate-online(dot)de
|
|
- Gordeev Andrey Vladimirovich / gordeev(at)openpyro(dot)com
|
|
- Skineffect / http://forum.ardumote.com/viewtopic.php?f=2&t=46
|
|
- Dominik Fischer / dom_fischer(at)web(dot)de
|
|
- Frank Oltmanns / <first name>.<last name>(at)gmail(dot)com
|
|
- Max Horn / max(at)quendi(dot)de
|
|
- Robert ter Vehn / <first name>.<last name>(at)gmail(dot)com
|
|
|
|
Project home: https://github.com/sui77/rc-switch/
|
|
|
|
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 _RCSwitch_h
|
|
#define _RCSwitch_h
|
|
|
|
#if defined(ARDUINO) && ARDUINO >= 100
|
|
#include "Arduino.h"
|
|
#elif defined(ENERGIA) // LaunchPad, FraunchPad and StellarPad specific
|
|
#include "Energia.h"
|
|
#elif defined(RPI) // Raspberry Pi
|
|
#define RaspberryPi
|
|
|
|
// Include libraries for RPi:
|
|
#include <string.h> /* memcpy */
|
|
#include <stdlib.h> /* abs */
|
|
#include <wiringPi.h>
|
|
#elif defined(SPARK)
|
|
#include "application.h"
|
|
#else
|
|
#include "WProgram.h"
|
|
#endif
|
|
|
|
#include <stdint.h>
|
|
|
|
|
|
// At least for the ATTiny X4/X5, receiving has to be disabled due to
|
|
// missing libm depencies (udivmodhi4)
|
|
#if defined( __AVR_ATtinyX5__ ) or defined ( __AVR_ATtinyX4__ )
|
|
#define RCSwitchDisableReceiving
|
|
#endif
|
|
|
|
// Number of maximum high/Low changes per packet.
|
|
// We can handle up to (unsigned long) => 32 bit * 2 H/L changes per bit + 2 for sync
|
|
#define RCSWITCH_MAX_CHANGES 67
|
|
|
|
class RCSwitch {
|
|
|
|
public:
|
|
RCSwitch();
|
|
|
|
void switchOn(int nGroupNumber, int nSwitchNumber);
|
|
void switchOff(int nGroupNumber, int nSwitchNumber);
|
|
void switchOn(const char* sGroup, int nSwitchNumber);
|
|
void switchOff(const char* sGroup, int nSwitchNumber);
|
|
void switchOn(char sFamily, int nGroup, int nDevice);
|
|
void switchOff(char sFamily, int nGroup, int nDevice);
|
|
void switchOn(const char* sGroup, const char* sDevice);
|
|
void switchOff(const char* sGroup, const char* sDevice);
|
|
void switchOn(char sGroup, int nDevice);
|
|
void switchOff(char sGroup, int nDevice);
|
|
|
|
void sendTriState(const char* sCodeWord);
|
|
void send(unsigned long code, unsigned int length);
|
|
void send(const char* sCodeWord);
|
|
|
|
#if not defined( RCSwitchDisableReceiving )
|
|
void enableReceive(int interrupt);
|
|
void enableReceive();
|
|
void disableReceive();
|
|
bool available();
|
|
void resetAvailable();
|
|
|
|
unsigned long getReceivedValue();
|
|
unsigned int getReceivedBitlength();
|
|
unsigned int getReceivedDelay();
|
|
unsigned int getReceivedProtocol();
|
|
unsigned int* getReceivedRawdata();
|
|
#endif
|
|
|
|
void enableTransmit(int nTransmitterPin);
|
|
void disableTransmit();
|
|
void setPulseLength(int nPulseLength);
|
|
void setRepeatTransmit(int nRepeatTransmit);
|
|
#if not defined( RCSwitchDisableReceiving )
|
|
void setReceiveTolerance(int nPercent);
|
|
#endif
|
|
|
|
/**
|
|
* Description of a single pule, which consists of a high signal
|
|
* whose duration is "high" times the base pulse length, followed
|
|
* by a low signal lasting "low" times the base pulse length.
|
|
* Thus, the pulse overall lasts (high+low)*pulseLength
|
|
*/
|
|
struct HighLow {
|
|
uint8_t high;
|
|
uint8_t low;
|
|
};
|
|
|
|
/**
|
|
* A "protocol" describes how zero and one bits are encoded into high/low
|
|
* pulses.
|
|
*/
|
|
struct Protocol {
|
|
/** base pulse length in microseconds, e.g. 350 */
|
|
uint16_t pulseLength;
|
|
|
|
HighLow syncFactor;
|
|
HighLow zero;
|
|
HighLow one;
|
|
|
|
/**
|
|
* If true, interchange high and low logic levels in all transmissions.
|
|
*
|
|
* By default, RCSwitch assumes that any signals it sends or receives
|
|
* can be broken down into pulses which start with a high signal level,
|
|
* followed by a a low signal level. This is e.g. the case for the
|
|
* popular PT 2260 encoder chip, and thus many switches out there.
|
|
*
|
|
* But some devices do it the other way around, and start with a low
|
|
* signal level, followed by a high signal level, e.g. the HT6P20B. To
|
|
* accommodate this, one can set invertedSignal to true, which causes
|
|
* RCSwitch to change how it interprets any HighLow struct FOO: It will
|
|
* then assume transmissions start with a low signal lasting
|
|
* FOO.high*pulseLength microseconds, followed by a high signal lasting
|
|
* FOO.low*pulseLength microseconds.
|
|
*/
|
|
bool invertedSignal;
|
|
};
|
|
|
|
void setProtocol(Protocol protocol);
|
|
void setProtocol(int nProtocol);
|
|
void setProtocol(int nProtocol, int nPulseLength);
|
|
|
|
private:
|
|
char* getCodeWordA(const char* sGroup, const char* sDevice, bool bStatus);
|
|
char* getCodeWordB(int nGroupNumber, int nSwitchNumber, bool bStatus);
|
|
char* getCodeWordC(char sFamily, int nGroup, int nDevice, bool bStatus);
|
|
char* getCodeWordD(char group, int nDevice, bool bStatus);
|
|
void transmit(HighLow pulses);
|
|
|
|
#if not defined( RCSwitchDisableReceiving )
|
|
static void handleInterrupt();
|
|
static bool receiveProtocol(const int p, unsigned int changeCount);
|
|
int nReceiverInterrupt;
|
|
#endif
|
|
int nTransmitterPin;
|
|
int nRepeatTransmit;
|
|
|
|
Protocol protocol;
|
|
|
|
#if not defined( RCSwitchDisableReceiving )
|
|
static int nReceiveTolerance;
|
|
volatile static unsigned long nReceivedValue;
|
|
volatile static unsigned int nReceivedBitlength;
|
|
volatile static unsigned int nReceivedDelay;
|
|
volatile static unsigned int nReceivedProtocol;
|
|
const static unsigned int nSeparationLimit;
|
|
/*
|
|
* timings[0] contains sync timing, followed by a number of bits
|
|
*/
|
|
static unsigned int timings[RCSWITCH_MAX_CHANGES];
|
|
#endif
|
|
|
|
|
|
};
|
|
|
|
#endif
|