youen/OneWireArduinoSlave
4
6
Fork 4
Code Issues 6 Pull Requests Releases Wiki Activity

Merge 82e8372512 into f65847e3a1

Browse Source
This commit is contained in:
destroyedlolo 2018-03-31 17:30:04 +00:00 committed by GitHub
commit 0be2aebf0d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 1339 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
examples/DS18B20_DHT22/DS18B20_DHT22.ino Normal file
View File

@ -0,0 +1,140 @@
/* Emulates a DS18B20 using a DHT22
*
* Provided by Destroyedlolo. (http://destroyedlolo.info)
*
* 23/03/2018 - First version
*/
#include <Arduino.h>
#include <LowLevel.h>
#include <OneWireSlave.h>
Pin oneWireData(2); // Where the 1-wire bus is connected to
const byte owROM[7] = { 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 };
enum OW_Cmd {
START_CONVERSION = 0x44,
WRITE_SCRATCHPAD = 0x4e,
READ_POWERSUPPLY = 0xb4,
READ_SCRATCHPAD = 0xBE
};
volatile byte scratchpad[9];
/*
* DHT22 related
*/
#include <SimpleDHT.h> // https://github.com/winlinvip/SimpleDHT
SimpleDHT22 DHT;
#define pinDHT 3
/*
* Let's go
*/
#define DEBUG // Comment out to be silence
enum DeviceState {
WAIT4RESET,
WAIT4COMMAND,
CONVERTING,
TEMPERATUREREADY
};
volatile DeviceState state = DeviceState::WAIT4RESET;
volatile unsigned long conversionStartTime = 0;
void owRcv( OneWireSlave::ReceiveEvent evt, byte cmd ){
switch( evt ){
case OneWireSlave::RE_Reset:
state = DeviceState::WAIT4COMMAND;
#ifdef DEBUG
Serial.println(F("Reset"));
#endif
break;
case OneWireSlave::RE_Error:
state = DeviceState::WAIT4RESET;
#ifdef DEBUG
Serial.println(F("Error"));
#endif
break;
case OneWireSlave::RE_Byte:
if( state == DeviceState::WAIT4COMMAND ) switch( cmd ){
case OW_Cmd::START_CONVERSION:
// Do a new request only if enough time passed
if( !conversionStartTime || millis() < conversionStartTime || millis() > conversionStartTime + 2000 ){
state = DeviceState::CONVERTING;
OWSlave.beginWriteBit(0, true); // send zeros as long as the conversion is not finished
}
#ifdef DEBUG
else
Serial.println(F("Ignored StartConv"));
#endif
break;
case OW_Cmd::READ_SCRATCHPAD:
state = DeviceState::WAIT4RESET;
OWSlave.beginWrite((const byte*)scratchpad, 9, 0);
break;
case OW_Cmd::WRITE_SCRATCHPAD:
case OW_Cmd::READ_POWERSUPPLY:
state = DeviceState::WAIT4RESET; // Ignore parameters
break;
default:
state = DeviceState::WAIT4RESET;
#ifdef DEBUG
Serial.print(F("Unknown command :"));
Serial.println( cmd, HEX );
#endif
}
}
}
void setTemperature( float temp ){ // Write given temperature to the scratchpad
int16_t raw = (int16_t)(temp * 16.0f + 0.5);
// We don't care about race condition as well as only one command
// can be processed at a time otherwise we are failing in error/collision
// condition.
scratchpad[0] = (byte)raw;
scratchpad[1] = (byte)(raw >> 8);
scratchpad[8] = OWSlave.crc8((const byte*)scratchpad, 8);
}
void setup(){
Serial.begin(115200); // debugging
for(int i = 2; i<8; i++)
scratchpad[i] = 0;
setTemperature( 85 );
OWSlave.setReceiveCallback(&owRcv);
OWSlave.begin(owROM, oneWireData.getPinNumber());
}
void loop(){
delay(10);
if(state == DeviceState::CONVERTING){ // start conversion
float temperature = 0;
float humidite = 0;
int err;
conversionStartTime = millis();
if((err = DHT.read2(pinDHT, &temperature, &humidite, NULL)) != SimpleDHTErrSuccess){
#ifdef DEBUG
Serial.print("\nError while reading, err=");
Serial.println(err);
#endif
temperature = 85;
} else {
#ifdef DEBUG
Serial.print("Temperature :");
Serial.println(temperature);
#endif
}
setTemperature( temperature );
state = DeviceState::TEMPERATUREREADY;
OWSlave.beginWriteBit(1, true);
}
}

12
examples/orgDS18B20/README.md Normal file
View File

@ -0,0 +1,12 @@
This is the **DS18B20** fake emulator provided with the original version of OneWireArduinoSlave.
To make it working, connect :
- a GND pin of your Uno to your 1-wire network ground.
- the pin "2" of your Unto to the data line of your 1-wire network. You may use "3" as well but need to change the code.
You will see 28.000000000002 probe that always return 42 as temperature :
$ cat 28.000000000002/temperature
42
Notez-bien : conversion timing is emulated as well.

117
examples/orgDS18B20/orgDS18B20.ino Normal file
View File

@ -0,0 +1,117 @@
#include <Arduino.h>
#include <LowLevel.h>
#include <OneWireSlave.h>
// This is the pin that will be used for one-wire data (depending on your arduino model, you are limited to a few choices, because some pins don't have complete interrupt support)
// On Arduino Uno, you can use pin 2 or pin 3
Pin oneWireData(2);
Pin led(13);
// This is the ROM the arduino will respond to, make sure it doesn't conflict with another device
const byte owROM[7] = { 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 };
// This sample emulates a DS18B20 device (temperature sensor), so we start by defining the available commands
const byte DS18B20_START_CONVERSION = 0x44;
const byte DS18B20_READ_SCRATCHPAD = 0xBE;
const byte DS18B20_WRITE_SCRATCHPAD = 0x4E;
// TODO:
// - handle configuration (resolution, alarms)
enum DeviceState
{
DS_WaitingReset,
DS_WaitingCommand,
DS_ConvertingTemperature,
DS_TemperatureConverted,
};
volatile DeviceState state = DS_WaitingReset;
// scratchpad, with the CRC byte at the end
volatile byte scratchpad[9];
volatile unsigned long conversionStartTime = 0;
// This function will be called each time the OneWire library has an event to notify (reset, error, byte received)
void owReceive(OneWireSlave::ReceiveEvent evt, byte data);
void setup()
{
led.outputMode();
led.writeLow();
// Setup the OneWire library
OWSlave.setReceiveCallback(&owReceive);
OWSlave.begin(owROM, oneWireData.getPinNumber());
}
void loop()
{
delay(10);
cli();//disable interrupts
// Be sure to not block interrupts for too long, OneWire timing is very tight for some operations. 1 or 2 microseconds (yes, microseconds, not milliseconds) can be too much depending on your master controller, but then it's equally unlikely that you block exactly at the moment where it matters.
// This can be mitigated by using error checking and retry in your high-level communication protocol. A good thing to do anyway.
DeviceState localState = state;
unsigned long localConversionStartTime = conversionStartTime;
sei();//enable interrupts
if (localState == DS_ConvertingTemperature && millis() > localConversionStartTime + 750)
{
float temperature = 42.0f; // here you could plug any logic you want to return the emulated temperature
int16_t raw = (int16_t)(temperature * 16.0f + 0.5f);
byte data[9];
data[0] = (byte)raw;
data[1] = (byte)(raw >> 8);
for (int i = 2; i < 8; ++i)
data[i] = 0;
data[8] = OWSlave.crc8(data, 8);
cli();
memcpy((void*)scratchpad, data, 9);
state = DS_TemperatureConverted;
OWSlave.beginWriteBit(1, true); // now that conversion is finished, start sending ones until reset
sei();
}
}
void owReceive(OneWireSlave::ReceiveEvent evt, byte data)
{
switch (evt)
{
case OneWireSlave::RE_Byte:
switch (state)
{
case DS_WaitingCommand:
switch (data)
{
case DS18B20_START_CONVERSION:
state = DS_ConvertingTemperature;
conversionStartTime = millis();
OWSlave.beginWriteBit(0, true); // send zeros as long as the conversion is not finished
break;
case DS18B20_READ_SCRATCHPAD:
state = DS_WaitingReset;
OWSlave.beginWrite((const byte*)scratchpad, 9, 0);
break;
case DS18B20_WRITE_SCRATCHPAD:
break;
}
break;
}
break;
case OneWireSlave::RE_Reset:
state = DS_WaitingCommand;
break;
case OneWireSlave::RE_Error:
state = DS_WaitingReset;
break;
}
}

5
extras/Interesting URL Normal file
View File

@ -0,0 +1,5 @@
http://palsbo.com/pi/owfsslave.html
An interesting project covering both Arduino and OWFS aspect
http://www.datastat.com/sysadminjournal/maximcrc.cgi
Address CRC calculator

34
keywords.txt Normal file
View File

@ -0,0 +1,34 @@
#######################################
# Syntax Coloring Map For OneWireSlave
#######################################
#######################################
# Datatypes (KEYWORD1)
#######################################
ReceiveEvent KEYWORD1
OneWireSlave KEYWORD1
Pin KEYWORD1
OWSlave KEYWORD1
#######################################
# Methods and Functions (KEYWORD2)
#######################################
begin KEYWORD2
end KEYWORD2
setReceiveCallback KEYWORD2
setReceiveBitCallback KEYWORD2
write KEYWORD2
writeBit KEYWORD2
stopWrite KEYWORD2
alarmed KEYWORD2
crc8 KEYWORD2
#######################################
# Constants (LITERAL1)
#######################################
RE_Reset LITERAL1
RE_Byte LITERAL1
RE_Error LITERAL1

9
library.properties Normal file
View File

@ -0,0 +1,9 @@
name=OneWireArduinoSlave
version=0.2
author=neuoy
maintainer=https://github.com/destroyedlolo/OneWireArduinoSlave
sentence=Library to create slave 1-wire devices
paragraph= +paragraph=This library allows you to emulate existing 1-wire devices with an Arduino, or to create your own protocol. All low-level details are handled by the library, such as reset detection, ROM matching, byte sending and receiving.
category=Device Control
url=https://github.com/destroyedlolo/OneWireArduinoSlave
architectures=*

160
src/LowLevel.h Normal file
View File

@ -0,0 +1,160 @@
#ifndef _LowLevel_h
#define _LowLevel_h
#include <inttypes.h>
#ifdef VS_INTELLISENSE
#define __attribute__()
#endif
#if ARDUINO >= 100
#include "Arduino.h" // for delayMicroseconds, digitalPinToBitMask, etc
#else
#include "WProgram.h" // for delayMicroseconds
#include "pins_arduino.h" // for digitalPinToBitMask, etc
#endif
#if defined(__AVR__)
#define PIN_TO_BASEREG(pin) (portInputRegister(digitalPinToPort(pin)))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define IO_REG_TYPE uint8_t
#define IO_REG_ASM asm("r30")
#define DIRECT_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0)
#define DIRECT_MODE_INPUT(base, mask) ((*((base)+1)) &= ~(mask))
#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+1)) |= (mask))
#define DIRECT_WRITE_LOW(base, mask) ((*((base)+2)) &= ~(mask))
#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+2)) |= (mask))
#if defined (__AVR_ATtiny85__)
#define CLEARINTERRUPT GIFR |= (1 << INTF0)
#include "UserTimer.h" //ATtiny-support based on TinyCore1 Arduino-core for ATtiny at http://github.com/Coding-Badly/TinyCore1.git
__attribute__((always_inline)) static inline void UserTimer_Init( void )
{
UserTimer_SetToPowerup();
UserTimer_SetWaveformGenerationMode(UserTimer_(CTC_OCR));
}
__attribute__((always_inline)) static inline void UserTimer_Run(short skipTicks)
{
UserTimer_SetCount(0);
UserTimer_SetOutputCompareMatchAndClear(skipTicks);
UserTimer_ClockSelect(UserTimer_(Prescale_Value_64));
}
#define UserTimer_Stop() UserTimer_ClockSelect(UserTimer_(Stopped))
#elif defined (__AVR_ATmega328P__)
#define CLEARINTERRUPT EIFR |= (1 << INTF0)
#define USERTIMER_COMPA_vect TIMER1_COMPA_vect
__attribute__((always_inline)) static inline void UserTimer_Init( void )
{
TCCR1A = 0;
TCCR1B = 0;
// enable timer compare interrupt
TIMSK1 |= (1 << OCIE1A);
}
__attribute__((always_inline)) static inline void UserTimer_Run(short skipTicks)
{
TCNT1 = 0;
OCR1A = skipTicks;
// turn on CTC mode with 64 prescaler
TCCR1B = (1 << WGM12) | (1 << CS11) | (1 << CS10);
}
#define UserTimer_Stop() TCCR1B = 0
#endif
#elif defined(__MK20DX128__) || defined(__MK20DX256__)
#define PIN_TO_BASEREG(pin) (portOutputRegister(pin))
#define PIN_TO_BITMASK(pin) (1)
#define IO_REG_TYPE uint8_t
#define IO_REG_ASM
#define DIRECT_READ(base, mask) (*((base)+512))
#define DIRECT_MODE_INPUT(base, mask) (*((base)+640) = 0)
#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+640) = 1)
#define DIRECT_WRITE_LOW(base, mask) (*((base)+256) = 1)
#define DIRECT_WRITE_HIGH(base, mask) (*((base)+128) = 1)
#elif defined(__SAM3X8E__)
// Arduino 1.5.1 may have a bug in delayMicroseconds() on Arduino Due.
// http://arduino.cc/forum/index.php/topic,141030.msg1076268.html#msg1076268
// If you have trouble with OneWire on Arduino Due, please check the
// status of delayMicroseconds() before reporting a bug in OneWire!
#define PIN_TO_BASEREG(pin) (&(digitalPinToPort(pin)->PIO_PER))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define IO_REG_TYPE uint32_t
#define IO_REG_ASM
#define DIRECT_READ(base, mask) (((*((base)+15)) & (mask)) ? 1 : 0)
#define DIRECT_MODE_INPUT(base, mask) ((*((base)+5)) = (mask))
#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+4)) = (mask))
#define DIRECT_WRITE_LOW(base, mask) ((*((base)+13)) = (mask))
#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+12)) = (mask))
#ifndef PROGMEM
#define PROGMEM
#endif
#ifndef pgm_read_byte
#define pgm_read_byte(addr) (*(const uint8_t *)(addr))
#endif
#elif defined(__PIC32MX__)
#define PIN_TO_BASEREG(pin) (portModeRegister(digitalPinToPort(pin)))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define IO_REG_TYPE uint32_t
#define IO_REG_ASM
#define DIRECT_READ(base, mask) (((*(base+4)) & (mask)) ? 1 : 0) //PORTX + 0x10
#define DIRECT_MODE_INPUT(base, mask) ((*(base+2)) = (mask)) //TRISXSET + 0x08
#define DIRECT_MODE_OUTPUT(base, mask) ((*(base+1)) = (mask)) //TRISXCLR + 0x04
#define DIRECT_WRITE_LOW(base, mask) ((*(base+8+1)) = (mask)) //LATXCLR + 0x24
#define DIRECT_WRITE_HIGH(base, mask) ((*(base+8+2)) = (mask)) //LATXSET + 0x28
#else
#error "Please define I/O register types here"
#endif
class Pin
{
private:
IO_REG_TYPE mask_;
volatile IO_REG_TYPE *reg_;
byte interruptNumber_;
byte pinNumber_;
public:
Pin()
: mask_(0)
, reg_(0)
, interruptNumber_((byte)-1)
, pinNumber_(255)
{ }
Pin(uint8_t pin)
{
pinNumber_ = pin;
mask_ = PIN_TO_BITMASK(pin);
reg_ = PIN_TO_BASEREG(pin);
switch (pin)
{
case 2: interruptNumber_ = 0; break;
case 3: interruptNumber_ = 1; break;
default: interruptNumber_ = (byte)-1;
}
}
inline byte getPinNumber() { return pinNumber_; }
inline void inputMode() { DIRECT_MODE_INPUT(reg_, mask_); }
inline void outputMode() { DIRECT_MODE_OUTPUT(reg_, mask_); }
inline bool read() { return DIRECT_READ(reg_, mask_) == 1; }
inline void writeLow() { DIRECT_WRITE_LOW(reg_, mask_); }
inline void writeHigh() { DIRECT_WRITE_HIGH(reg_, mask_); }
inline void write(bool value) { if (value) writeHigh(); else writeLow(); }
inline void attachInterrupt(void (*handler)(), int mode)
{
CLEARINTERRUPT; // clear any pending interrupt (we want to call the handler only for interrupts happening after it is attached)
::attachInterrupt(interruptNumber_, handler, mode);
}
inline void detachInterrupt() { ::detachInterrupt(interruptNumber_); }
};
#endif

715
src/OneWireSlave.cpp Normal file
View File

@ -0,0 +1,715 @@
#include "OneWireSlave.h"
// uncomment this line to enable sending messages along with errors (but takes more program memory)
//#define ERROR_MESSAGES
#ifdef ERROR_MESSAGES
#define ERROR(msg) error_(msg)
#else
#define ERROR(msg) error_(0)
#endif
namespace
{
const unsigned long ResetMinDuration = 480;
const unsigned long ResetMaxDuration = 900;
const unsigned long PresenceWaitDuration = 15;
const unsigned long PresenceDuration = 200;
const unsigned long ReadBitSamplingTime = 25;
const unsigned long SendBitDuration = 35;
const byte ReceiveCommand = (byte)-1;
void(*timerEvent)() = 0;
}
OneWireSlave OWSlave;
byte OneWireSlave::rom_[8];
byte OneWireSlave::scratchpad_[8];
Pin OneWireSlave::pin_;
unsigned long OneWireSlave::resetStart_;
unsigned long OneWireSlave::lastReset_;
void(*OneWireSlave::receiveBitCallback_)(bool bit, bool error);
void(*OneWireSlave::bitSentCallback_)(bool error);
void(*OneWireSlave::clientReceiveCallback_)(ReceiveEvent evt, byte data);
void(*OneWireSlave::clientReceiveBitCallback_)(bool bit);
byte OneWireSlave::receivingByte_;
byte OneWireSlave::searchRomBytePos_;
byte OneWireSlave::searchRomBitPos_;
bool OneWireSlave::searchRomInverse_;
bool OneWireSlave::resumeCommandFlag_;
bool OneWireSlave::alarmedFlag_;
const byte* OneWireSlave::sendBuffer_;
byte* OneWireSlave::recvBuffer_;
short OneWireSlave::bufferLength_;
byte OneWireSlave::bufferBitPos_;
short OneWireSlave::bufferPos_;
void(*OneWireSlave::receiveBytesCallback_)(bool error);
void(*OneWireSlave::sendBytesCallback_)(bool error);
volatile bool OneWireSlave::waitingSynchronousWriteToComplete_;
volatile bool OneWireSlave::synchronousWriteError_;
bool OneWireSlave::sendingClientBytes_;
bool OneWireSlave::singleBit_;
bool OneWireSlave::singleBitRepeat_;
void(*OneWireSlave::singleBitSentCallback_)(bool error);
void(*OneWireSlave::logCallback_)(const char* message);
ISR(USERTIMER_COMPA_vect) // timer1 interrupt
{
UserTimer_Stop(); // disable clock
void(*event)() = timerEvent;
timerEvent = 0;
event();
}
void OneWireSlave::begin(const byte* rom, byte pinNumber)
{
pin_ = Pin(pinNumber);
resetStart_ = (unsigned long)-1;
lastReset_ = 0;
memcpy(rom_, rom, 7);
rom_[7] = crc8(rom_, 7);
resumeCommandFlag_ = false;
alarmedFlag_ = false;
clientReceiveBitCallback_ = 0;
sendingClientBytes_ = false;
// log("Enabling 1-wire library")
cli(); // disable interrupts
pin_.inputMode();
pin_.writeLow(); // make sure the internal pull-up resistor is disabled
// prepare hardware timer
UserTimer_Init();
// start 1-wire activity
beginWaitReset_();
sei(); // enable interrupts
}
void OneWireSlave::end()
{
// log("Disabling 1-wire library");
cli();
disableTimer_();
pin_.detachInterrupt();
releaseBus_();
sei();
}
bool OneWireSlave::write(const byte* bytes, short numBytes)
{
// TODO: put the arduino to sleep between interrupts to save power?
waitingSynchronousWriteToComplete_ = true;
beginWrite(bytes, numBytes, &OneWireSlave::onSynchronousWriteComplete_);
while (waitingSynchronousWriteToComplete_)
delay(1);
return !synchronousWriteError_;
}
void OneWireSlave::onSynchronousWriteComplete_(bool error)
{
synchronousWriteError_ = error;
waitingSynchronousWriteToComplete_ = false;
}
void OneWireSlave::beginWrite(const byte* bytes, short numBytes, void(*complete)(bool error))
{
cli();
endWrite_(true);
sendingClientBytes_ = true;
beginWriteBytes_(bytes, numBytes, complete == 0 ? noOpCallback_ : complete);
sei();
}
void OneWireSlave::endWrite_(bool error, bool resetInterrupts)
{
if(resetInterrupts)
beginWaitReset_();
if (sendingClientBytes_)
{
sendingClientBytes_ = false;
if (sendBytesCallback_ != 0)
{
void(*callback)(bool error) = sendBytesCallback_;
sendBytesCallback_ = noOpCallback_;
callback(error);
}
}
else if (singleBitSentCallback_ != 0)
{
void(*callback)(bool) = singleBitSentCallback_;
singleBitSentCallback_ = 0;
callback(error);
}
}
bool OneWireSlave::writeBit(bool value)
{
// TODO: put the arduino to sleep between interrupts to save power?
waitingSynchronousWriteToComplete_ = true;
beginWriteBit(value, false, &OneWireSlave::onSynchronousWriteComplete_);
while (waitingSynchronousWriteToComplete_)
delay(1);
return !synchronousWriteError_;
}
void OneWireSlave::beginWriteBit(bool value, bool repeat, void(*bitSent)(bool))
{
cli();
endWrite_(true);
singleBit_ = value;
singleBitRepeat_ = repeat;
singleBitSentCallback_ = bitSent;
beginSendBit_(value, &OneWireSlave::onSingleBitSent_);
sei();
}
void OneWireSlave::onSingleBitSent_(bool error)
{
if (!error && singleBitRepeat_)
{
beginSendBit_(singleBit_, &OneWireSlave::onSingleBitSent_);
}
else
{
beginReceiveBytes_(scratchpad_, 1, &OneWireSlave::notifyClientByteReceived_);
}
if (singleBitSentCallback_ != 0)
{
void(*callback)(bool) = singleBitSentCallback_;
singleBitSentCallback_ = 0;
callback(error);
}
}
void OneWireSlave::stopWrite()
{
beginWrite(0, 0, 0);
}
void OneWireSlave::alarmed(bool value)
{
alarmedFlag_ = value;
}
byte OneWireSlave::crc8(const byte* data, short numBytes)
{
byte crc = 0;
while (numBytes--) {
byte inbyte = *data++;
for (byte i = 8; i; i--) {
byte mix = (crc ^ inbyte) & 0x01;
crc >>= 1;
if (mix) crc ^= 0x8C;
inbyte >>= 1;
}
}
return crc;
}
void OneWireSlave::setTimerEvent_(short delayMicroSeconds, void(*handler)())
{
delayMicroSeconds -= 10; // remove overhead (tuned on Arduino Uno)
short skipTicks = (delayMicroSeconds - 3) / 4; // round the micro seconds delay to a number of ticks to skip (4us per tick, so 4us must skip 0 tick, 8us must skip 1 tick, etc.)
if (skipTicks < 1) skipTicks = 1;
timerEvent = handler;
UserTimer_Run(skipTicks);
}
void OneWireSlave::disableTimer_()
{
UserTimer_Stop();
}
void OneWireSlave::onEnterInterrupt_()
{
}
void OneWireSlave::onLeaveInterrupt_()
{
}
void OneWireSlave::error_(const char* message)
{
if (logCallback_ != 0)
logCallback_(message);
endWrite_(true);
if (clientReceiveCallback_ != 0)
clientReceiveCallback_(RE_Error, 0);
}
void OneWireSlave::pullLow_()
{
pin_.outputMode();
pin_.writeLow();
}
void OneWireSlave::releaseBus_()
{
pin_.inputMode();
}
void OneWireSlave::beginResetDetection_()
{
setTimerEvent_(ResetMinDuration - 50, &OneWireSlave::resetCheck_);
resetStart_ = micros() - 50;
}
void OneWireSlave::beginResetDetectionSendZero_()
{
setTimerEvent_(ResetMinDuration - SendBitDuration - 50, &OneWireSlave::resetCheck_);
resetStart_ = micros() - SendBitDuration - 50;
}
void OneWireSlave::cancelResetDetection_()
{
disableTimer_();
resetStart_ = (unsigned long)-1;
}
void OneWireSlave::resetCheck_()
{
onEnterInterrupt_();
if (!pin_.read())
{
pin_.attachInterrupt(&OneWireSlave::waitReset_, CHANGE);
// log("Reset detected during another operation");
}
onLeaveInterrupt_();
}
void OneWireSlave::beginReceiveBit_(void(*completeCallback)(bool bit, bool error))
{
receiveBitCallback_ = completeCallback;
pin_.attachInterrupt(&OneWireSlave::receive_, FALLING);
}
void OneWireSlave::receive_()
{
onEnterInterrupt_();
pin_.detachInterrupt();
setTimerEvent_(ReadBitSamplingTime, &OneWireSlave::readBit_);
onLeaveInterrupt_();
}
void OneWireSlave::readBit_()
{
onEnterInterrupt_();
bool bit = pin_.read();
if (bit)
cancelResetDetection_();
else
beginResetDetection_();
receiveBitCallback_(bit, false);
//dbgOutput.writeLow();
//dbgOutput.writeHigh();
onLeaveInterrupt_();
}
void OneWireSlave::beginSendBit_(bool bit, void(*completeCallback)(bool error))
{
bitSentCallback_ = completeCallback;
if (bit)
{
pin_.attachInterrupt(&OneWireSlave::sendBitOne_, FALLING);
}
else
{
pin_.attachInterrupt(&OneWireSlave::sendBitZero_, FALLING);
}
}
void OneWireSlave::sendBitOne_()
{
onEnterInterrupt_();
beginResetDetection_();
bitSentCallback_(false);
onLeaveInterrupt_();
}
void OneWireSlave::sendBitZero_()
{
pullLow_(); // this must be executed first because the timing is very tight with some master devices
onEnterInterrupt_();
pin_.detachInterrupt();
setTimerEvent_(SendBitDuration, &OneWireSlave::endSendBitZero_);
onLeaveInterrupt_();
}
void OneWireSlave::endSendBitZero_()
{
onEnterInterrupt_();
releaseBus_();
beginResetDetectionSendZero_();
bitSentCallback_(false);
onLeaveInterrupt_();
}
void OneWireSlave::beginWaitReset_()
{
disableTimer_();
pin_.inputMode();
pin_.attachInterrupt(&OneWireSlave::waitReset_, CHANGE);
resetStart_ = (unsigned int)-1;
}
void OneWireSlave::waitReset_()
{
onEnterInterrupt_();
bool state = pin_.read();
unsigned long now = micros();
if (state)
{
if (resetStart_ == (unsigned int)-1)
{
onLeaveInterrupt_();
return;
}
unsigned long resetDuration = now - resetStart_;
resetStart_ = (unsigned int)-1;
if (resetDuration >= ResetMinDuration)
{
if (resetDuration > ResetMaxDuration)
{
ERROR("Reset too long");
onLeaveInterrupt_();
return;
}
lastReset_ = now;
pin_.detachInterrupt();
unsigned long alreadyElapsedTime = micros() - now;
setTimerEvent_(alreadyElapsedTime < PresenceWaitDuration ? PresenceWaitDuration - alreadyElapsedTime : 0, &OneWireSlave::beginPresence_);
endWrite_(true, false);
if (clientReceiveCallback_ != 0)
clientReceiveCallback_(RE_Reset, 0);
}
}
else
{
resetStart_ = now;
}
onLeaveInterrupt_();
}
void OneWireSlave::beginPresence_()
{
pullLow_();
setTimerEvent_(PresenceDuration, &OneWireSlave::endPresence_);
}
void OneWireSlave::endPresence_()
{
releaseBus_();
beginWaitCommand_();
}
void OneWireSlave::beginWaitCommand_()
{
bufferPos_ = ReceiveCommand;
beginReceive_();
}
void OneWireSlave::beginReceive_()
{
receivingByte_ = 0;
bufferBitPos_ = 0;
beginReceiveBit_(&OneWireSlave::onBitReceived_);
}
void OneWireSlave::onBitReceived_(bool bit, bool error)
{
if (error)
{
ERROR("Invalid bit");
if (bufferPos_ >= 0)
receiveBytesCallback_(true);
return;
}
receivingByte_ |= ((bit ? 1 : 0) << bufferBitPos_);
++bufferBitPos_;
if (clientReceiveBitCallback_ != 0 && bufferPos_ != ReceiveCommand)
clientReceiveBitCallback_(bit);
if (bufferBitPos_ == 8)
{
// log("received byte", (long)receivingByte_);
if (bufferPos_ == ReceiveCommand)
{
bufferPos_ = 0;
switch (receivingByte_)
{
case 0xF0: // SEARCH ROM
resumeCommandFlag_ = false;
beginSearchRom_();
return;
case 0xEC: // CONDITIONAL SEARCH ROM
resumeCommandFlag_ = false;
if (alarmedFlag_)
{
beginSearchRom_();
}
else
{
beginWaitReset_();
}
return;
case 0x33: // READ ROM
resumeCommandFlag_ = false;
beginWriteBytes_(rom_, 8, &OneWireSlave::noOpCallback_);
return;
case 0x55: // MATCH ROM
resumeCommandFlag_ = false;
beginReceiveBytes_(scratchpad_, 8, &OneWireSlave::matchRomBytesReceived_);
return;
case 0xCC: // SKIP ROM
resumeCommandFlag_ = false;
beginReceiveBytes_(scratchpad_, 1, &OneWireSlave::notifyClientByteReceived_);
return;
case 0xA5: // RESUME
if (resumeCommandFlag_)
{
beginReceiveBytes_(scratchpad_, 1, &OneWireSlave::notifyClientByteReceived_);
}
else
{
beginWaitReset_();
}
return;
default:
ERROR("Unknown command");
return;
}
}
else
{
recvBuffer_[bufferPos_++] = receivingByte_;
receivingByte_ = 0;
bufferBitPos_ = 0;
if (bufferPos_ == bufferLength_)
{
beginWaitReset_();
receiveBytesCallback_(false);
return;
}
}
}
beginReceiveBit_(&OneWireSlave::onBitReceived_);
}
void OneWireSlave::beginSearchRom_()
{
searchRomBytePos_ = 0;
searchRomBitPos_ = 0;
searchRomInverse_ = false;
beginSearchRomSendBit_();
}
void OneWireSlave::beginSearchRomSendBit_()
{
byte currentByte = rom_[searchRomBytePos_];
bool currentBit = bitRead(currentByte, searchRomBitPos_);
bool bitToSend = searchRomInverse_ ? !currentBit : currentBit;
beginSendBit_(bitToSend, &OneWireSlave::continueSearchRom_);
}
void OneWireSlave::continueSearchRom_(bool error)
{
if (error)
{
ERROR("Failed to send bit");
return;
}
searchRomInverse_ = !searchRomInverse_;
if (searchRomInverse_)
{
beginSearchRomSendBit_();
}
else
{
beginReceiveBit_(&OneWireSlave::searchRomOnBitReceived_);
}
}
void OneWireSlave::searchRomOnBitReceived_(bool bit, bool error)
{
if (error)
{
ERROR("Bit read error during ROM search");
return;
}
byte currentByte = rom_[searchRomBytePos_];
bool currentBit = bitRead(currentByte, searchRomBitPos_);
if (bit == currentBit)
{
++searchRomBitPos_;
if (searchRomBitPos_ == 8)
{
searchRomBitPos_ = 0;
++searchRomBytePos_;
}
if (searchRomBytePos_ == 8)
{
// log("ROM sent entirely");
beginWaitReset_();
}
else
{
beginSearchRomSendBit_();
}
}
else
{
// log("Leaving ROM search");
beginWaitReset_();
}
}
void OneWireSlave::beginWriteBytes_(const byte* data, short numBytes, void(*complete)(bool error))
{
sendBuffer_ = data;
bufferLength_ = numBytes;
bufferPos_ = 0;
bufferBitPos_ = 0;
sendBytesCallback_ = complete;
if (sendBuffer_ != 0 && bufferLength_ > 0)
{
bool bit = bitRead(sendBuffer_[0], 0);
beginSendBit_(bit, &OneWireSlave::bitSent_);
}
else
{
endWrite_(true);
beginReceiveBytes_(scratchpad_, 1, &OneWireSlave::notifyClientByteReceived_);
}
}
void OneWireSlave::bitSent_(bool error)
{
if (error)
{
ERROR("error sending a bit");
sendBytesCallback_(true);
return;
}
++bufferBitPos_;
if (bufferBitPos_ == 8)
{
bufferBitPos_ = 0;
++bufferPos_;
}
if (bufferPos_ == bufferLength_)
{
endWrite_(false);
sendBytesCallback_(false);
return;
}
bool bit = bitRead(sendBuffer_[bufferPos_], bufferBitPos_);
beginSendBit_(bit, &OneWireSlave::bitSent_);
}
void OneWireSlave::beginReceiveBytes_(byte* buffer, short numBytes, void(*complete)(bool error))
{
recvBuffer_ = buffer;
bufferLength_ = numBytes;
bufferPos_ = 0;
receiveBytesCallback_ = complete;
beginReceive_();
}
void OneWireSlave::noOpCallback_(bool error)
{
if (error)
ERROR("error during an internal 1-wire operation");
}
void OneWireSlave::matchRomBytesReceived_(bool error)
{
if (error)
{
resumeCommandFlag_ = false;
ERROR("error receiving match rom bytes");
return;
}
if (memcmp(rom_, scratchpad_, 8) == 0)
{
// log("ROM matched");
resumeCommandFlag_ = true;
beginReceiveBytes_(scratchpad_, 1, &OneWireSlave::notifyClientByteReceived_);
}
else
{
// log("ROM not matched");
resumeCommandFlag_ = false;
beginWaitReset_();
}
}
void OneWireSlave::notifyClientByteReceived_(bool error)
{
if (error)
{
if (clientReceiveCallback_ != 0)
clientReceiveCallback_(RE_Error, 0);
ERROR("error receiving custom bytes");
return;
}
beginReceiveBytes_(scratchpad_, 1, &OneWireSlave::notifyClientByteReceived_);
if (clientReceiveCallback_ != 0)
clientReceiveCallback_(RE_Byte, scratchpad_[0]);
}

147
src/OneWireSlave.h Normal file
View File

@ -0,0 +1,147 @@
#ifndef _OneWireSlave_h_
#define _OneWireSlave_h_
#include "Arduino.h"
#include "LowLevel.h"
class OneWireSlave
{
public:
enum ReceiveEvent
{
RE_Reset, //!< The master has sent a general reset
RE_Byte, //!< The master just sent a byte of data
RE_Error //!< A communication error happened (such as a timeout) ; the library will stop all 1-wire activities until the next reset
};
//! Starts listening for the 1-wire master, on the specified pin, as a virtual slave device identified by the specified ROM (7 bytes, starting from the family code, CRC will be computed internally). Reset, Presence, SearchRom and MatchRom are handled automatically. The library will use the external interrupt on the specified pin (note that this is usually not possible with all pins, depending on the board), as well as one hardware timer. Blocking interrupts (either by disabling them explicitely with sei/cli, or by spending time in another interrupt) can lead to malfunction of the library, due to tight timing for some 1-wire operations.
void begin(const byte* rom, byte pinNumber);
//! Stops all 1-wire activities, which frees hardware resources for other purposes.
void end();
//! Sets (or replaces) a function to be called when something is received. The callback is executed from interrupts and should be as short as possible. Failure to return quickly can prevent the library from correctly reading the next byte.
void setReceiveCallback(void(*callback)(ReceiveEvent evt, byte data)) { clientReceiveCallback_ = callback; }
//! Sets (or replaces) a function to be called when a bit is received. The byte reception callback is called after that if the received bit was the last of a byte. The callback is executed from interrupts and should be as short as possible. Failure to return quickly can prevent the library from correctly reading the next bit.
void setReceiveBitCallback(void(*callback)(bool bit)) { clientReceiveBitCallback_ = callback; }
//! Sets (or replaces) a function to be called when the library has a message to log, if the functionality is enabled in OneWireSlave.cpp. This is for debugging purposes.
void setLogCallback(void(*callback)(const char* message)) { logCallback_ = callback; }
//! Writes the specified bytes synchronously. This function blocks until the write operation has finished. Do not call from an interrupt handler! Returns true in case of success, false if an error occurs.
bool write(const byte* bytes, short numBytes);
//! Starts sending the specified bytes. They will be sent in the background, and the buffer must remain valid and unchanged until the write operation has finished or is cancelled. The optional callback is used to notify when the bytes are sent, or if an error occured. Callbacks are executed from interrupts and should be as short as possible. If bytes is null or numBytes is 0, nothing is sent, which is equivalent to calling stopWrite. In any case, calling the write function will cancel the previous write operation if it didn't complete yet.
void beginWrite(const byte* bytes, short numBytes, void(*complete)(bool error));
//! Writes a single bit synchronously. This function blocks until the bit is sent. Do not call from an interrupt handler! Returns true in case of success, false if an error occurs.
bool writeBit(bool value);
//! Sets a bit that will be sent next time the master asks for one. Optionnaly, the repeat parameter can be set to true to continue sending the same bit each time. In both cases, the send operation can be canceled by calling stopWrite.
void beginWriteBit(bool value, bool repeat = false, void(*bitSent)(bool error) = 0);
//! Cancels any pending write operation, started by writeBit or write. If this function is called before the master asked for a bit, then nothing is sent to the master.
void stopWrite();
void alarmed(bool value);
static byte crc8(const byte* data, short numBytes);
private:
static void setTimerEvent_(short delayMicroSeconds, void(*handler)());
static void disableTimer_();
static void onEnterInterrupt_();
static void onLeaveInterrupt_();
static void error_(const char* message);
static void pullLow_();
static void releaseBus_();
static void beginReceiveBit_(void(*completeCallback)(bool bit, bool error));
static void beginSendBit_(bool bit, void(*completeCallback)(bool error));
static void beginResetDetection_();
static void beginResetDetectionSendZero_();
static void cancelResetDetection_();
static void beginWaitReset_();
static void beginWaitCommand_();
static void beginReceive_();
static void onBitReceived_(bool bit, bool error);
static void beginSearchRom_();
static void beginSearchRomSendBit_();
static void continueSearchRom_(bool error);
static void searchRomOnBitReceived_(bool bit, bool error);
static void beginWriteBytes_(const byte* data, short numBytes, void(*complete)(bool error));
static void beginReceiveBytes_(byte* buffer, short numBytes, void(*complete)(bool error));
static void endWrite_(bool error, bool resetInterrupts = true);
static void onSynchronousWriteComplete_(bool error);
static void noOpCallback_(bool error);
static void matchRomBytesReceived_(bool error);
static void notifyClientByteReceived_(bool error);
static void bitSent_(bool error);
// interrupt handlers
static void waitReset_();
static void beginPresence_();
static void endPresence_();
static void receive_();
static void readBit_();
static void sendBitOne_();
static void sendBitZero_();
static void endSendBitZero_();
static void resetCheck_();
private:
static byte rom_[8];
static byte scratchpad_[8];
static Pin pin_;
static unsigned long resetStart_;
static unsigned long lastReset_;
static void(*receiveBitCallback_)(bool bit, bool error);
static void(*bitSentCallback_)(bool error);
static byte receivingByte_;
static byte searchRomBytePos_;
static byte searchRomBitPos_;
static bool searchRomInverse_;
static bool resumeCommandFlag_;
static bool alarmedFlag_;
static const byte* sendBuffer_;
static byte* recvBuffer_;
static short bufferLength_;
static short bufferPos_;
static byte bufferBitPos_;
static void(*receiveBytesCallback_)(bool error);
static void(*sendBytesCallback_)(bool error);
static volatile bool waitingSynchronousWriteToComplete_;
static volatile bool synchronousWriteError_;
static bool sendingClientBytes_;
static bool singleBit_;
static bool singleBitRepeat_;
static void (*singleBitSentCallback_)(bool error);
static void onSingleBitSent_(bool error);
static void(*clientReceiveCallback_)(ReceiveEvent evt, byte data);
static void(*clientReceiveBitCallback_)(bool bit);
static void(*logCallback_)(const char* message);
};
extern OneWireSlave OWSlave;
#endif