Created
February 15, 2014 09:42
-
-
Save Ryotsuke/9016839 to your computer and use it in GitHub Desktop.
Complex LCD+Servo+Dallas+SparkFunctions+GaranAudio text
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#define ARDUINO_H | |
#ifndef LiquidCrystal_I2C_h | |
#define LiquidCrystal_I2C_h | |
#define LCD_CLEARDISPLAY 0x01 | |
#define LCD_RETURNHOME 0x02 | |
#define LCD_ENTRYMODESET 0x04 | |
#define LCD_DISPLAYCONTROL 0x08 | |
#define LCD_CURSORSHIFT 0x10 | |
#define LCD_FUNCTIONSET 0x20 | |
#define LCD_SETCGRAMADDR 0x40 | |
#define LCD_SETDDRAMADDR 0x80 | |
#define LCD_ENTRYRIGHT 0x00 | |
#define LCD_ENTRYLEFT 0x02 | |
#define LCD_ENTRYSHIFTINCREMENT 0x01 | |
#define LCD_ENTRYSHIFTDECREMENT 0x00 | |
// flags for display on/off control | |
#define LCD_DISPLAYON 0x04 | |
#define LCD_DISPLAYOFF 0x00 | |
#define LCD_CURSORON 0x02 | |
#define LCD_CURSOROFF 0x00 | |
#define LCD_BLINKON 0x01 | |
#define LCD_BLINKOFF 0x00 | |
// flags for display/cursor shift | |
#define LCD_DISPLAYMOVE 0x08 | |
#define LCD_CURSORMOVE 0x00 | |
#define LCD_MOVERIGHT 0x04 | |
#define LCD_MOVELEFT 0x00 | |
// flags for function set | |
#define LCD_8BITMODE 0x10 | |
#define LCD_4BITMODE 0x00 | |
#define LCD_2LINE 0x08 | |
#define LCD_1LINE 0x00 | |
#define LCD_5x10DOTS 0x04 | |
#define LCD_5x8DOTS 0x00 | |
// flags for backlight control | |
#define LCD_BACKLIGHT 0x08 | |
#define LCD_NOBACKLIGHT 0x00 | |
//#define En B00000100 // Enable bit | |
//#define Rw B00000010 // Read/Write bit | |
//#define Rs B00000001 // Register select bit | |
class LiquidCrystal_I2C : public Print { | |
public: | |
LiquidCrystal_I2C(uint8_t lcd_Addr,uint8_t lcd_cols,uint8_t lcd_rows); | |
void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS ); | |
void clear(); | |
void home(); | |
void noDisplay(); | |
void display(); | |
void noBlink(); | |
void blink(); | |
void noCursor(); | |
void cursor(); | |
void scrollDisplayLeft(); | |
void scrollDisplayRight(); | |
void printLeft(); | |
void printRight(); | |
void leftToRight(); | |
void rightToLeft(); | |
void shiftIncrement(); | |
void shiftDecrement(); | |
void noBacklight(); | |
void backlight(); | |
void autoscroll(); | |
void noAutoscroll(); | |
void createChar(uint8_t, uint8_t[]); | |
void setCursor(uint8_t, uint8_t); | |
virtual size_t write(uint8_t); //changed to size_t | |
void command(uint8_t); | |
void init(); | |
////compatibility API function aliases | |
void blink_on(); // alias for blink() | |
void blink_off(); // alias for noBlink() | |
void cursor_on(); // alias for cursor() | |
void cursor_off(); // alias for noCursor() | |
void setBacklight(uint8_t new_val); // alias for backlight() and nobacklight() | |
void load_custom_character(uint8_t char_num, uint8_t *rows); // alias for createChar() | |
void printstr(const char[]); | |
////Unsupported API functions (not implemented in this library) | |
uint8_t status(); | |
void setContrast(uint8_t new_val); | |
uint8_t keypad(); | |
void setDelay(int,int); | |
void on(); | |
void off(); | |
uint8_t init_bargraph(uint8_t graphtype); | |
void draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len, uint8_t pixel_col_end); | |
void draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len, uint8_t pixel_col_end); | |
private: | |
void init_priv(); | |
void send(uint8_t, uint8_t); | |
void write4bits(uint8_t); | |
void expanderWrite(uint8_t); | |
void pulseEnable(uint8_t); | |
uint8_t _Addr; | |
uint8_t _displayfunction; | |
uint8_t _displaycontrol; | |
uint8_t _displaymode; | |
uint8_t _numlines; | |
uint8_t _cols; | |
uint8_t _rows; | |
uint8_t _backlightval; | |
}; | |
#endif | |
// LiquidCrystal_I2C V2.0 | |
// When the display powers up, it is configured as follows: | |
// | |
// 1. Display clear | |
// 2. Function set: | |
// DL = 1; 8-bit interface data | |
// N = 0; 1-line display | |
// F = 0; 5x8 dot character font | |
// 3. Display on/off control: | |
// D = 0; Display off | |
// C = 0; Cursor off | |
// B = 0; Blinking off | |
// 4. Entry mode set: | |
// I/D = 1; Increment by 1 | |
// S = 0; No shift | |
// | |
// Note, however, that resetting the Arduino doesn't reset the LCD, so we | |
// can't assume that its in that state when a sketch starts (and the | |
// LiquidCrystal constructor is called). | |
LiquidCrystal_I2C::LiquidCrystal_I2C(uint8_t lcd_Addr,uint8_t lcd_cols,uint8_t lcd_rows) | |
{ | |
_Addr = lcd_Addr; | |
_cols = lcd_cols; | |
_rows = lcd_rows; | |
_backlightval = LCD_NOBACKLIGHT; | |
} | |
void LiquidCrystal_I2C::init(){ | |
init_priv(); | |
} | |
void LiquidCrystal_I2C::init_priv() | |
{ | |
Wire.begin(); | |
_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS; | |
begin(_cols, _rows); | |
} | |
void LiquidCrystal_I2C::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) { | |
if (lines > 1) { | |
_displayfunction |= LCD_2LINE; | |
} | |
_numlines = lines; | |
// for some 1 line displays you can select a 10 pixel high font | |
if ((dotsize != 0) && (lines == 1)) { | |
_displayfunction |= LCD_5x10DOTS; | |
} | |
// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION! | |
// according to datasheet, we need at least 40ms after power rises above 2.7V | |
// before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50 | |
delay(50); | |
// Now we pull both RS and R/W low to begin commands | |
expanderWrite(_backlightval); // reset expanderand turn backlight off (Bit 8 =1) | |
delay(1000); | |
//put the LCD into 4 bit mode | |
// this is according to the hitachi HD44780 datasheet | |
// figure 24, pg 46 | |
// we start in 8bit mode, try to set 4 bit mode | |
write4bits(0x03 << 4); | |
delayMicroseconds(4500); // wait min 4.1ms | |
// second try | |
write4bits(0x03 << 4); | |
delayMicroseconds(4500); // wait min 4.1ms | |
// third go! | |
write4bits(0x03 << 4); | |
delayMicroseconds(150); | |
// finally, set to 4-bit interface | |
write4bits(0x02 << 4); | |
// set # lines, font size, etc. | |
command(LCD_FUNCTIONSET | _displayfunction); | |
// turn the display on with no cursor or blinking default | |
_displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF; | |
display(); | |
// clear it off | |
clear(); | |
// Initialize to default text direction (for roman languages) | |
_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT; | |
// set the entry mode | |
command(LCD_ENTRYMODESET | _displaymode); | |
home(); | |
} | |
/********** high level commands, for the user! */ | |
void LiquidCrystal_I2C::clear(){ | |
command(LCD_CLEARDISPLAY);// clear display, set cursor position to zero | |
delayMicroseconds(2000); // this command takes a long time! | |
} | |
void LiquidCrystal_I2C::home(){ | |
command(LCD_RETURNHOME); // set cursor position to zero | |
delayMicroseconds(2000); // this command takes a long time! | |
} | |
void LiquidCrystal_I2C::setCursor(uint8_t col, uint8_t row){ | |
int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 }; | |
if ( row > _numlines ) { | |
row = _numlines-1; // we count rows starting w/0 | |
} | |
command(LCD_SETDDRAMADDR | (col + row_offsets[row])); | |
} | |
// Turn the display on/off (quickly) | |
void LiquidCrystal_I2C::noDisplay() { | |
_displaycontrol &= ~LCD_DISPLAYON; | |
command(LCD_DISPLAYCONTROL | _displaycontrol); | |
} | |
void LiquidCrystal_I2C::display() { | |
_displaycontrol |= LCD_DISPLAYON; | |
command(LCD_DISPLAYCONTROL | _displaycontrol); | |
} | |
// Turns the underline cursor on/off | |
void LiquidCrystal_I2C::noCursor() { | |
_displaycontrol &= ~LCD_CURSORON; | |
command(LCD_DISPLAYCONTROL | _displaycontrol); | |
} | |
void LiquidCrystal_I2C::cursor() { | |
_displaycontrol |= LCD_CURSORON; | |
command(LCD_DISPLAYCONTROL | _displaycontrol); | |
} | |
// Turn on and off the blinking cursor | |
void LiquidCrystal_I2C::noBlink() { | |
_displaycontrol &= ~LCD_BLINKON; | |
command(LCD_DISPLAYCONTROL | _displaycontrol); | |
} | |
void LiquidCrystal_I2C::blink() { | |
_displaycontrol |= LCD_BLINKON; | |
command(LCD_DISPLAYCONTROL | _displaycontrol); | |
} | |
// These commands scroll the display without changing the RAM | |
void LiquidCrystal_I2C::scrollDisplayLeft(void) { | |
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT); | |
} | |
void LiquidCrystal_I2C::scrollDisplayRight(void) { | |
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT); | |
} | |
// This is for text that flows Left to Right | |
void LiquidCrystal_I2C::leftToRight(void) { | |
_displaymode |= LCD_ENTRYLEFT; | |
command(LCD_ENTRYMODESET | _displaymode); | |
} | |
// This is for text that flows Right to Left | |
void LiquidCrystal_I2C::rightToLeft(void) { | |
_displaymode &= ~LCD_ENTRYLEFT; | |
command(LCD_ENTRYMODESET | _displaymode); | |
} | |
// This will 'right justify' text from the cursor | |
void LiquidCrystal_I2C::autoscroll(void) { | |
_displaymode |= LCD_ENTRYSHIFTINCREMENT; | |
command(LCD_ENTRYMODESET | _displaymode); | |
} | |
// This will 'left justify' text from the cursor | |
void LiquidCrystal_I2C::noAutoscroll(void) { | |
_displaymode &= ~LCD_ENTRYSHIFTINCREMENT; | |
command(LCD_ENTRYMODESET | _displaymode); | |
} | |
// Allows us to fill the first 8 CGRAM locations | |
// with custom characters | |
void LiquidCrystal_I2C::createChar(uint8_t location, uint8_t charmap[]) { | |
location &= 0x7; // we only have 8 locations 0-7 | |
command(LCD_SETCGRAMADDR | (location << 3)); | |
for (int i=0; i<8; i++) { | |
write(charmap[i]); | |
} | |
} | |
// Turn the (optional) backlight off/on | |
void LiquidCrystal_I2C::noBacklight(void) { | |
_backlightval=LCD_NOBACKLIGHT; | |
expanderWrite(0); | |
} | |
void LiquidCrystal_I2C::backlight(void) { | |
_backlightval=LCD_BACKLIGHT; | |
expanderWrite(0); | |
} | |
/*********** mid level commands, for sending data/cmds */ | |
inline void LiquidCrystal_I2C::command(uint8_t value) { | |
send(value, 0); | |
} | |
inline size_t LiquidCrystal_I2C::write(uint8_t value) { | |
send(value, 1); | |
return 0; | |
} | |
/************ low level data pushing commands **********/ | |
// write either command or data | |
void LiquidCrystal_I2C::send(uint8_t value, uint8_t mode) { | |
uint8_t highnib=value&0xf0; | |
uint8_t lownib=(value<<4)&0xf0; | |
write4bits((highnib)|mode); | |
write4bits((lownib)|mode); | |
} | |
void LiquidCrystal_I2C::write4bits(uint8_t value) { | |
expanderWrite(value); | |
pulseEnable(value); | |
} | |
void LiquidCrystal_I2C::expanderWrite(uint8_t _data){ | |
Wire.beginTransmission(_Addr); | |
Wire.write((int)(_data) | _backlightval); | |
Wire.endTransmission(); | |
} | |
void LiquidCrystal_I2C::pulseEnable(uint8_t _data){ | |
expanderWrite(_data | (1<<2)); // En high | |
delayMicroseconds(1); // enable pulse must be >450ns | |
expanderWrite(_data & ~(1<<2)); // En low | |
delayMicroseconds(50); // commands need > 37us to settle | |
} | |
// Alias functions | |
void LiquidCrystal_I2C::cursor_on(){ | |
cursor(); | |
} | |
void LiquidCrystal_I2C::cursor_off(){ | |
noCursor(); | |
} | |
void LiquidCrystal_I2C::blink_on(){ | |
blink(); | |
} | |
void LiquidCrystal_I2C::blink_off(){ | |
noBlink(); | |
} | |
void LiquidCrystal_I2C::load_custom_character(uint8_t char_num, uint8_t *rows){ | |
createChar(char_num, rows); | |
} | |
void LiquidCrystal_I2C::setBacklight(uint8_t new_val){ | |
if(new_val){ | |
backlight(); // turn backlight on | |
}else{ | |
noBacklight(); // turn backlight off | |
} | |
} | |
void LiquidCrystal_I2C::printstr(const char c[]){ | |
//This function is not identical to the function used for "real" I2C displays | |
//it's here so the user sketch doesn't have to be changed | |
print(c); | |
} | |
// unsupported API functions | |
void LiquidCrystal_I2C::off(){} | |
void LiquidCrystal_I2C::on(){} | |
void LiquidCrystal_I2C::setDelay (int cmdDelay,int charDelay) {} | |
uint8_t LiquidCrystal_I2C::status(){return 0;} | |
uint8_t LiquidCrystal_I2C::keypad (){return 0;} | |
uint8_t LiquidCrystal_I2C::init_bargraph(uint8_t graphtype){return 0;} | |
void LiquidCrystal_I2C::draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len, uint8_t pixel_col_end){} | |
void LiquidCrystal_I2C::draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len, uint8_t pixel_row_end){} | |
void LiquidCrystal_I2C::setContrast(uint8_t new_val){} | |
LiquidCrystal_I2C *lcd; | |
/** GARAN */ | |
// example or fixed commands | |
const uint8_t SINGLE_PLAY[] = {0x04, 0x01, 0x00, 0x00, 0x01}; // NH NL | |
const uint8_t SEQUENCE_PLAY[] = {0x04, 0x02, 0x00, 0x00, 0x02}; // NH NL | |
const uint8_t SINGLE_LOOP_PLAY[] = {0x04, 0x03, 0x00, 0x00, 0x02}; // NH NL | |
const uint8_t SINGLE_PLAY_NAME[] = {0x07, 0x04, 0x00, 0x31, 0x2E, 0x4D, 0x50, 0x33}; // Name must <= 12 | |
const uint8_t SEQUENCE_PLAY_NAME[] = {0x07, 0x05, 0x00, 0x31, 0x2E, 0x4D, 0x50, 0x33}; // Name must <= 12 | |
const uint8_t SINGLE_LOOP_NAME[] = {0x07, 0x06, 0x00, 0x31, 0x2E, 0x4D, 0x50, 0x33}; // Name must <= 12 | |
const uint8_t STOP[] = {0x02, 0x07, 0x00}; | |
const uint8_t PAUSE_PLAY[] = {0x02, 0x08, 0x00}; | |
const uint8_t NEXT[] = {0x02, 0x09, 0x00}; | |
const uint8_t PREV[] = {0x02, 0x0A, 0x00}; | |
const uint8_t VOLUME_UP[] = {0x02, 0x0B, 0x00}; | |
const uint8_t VOLUME_DOWN[] = {0x02, 0x0C, 0x00}; | |
const uint8_t SET_VOLUME[] = {0x03, 0x0D, 0x00, 0x05}; // Value | |
const uint8_t EQ_CHANGE[] = {0x02, 0x0E, 0x00}; | |
const uint8_t SET_EQ[] = {0x03, 0x0F, 0x00, 0x01}; // Value | |
const uint8_t STANDBY_MODE[] = {0x02, 0x10, 0x00}; | |
const uint8_t SET_TIME[] = {0x09, 0x11, 0x00, 0x07, 0xDD, 0x06, 0x0D, 0x0B, 0x11, 0x01}; | |
const uint8_t GET_PLAYING_NAME[] = {0x02, 0x21, 0x01}; | |
const uint8_t GET_MUSIC_NUMBERS[] = {0x02, 0x22, 0x01}; | |
const uint8_t GET_PLAYING_ORDER[] = {0x02, 0x23, 0x01}; | |
const uint8_t GET_TIME[] = {0x02, 0x25, 0x01}; | |
const uint8_t FEEDBACK_AT_END[] = {0x03, 0xA0, 0x01, 0x01}; | |
const uint8_t NO_FEEDBACK_AT_END[] = {0x03, 0xA0, 0x01, 0x00}; | |
const uint8_t GET_VERSION[] = {0x02, 0x80, 0x01}; | |
#define _serial Serial1 | |
/* | |
Garan.h - Library for controlling Garan Audio Module | |
Released into the public domain. | |
*/ | |
#ifndef Garan_h | |
#define Garan_h | |
class Garan | |
{ | |
private: | |
unsigned char _commandBuff[13]; | |
void sendCommand(uint8_t command[]); | |
inline void buildHead(uint8_t len, uint8_t cmd); | |
public: | |
Garan(); | |
bool available(); | |
void singlePlay(uint16_t number); | |
void sequencePlay(uint16_t number); | |
void singleLoopPlay(uint16_t number); | |
void singlePlayName(char *name); | |
void sequencePlayName(char *name); | |
void singleLoopName(char *name); | |
void stop(); | |
void pausePlay(); | |
void next(); | |
void prev(); | |
void volumeUp(); | |
void volumeDown(); | |
void setVolume(uint8_t volume); | |
void eqChange(); | |
void setEQ(uint8_t eq); | |
void standbyMode(); | |
void setTime(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second); | |
void getPlayingName(); | |
void getMusicNumbers(); | |
void getPlayingOrder(); | |
void getTime(); | |
void feedbackAtEnd(); | |
void NoFeedbackAtEnd(); | |
void getVersion(); | |
}; | |
#endif | |
Garan::Garan() | |
{ | |
_serial.begin(9600); | |
_commandBuff[2] = 1; | |
} | |
bool Garan::available() { | |
return _serial.available(); | |
} | |
void Garan::sendCommand(uint8_t command[]) { | |
uint8_t checksum = 0; | |
_serial.write(0x24); | |
for (uint16_t i = 0; i <= command[0]; i++) { | |
_serial.write(command[i]); | |
checksum ^= command[i]; | |
} | |
_serial.write(checksum); | |
} | |
inline void Garan::buildHead(uint8_t len, uint8_t cmd) { | |
_commandBuff[0] = len; | |
_commandBuff[1] = cmd; | |
} | |
void Garan::singlePlay(uint16_t number) { | |
buildHead(0x04, 0x01); | |
_commandBuff[3] = (uint8_t)(number >> 8); | |
_commandBuff[4] = (uint8_t)number; | |
sendCommand(_commandBuff); | |
} | |
void Garan::sequencePlay(uint16_t number) { | |
buildHead(0x04, 0x02); | |
_commandBuff[3] = (uint8_t)(number >> 8); | |
_commandBuff[4] = (uint8_t)number; | |
sendCommand(_commandBuff); | |
} | |
void Garan::singleLoopPlay(uint16_t number) { | |
buildHead(0x04, 0x02); | |
_commandBuff[3] = (uint8_t)(number >> 8); | |
_commandBuff[4] = (uint8_t)number; | |
sendCommand(_commandBuff); | |
} | |
void Garan::singlePlayName(char *name) { | |
strcpy((char *)&_commandBuff[3], name); | |
buildHead(strlen(name) + 2, 4); | |
sendCommand(_commandBuff); | |
_serial.begin(9600); | |
} | |
void Garan::sequencePlayName(char *name) { | |
strcpy((char *)&_commandBuff[3], name); | |
buildHead(strlen(name) + 2, 5); | |
sendCommand(_commandBuff); | |
_serial.begin(9600); | |
} | |
void Garan::singleLoopName(char *name) { | |
strcpy((char *)&_commandBuff[3], name); | |
buildHead(strlen(name) + 2, 6); | |
sendCommand(_commandBuff); | |
_serial.begin(9600); | |
} | |
void Garan::stop() { | |
sendCommand((uint8_t *)STOP); | |
} | |
void Garan::pausePlay() { | |
sendCommand((uint8_t *)PAUSE_PLAY); | |
} | |
void Garan::next() { | |
sendCommand((uint8_t *)NEXT); | |
} | |
void Garan::prev() { | |
sendCommand((uint8_t *)PREV); | |
} | |
void Garan::volumeUp() { | |
sendCommand((uint8_t *)VOLUME_UP); | |
} | |
void Garan::volumeDown() { | |
sendCommand((uint8_t *)VOLUME_DOWN); | |
} | |
void Garan::setVolume(uint8_t volume) { | |
buildHead(0x03, 0x0D); | |
_commandBuff[3] = volume; | |
sendCommand(_commandBuff); | |
} | |
void Garan::eqChange() { | |
sendCommand((uint8_t *)EQ_CHANGE); | |
} | |
void Garan::setEQ(uint8_t eq) { | |
buildHead(0x03, 0x0F); | |
_commandBuff[3] = eq; | |
sendCommand(_commandBuff); | |
} | |
void Garan::standbyMode() { | |
sendCommand((uint8_t *)STANDBY_MODE); | |
} | |
void Garan::setTime(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second) { | |
buildHead(0x09, 0x11); | |
_commandBuff[3] = (uint8_t)(year >> 8); | |
_commandBuff[4] = (uint8_t)year; | |
_commandBuff[5] = month; | |
_commandBuff[6] = day; | |
_commandBuff[7] = hour; | |
_commandBuff[8] = minute; | |
_commandBuff[9] = second; | |
sendCommand(_commandBuff); | |
} | |
void Garan::getPlayingName() { | |
sendCommand((uint8_t *)GET_PLAYING_NAME); | |
} | |
void Garan::getMusicNumbers() { | |
sendCommand((uint8_t *)GET_MUSIC_NUMBERS); | |
} | |
void Garan::getPlayingOrder() { | |
sendCommand((uint8_t *)GET_PLAYING_ORDER); | |
} | |
void Garan::getTime() { | |
sendCommand((uint8_t *)GET_TIME); | |
} | |
void Garan::feedbackAtEnd() { | |
sendCommand((uint8_t *)FEEDBACK_AT_END); | |
} | |
void Garan::NoFeedbackAtEnd() { | |
sendCommand((uint8_t *)NO_FEEDBACK_AT_END); | |
} | |
void Garan::getVersion() { | |
sendCommand((uint8_t *)GET_VERSION); | |
} | |
#ifndef OneWire_h | |
#define OneWire_h | |
#include <inttypes.h> | |
#ifdef STM32F10X_MD | |
#include "spark_wiring.h" | |
#include "spark_wiring_interrupts.h" | |
#endif | |
// you can exclude onewire_search by defining that to 0 | |
#ifndef ONEWIRE_SEARCH | |
#define ONEWIRE_SEARCH 1 | |
#endif | |
// You can exclude CRC checks altogether by defining this to 0 | |
#ifndef ONEWIRE_CRC | |
#define ONEWIRE_CRC 1 | |
#endif | |
// You can allow 16-bit CRC checks by defining this to 1 | |
// (Note that ONEWIRE_CRC must also be 1.) | |
#ifndef ONEWIRE_CRC16 | |
#define ONEWIRE_CRC16 1 | |
#endif | |
#define FALSE 0 | |
#define TRUE 1 | |
class OneWire | |
{ | |
private: | |
uint16_t _pin; | |
void DIRECT_WRITE_LOW(void); | |
void DIRECT_MODE_OUTPUT(void); | |
void DIRECT_WRITE_HIGH(void); | |
void DIRECT_MODE_INPUT(void); | |
uint8_t DIRECT_READ(void); | |
#if ONEWIRE_SEARCH | |
// global search state | |
unsigned char ROM_NO[8]; | |
uint8_t LastDiscrepancy; | |
uint8_t LastFamilyDiscrepancy; | |
uint8_t LastDeviceFlag; | |
#endif | |
public: | |
OneWire( uint16_t pin); | |
// Perform a 1-Wire reset cycle. Returns 1 if a device responds | |
// with a presence pulse. Returns 0 if there is no device or the | |
// bus is shorted or otherwise held low for more than 250uS | |
uint8_t reset(void); | |
// Issue a 1-Wire rom select command, you do the reset first. | |
void select(const uint8_t rom[8]); | |
// Issue a 1-Wire rom skip command, to address all on bus. | |
void skip(void); | |
// Write a byte. If 'power' is one then the wire is held high at | |
// the end for parasitically powered devices. You are responsible | |
// for eventually depowering it by calling depower() or doing | |
// another read or write. | |
void write(uint8_t v, uint8_t power = 0); | |
void write_bytes(const uint8_t *buf, uint16_t count, bool power = 0); | |
// Read a byte. | |
uint8_t read(void); | |
void read_bytes(uint8_t *buf, uint16_t count); | |
// Write a bit. The bus is always left powered at the end, see | |
// note in write() about that. | |
void write_bit(uint8_t v); | |
// Read a bit. | |
uint8_t read_bit(void); | |
// Stop forcing power onto the bus. You only need to do this if | |
// you used the 'power' flag to write() or used a write_bit() call | |
// and aren't about to do another read or write. You would rather | |
// not leave this powered if you don't have to, just in case | |
// someone shorts your bus. | |
void depower(void); | |
#if ONEWIRE_SEARCH | |
// Clear the search state so that if will start from the beginning again. | |
void reset_search(); | |
// Setup the search to find the device type 'family_code' on the next call | |
// to search(*newAddr) if it is present. | |
void target_search(uint8_t family_code); | |
// Look for the next device. Returns 1 if a new address has been | |
// returned. A zero might mean that the bus is shorted, there are | |
// no devices, or you have already retrieved all of them. It | |
// might be a good idea to check the CRC to make sure you didn't | |
// get garbage. The order is deterministic. You will always get | |
// the same devices in the same order. | |
uint8_t search(uint8_t *newAddr); | |
#endif | |
#if ONEWIRE_CRC | |
// Compute a Dallas Semiconductor 8 bit CRC, these are used in the | |
// ROM and scratchpad registers. | |
static uint8_t crc8(uint8_t *addr, uint8_t len); | |
#if ONEWIRE_CRC16 | |
// Compute the 1-Wire CRC16 and compare it against the received CRC. | |
// Example usage (reading a DS2408): | |
// // Put everything in a buffer so we can compute the CRC easily. | |
// uint8_t buf[13]; | |
// buf[0] = 0xF0; // Read PIO Registers | |
// buf[1] = 0x88; // LSB address | |
// buf[2] = 0x00; // MSB address | |
// WriteBytes(net, buf, 3); // Write 3 cmd bytes | |
// ReadBytes(net, buf+3, 10); // Read 6 data bytes, 2 0xFF, 2 CRC16 | |
// if (!CheckCRC16(buf, 11, &buf[11])) { | |
// // Handle error. | |
// } | |
// | |
// @param input - Array of bytes to checksum. | |
// @param len - How many bytes to use. | |
// @param inverted_crc - The two CRC16 bytes in the received data. | |
// This should just point into the received data, | |
// *not* at a 16-bit integer. | |
// @param crc - The crc starting value (optional) | |
// @return True, iff the CRC matches. | |
static bool check_crc16(const uint8_t* input, uint16_t len, const uint8_t* inverted_crc, uint16_t crc = 0); | |
// Compute a Dallas Semiconductor 16 bit CRC. This is required to check | |
// the integrity of data received from many 1-Wire devices. Note that the | |
// CRC computed here is *not* what you'll get from the 1-Wire network, | |
// for two reasons: | |
// 1) The CRC is transmitted bitwise inverted. | |
// 2) Depending on the endian-ness of your processor, the binary | |
// representation of the two-byte return value may have a different | |
// byte order than the two bytes you get from 1-Wire. | |
// @param input - Array of bytes to checksum. | |
// @param len - How many bytes to use. | |
// @param crc - The crc starting value (optional) | |
// @return The CRC16, as defined by Dallas Semiconductor. | |
static uint16_t crc16(const uint8_t* input, uint16_t len, uint16_t crc = 0); | |
#endif | |
#endif | |
}; | |
#endif | |
/* | |
SparkCore Verison of OneWire Libary | |
I've taken the code that Spark Forum user tidwelltimj posted | |
split it back into separte code and header files and put back in the | |
credits and comments and got it compiling on the command line within SparkCore core-firmware | |
Justin Maynard 2013 | |
Original Comments follow | |
Copyright (c) 2007, Jim Studt (original old version - many contributors since) | |
The latest version of this library may be found at: | |
http://www.pjrc.com/teensy/td_libs_OneWire.html | |
OneWire has been maintained by Paul Stoffregen (paul@pjrc.com) since | |
January 2010. At the time, it was in need of many bug fixes, but had | |
been abandoned the original author (Jim Studt). None of the known | |
contributors were interested in maintaining OneWire. Paul typically | |
works on OneWire every 6 to 12 months. Patches usually wait that | |
long. If anyone is interested in more actively maintaining OneWire, | |
please contact Paul. | |
Version 2.2: | |
Teensy 3.0 compatibility, Paul Stoffregen, paul@pjrc.com | |
Arduino Due compatibility, http://arduino.cc/forum/index.php?topic=141030 | |
Fix DS18B20 example negative temperature | |
Fix DS18B20 example's low res modes, Ken Butcher | |
Improve reset timing, Mark Tillotson | |
Add const qualifiers, Bertrik Sikken | |
Add initial value input to crc16, Bertrik Sikken | |
Add target_search() function, Scott Roberts | |
Version 2.1: | |
Arduino 1.0 compatibility, Paul Stoffregen | |
Improve temperature example, Paul Stoffregen | |
DS250x_PROM example, Guillermo Lovato | |
PIC32 (chipKit) compatibility, Jason Dangel, dangel.jason AT gmail.com | |
Improvements from Glenn Trewitt: | |
- crc16() now works | |
- check_crc16() does all of calculation/checking work. | |
- Added read_bytes() and write_bytes(), to reduce tedious loops. | |
- Added ds2408 example. | |
Delete very old, out-of-date readme file (info is here) | |
Version 2.0: Modifications by Paul Stoffregen, January 2010: | |
http://www.pjrc.com/teensy/td_libs_OneWire.html | |
Search fix from Robin James | |
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295/27#27 | |
Use direct optimized I/O in all cases | |
Disable interrupts during timing critical sections | |
(this solves many random communication errors) | |
Disable interrupts during read-modify-write I/O | |
Reduce RAM consumption by eliminating unnecessary | |
variables and trimming many to 8 bits | |
Optimize both crc8 - table version moved to flash | |
Modified to work with larger numbers of devices - avoids loop. | |
Tested in Arduino 11 alpha with 12 sensors. | |
26 Sept 2008 -- Robin James | |
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295/27#27 | |
Updated to work with arduino-0008 and to include skip() as of | |
2007/07/06. --RJL20 | |
Modified to calculate the 8-bit CRC directly, avoiding the need for | |
the 256-byte lookup table to be loaded in RAM. Tested in arduino-0010 | |
-- Tom Pollard, Jan 23, 2008 | |
Jim Studt's original library was modified by Josh Larios. | |
Tom Pollard, pollard@alum.mit.edu, contributed around May 20, 2008 | |
Permission is hereby granted, free of charge, to any person obtaining | |
a copy of this software and associated documentation files (the | |
"Software"), to deal in the Software without restriction, including | |
without limitation the rights to use, copy, modify, merge, publish, | |
distribute, sublicense, and/or sell copies of the Software, and to | |
permit persons to whom the Software is furnished to do so, subject to | |
the following conditions: | |
The above copyright notice and this permission notice shall be | |
included in all copies or substantial portions of the Software. | |
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE | |
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION | |
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | |
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
Much of the code was inspired by Derek Yerger's code, though I don't | |
think much of that remains. In any event that was.. | |
(copyleft) 2006 by Derek Yerger - Free to distribute freely. | |
The CRC code was excerpted and inspired by the Dallas Semiconductor | |
sample code bearing this copyright. | |
//--------------------------------------------------------------------------- | |
// Copyright (C) 2000 Dallas Semiconductor Corporation, All Rights Reserved. | |
// | |
// Permission is hereby granted, free of charge, to any person obtaining a | |
// copy of this software and associated documentation files (the "Software"), | |
// to deal in the Software without restriction, including without limitation | |
// the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
// and/or sell copies of the Software, and to permit persons to whom the | |
// Software is furnished to do so, subject to the following conditions: | |
// | |
// The above copyright notice and this permission notice shall be included | |
// in all copies or substantial portions of the Software. | |
// | |
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. | |
// IN NO EVENT SHALL DALLAS SEMICONDUCTOR BE LIABLE FOR ANY CLAIM, DAMAGES | |
// OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | |
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | |
// OTHER DEALINGS IN THE SOFTWARE. | |
// | |
// Except as contained in this notice, the name of Dallas Semiconductor | |
// shall not be used except as stated in the Dallas Semiconductor | |
// Branding Policy. | |
//-------------------------------------------------------------------------- | |
*/ | |
OneWire::OneWire(uint16_t pin) | |
{ | |
pinMode(pin, INPUT); | |
_pin = pin; | |
} | |
void OneWire::DIRECT_WRITE_LOW(void) | |
{ | |
PIN_MAP[_pin].gpio_peripheral->BRR = PIN_MAP[_pin].gpio_pin; | |
} | |
void OneWire::DIRECT_MODE_OUTPUT(void) | |
{ | |
GPIO_TypeDef *gpio_port = PIN_MAP[_pin].gpio_peripheral; | |
uint16_t gpio_pin = PIN_MAP[_pin].gpio_pin; | |
GPIO_InitTypeDef GPIO_InitStructure; | |
if (gpio_port == GPIOA ) | |
{ | |
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); | |
} | |
else if (gpio_port == GPIOB ) | |
{ | |
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); | |
} | |
GPIO_InitStructure.GPIO_Pin = gpio_pin; | |
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; | |
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; | |
PIN_MAP[_pin].pin_mode = OUTPUT; | |
GPIO_Init(gpio_port, &GPIO_InitStructure); | |
} | |
void OneWire::DIRECT_WRITE_HIGH(void) | |
{ | |
PIN_MAP[_pin].gpio_peripheral->BSRR = PIN_MAP[_pin].gpio_pin; | |
} | |
void OneWire::DIRECT_MODE_INPUT(void) | |
{ | |
GPIO_TypeDef *gpio_port = PIN_MAP[_pin].gpio_peripheral; | |
uint16_t gpio_pin = PIN_MAP[_pin].gpio_pin; | |
GPIO_InitTypeDef GPIO_InitStructure; | |
if (gpio_port == GPIOA ) | |
{ | |
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); | |
} | |
else if (gpio_port == GPIOB ) | |
{ | |
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); | |
} | |
GPIO_InitStructure.GPIO_Pin = gpio_pin; | |
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; | |
PIN_MAP[_pin].pin_mode = INPUT; | |
GPIO_Init(gpio_port, &GPIO_InitStructure); | |
} | |
uint8_t OneWire::DIRECT_READ(void) | |
{ | |
return GPIO_ReadInputDataBit(PIN_MAP[_pin].gpio_peripheral, PIN_MAP[_pin].gpio_pin); | |
} | |
// Perform the onewire reset function. We will wait up to 250uS for | |
// the bus to come high, if it doesn't then it is broken or shorted | |
// and we return a 0; | |
// | |
// Returns 1 if a device asserted a presence pulse, 0 otherwise. | |
// | |
uint8_t OneWire::reset(void) | |
{ | |
uint8_t r; | |
uint8_t retries = 125; | |
noInterrupts(); | |
DIRECT_MODE_INPUT(); | |
interrupts(); | |
// wait until the wire is high... just in case | |
do { | |
if (--retries == 0) return 0; | |
delayMicroseconds(2); | |
} while ( !DIRECT_READ()); | |
noInterrupts(); | |
DIRECT_WRITE_LOW(); | |
DIRECT_MODE_OUTPUT(); // drive output low | |
interrupts(); | |
delayMicroseconds(480); | |
noInterrupts(); | |
DIRECT_MODE_INPUT(); // allow it to float | |
delayMicroseconds(70); | |
r = !DIRECT_READ(); | |
interrupts(); | |
delayMicroseconds(410); | |
return r; | |
} | |
void OneWire::write_bit(uint8_t v) | |
{ | |
if (v & 1) { | |
noInterrupts(); | |
DIRECT_WRITE_LOW(); | |
DIRECT_MODE_OUTPUT(); // drive output low | |
delayMicroseconds(10); | |
DIRECT_WRITE_HIGH(); // drive output high | |
interrupts(); | |
delayMicroseconds(55); | |
} else { | |
noInterrupts(); | |
DIRECT_WRITE_LOW(); | |
DIRECT_MODE_OUTPUT(); // drive output low | |
delayMicroseconds(65); | |
DIRECT_WRITE_HIGH(); // drive output high | |
interrupts(); | |
delayMicroseconds(5); | |
} | |
} | |
// | |
// Read a bit. Port and bit is used to cut lookup time and provide | |
// more certain timing. | |
// | |
uint8_t OneWire::read_bit(void) | |
{ | |
uint8_t r; | |
noInterrupts(); | |
DIRECT_MODE_OUTPUT(); | |
DIRECT_WRITE_LOW(); | |
delayMicroseconds(3); | |
DIRECT_MODE_INPUT(); // let pin float, pull up will raise | |
delayMicroseconds(10); | |
r = DIRECT_READ(); | |
interrupts(); | |
delayMicroseconds(53); | |
return r; | |
} | |
// | |
// Write a byte. The writing code uses the active drivers to raise the | |
// pin high, if you need power after the write (e.g. DS18S20 in | |
// parasite power mode) then set 'power' to 1, otherwise the pin will | |
// go tri-state at the end of the write to avoid heating in a short or | |
// other mishap. | |
// | |
void OneWire::write(uint8_t v, uint8_t power /* = 0 */) { | |
uint8_t bitMask; | |
for (bitMask = 0x01; bitMask; bitMask <<= 1) { | |
OneWire::write_bit( (bitMask & v)?1:0); | |
} | |
if ( !power) { | |
noInterrupts(); | |
DIRECT_MODE_INPUT(); | |
DIRECT_WRITE_LOW(); | |
interrupts(); | |
} | |
} | |
void OneWire::write_bytes(const uint8_t *buf, uint16_t count, bool power /* = 0 */) { | |
for (uint16_t i = 0 ; i < count ; i++) | |
write(buf[i]); | |
if (!power) { | |
noInterrupts(); | |
DIRECT_MODE_INPUT(); | |
DIRECT_WRITE_LOW(); | |
interrupts(); | |
} | |
} | |
// | |
// Read a byte | |
// | |
uint8_t OneWire::read() { | |
uint8_t bitMask; | |
uint8_t r = 0; | |
for (bitMask = 0x01; bitMask; bitMask <<= 1) { | |
if ( OneWire::read_bit()) r |= bitMask; | |
} | |
return r; | |
} | |
void OneWire::read_bytes(uint8_t *buf, uint16_t count) { | |
for (uint16_t i = 0 ; i < count ; i++) | |
buf[i] = read(); | |
} | |
// | |
// Do a ROM select | |
// | |
void OneWire::select(const uint8_t rom[8]) | |
{ | |
uint8_t i; | |
write(0x55); // Choose ROM | |
for (i = 0; i < 8; i++) write(rom[i]); | |
} | |
// | |
// Do a ROM skip | |
// | |
void OneWire::skip() | |
{ | |
write(0xCC); // Skip ROM | |
} | |
void OneWire::depower() | |
{ | |
noInterrupts(); | |
DIRECT_MODE_INPUT(); | |
interrupts(); | |
} | |
#if ONEWIRE_SEARCH | |
// | |
// You need to use this function to start a search again from the beginning. | |
// You do not need to do it for the first search, though you could. | |
// | |
void OneWire::reset_search() | |
{ | |
// reset the search state | |
LastDiscrepancy = 0; | |
LastDeviceFlag = FALSE; | |
LastFamilyDiscrepancy = 0; | |
for(int i = 7; ; i--) { | |
ROM_NO[i] = 0; | |
if ( i == 0) break; | |
} | |
} | |
// Setup the search to find the device type 'family_code' on the next call | |
// to search(*newAddr) if it is present. | |
// | |
void OneWire::target_search(uint8_t family_code) | |
{ | |
// set the search state to find SearchFamily type devices | |
ROM_NO[0] = family_code; | |
for (uint8_t i = 1; i < 8; i++) | |
ROM_NO[i] = 0; | |
LastDiscrepancy = 64; | |
LastFamilyDiscrepancy = 0; | |
LastDeviceFlag = FALSE; | |
} | |
// | |
// Perform a search. If this function returns a '1' then it has | |
// enumerated the next device and you may retrieve the ROM from the | |
// OneWire::address variable. If there are no devices, no further | |
// devices, or something horrible happens in the middle of the | |
// enumeration then a 0 is returned. If a new device is found then | |
// its address is copied to newAddr. Use OneWire::reset_search() to | |
// start over. | |
// | |
// --- Replaced by the one from the Dallas Semiconductor web site --- | |
//-------------------------------------------------------------------------- | |
// Perform the 1-Wire Search Algorithm on the 1-Wire bus using the existing | |
// search state. | |
// Return TRUE : device found, ROM number in ROM_NO buffer | |
// FALSE : device not found, end of search | |
// | |
uint8_t OneWire::search(uint8_t *newAddr) | |
{ | |
uint8_t id_bit_number; | |
uint8_t last_zero, rom_byte_number, search_result; | |
uint8_t id_bit, cmp_id_bit; | |
unsigned char rom_byte_mask, search_direction; | |
// initialize for search | |
id_bit_number = 1; | |
last_zero = 0; | |
rom_byte_number = 0; | |
rom_byte_mask = 1; | |
search_result = 0; | |
// if the last call was not the last one | |
if (!LastDeviceFlag) | |
{ | |
// 1-Wire reset | |
if (!reset()) | |
{ | |
// reset the search | |
LastDiscrepancy = 0; | |
LastDeviceFlag = FALSE; | |
LastFamilyDiscrepancy = 0; | |
return FALSE; | |
} | |
// issue the search command | |
write(0xF0); | |
// loop to do the search | |
do | |
{ | |
// read a bit and its complement | |
id_bit = read_bit(); | |
cmp_id_bit = read_bit(); | |
// check for no devices on 1-wire | |
if ((id_bit == 1) && (cmp_id_bit == 1)) | |
break; | |
else | |
{ | |
// all devices coupled have 0 or 1 | |
if (id_bit != cmp_id_bit) | |
search_direction = id_bit; // bit write value for search | |
else | |
{ | |
// if this discrepancy if before the Last Discrepancy | |
// on a previous next then pick the same as last time | |
if (id_bit_number < LastDiscrepancy) | |
search_direction = ((ROM_NO[rom_byte_number] & rom_byte_mask) > 0); | |
else | |
// if equal to last pick 1, if not then pick 0 | |
search_direction = (id_bit_number == LastDiscrepancy); | |
// if 0 was picked then record its position in LastZero | |
if (search_direction == 0) | |
{ | |
last_zero = id_bit_number; | |
// check for Last discrepancy in family | |
if (last_zero < 9) | |
LastFamilyDiscrepancy = last_zero; | |
} | |
} | |
// set or clear the bit in the ROM byte rom_byte_number | |
// with mask rom_byte_mask | |
if (search_direction == 1) | |
ROM_NO[rom_byte_number] |= rom_byte_mask; | |
else | |
ROM_NO[rom_byte_number] &= ~rom_byte_mask; | |
// serial number search direction write bit | |
write_bit(search_direction); | |
// increment the byte counter id_bit_number | |
// and shift the mask rom_byte_mask | |
id_bit_number++; | |
rom_byte_mask <<= 1; | |
// if the mask is 0 then go to new SerialNum byte rom_byte_number and reset mask | |
if (rom_byte_mask == 0) | |
{ | |
rom_byte_number++; | |
rom_byte_mask = 1; | |
} | |
} | |
} | |
while(rom_byte_number < 8); // loop until through all ROM bytes 0-7 | |
// if the search was successful then | |
if (!(id_bit_number < 65)) | |
{ | |
// search successful so set LastDiscrepancy,LastDeviceFlag,search_result | |
LastDiscrepancy = last_zero; | |
// check for last device | |
if (LastDiscrepancy == 0) | |
LastDeviceFlag = TRUE; | |
search_result = TRUE; | |
} | |
} | |
// if no device found then reset counters so next 'search' will be like a first | |
if (!search_result || !ROM_NO[0]) | |
{ | |
LastDiscrepancy = 0; | |
LastDeviceFlag = FALSE; | |
LastFamilyDiscrepancy = 0; | |
search_result = FALSE; | |
} | |
for (int i = 0; i < 8; i++) newAddr[i] = ROM_NO[i]; | |
return search_result; | |
} | |
#endif | |
#if ONEWIRE_CRC | |
// The 1-Wire CRC scheme is described in Maxim Application Note 27: | |
// "Understanding and Using Cyclic Redundancy Checks with Maxim iButton Products" | |
// | |
// | |
// Compute a Dallas Semiconductor 8 bit CRC directly. | |
// this is much slower, but much smaller, than the lookup table. | |
// | |
uint8_t OneWire::crc8( uint8_t *addr, uint8_t len) | |
{ | |
uint8_t crc = 0; | |
while (len--) { | |
uint8_t inbyte = *addr++; | |
for (uint8_t i = 8; i; i--) { | |
uint8_t mix = (crc ^ inbyte) & 0x01; | |
crc >>= 1; | |
if (mix) crc ^= 0x8C; | |
inbyte >>= 1; | |
} | |
} | |
return crc; | |
} | |
#endif | |
#if ONEWIRE_CRC16 | |
bool OneWire::check_crc16(const uint8_t* input, uint16_t len, const uint8_t* inverted_crc, uint16_t crc) | |
{ | |
crc = ~crc16(input, len, crc); | |
return (crc & 0xFF) == inverted_crc[0] && (crc >> 8) == inverted_crc[1]; | |
} | |
uint16_t OneWire::crc16(const uint8_t* input, uint16_t len, uint16_t crc) | |
{ | |
static const uint8_t oddparity[16] = | |
{ 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 }; | |
for (uint16_t i = 0 ; i < len ; i++) { | |
// Even though we're just copying a byte from the input, | |
// we'll be doing 16-bit computation with it. | |
uint16_t cdata = input[i]; | |
cdata = (cdata ^ crc) & 0xff; | |
crc >>= 8; | |
if (oddparity[cdata & 0x0F] ^ oddparity[cdata >> 4]) | |
crc ^= 0xC001; | |
cdata <<= 6; | |
crc ^= cdata; | |
cdata <<= 1; | |
crc ^= cdata; | |
} | |
return crc; | |
} | |
#endif | |
#ifndef DallasTemperature_h | |
#define DallasTemperature_h | |
#define DALLASTEMPLIBVERSION "3.7.2" | |
// 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. | |
// set to true to include code for new and delete operators | |
#ifndef REQUIRESNEW | |
#define REQUIRESNEW false | |
#endif | |
// set to true to include code implementing alarm search functions | |
#ifndef REQUIRESALARMS | |
#define REQUIRESALARMS true | |
#endif | |
#include <inttypes.h> | |
// Model IDs | |
#define DS18S20MODEL 0x10 | |
#define DS18B20MODEL 0x28 | |
#define DS1822MODEL 0x22 | |
// OneWire commands | |
#define STARTCONVO 0x44 // Tells device to take a temperature reading and put it on the scratchpad | |
#define COPYSCRATCH 0x48 // Copy EEPROM | |
#define READSCRATCH 0xBE // Read EEPROM | |
#define WRITESCRATCH 0x4E // Write to EEPROM | |
#define RECALLSCRATCH 0xB8 // Reload from last known | |
#define READPOWERSUPPLY 0xB4 // Determine if device needs parasite power | |
#define ALARMSEARCH 0xEC // Query bus for devices with an alarm condition | |
// Scratchpad locations | |
#define TEMP_LSB 0 | |
#define TEMP_MSB 1 | |
#define HIGH_ALARM_TEMP 2 | |
#define LOW_ALARM_TEMP 3 | |
#define CONFIGURATION 4 | |
#define INTERNAL_BYTE 5 | |
#define COUNT_REMAIN 6 | |
#define COUNT_PER_C 7 | |
#define SCRATCHPAD_CRC 8 | |
// Device resolution | |
#define TEMP_9_BIT 0x1F // 9 bit | |
#define TEMP_10_BIT 0x3F // 10 bit | |
#define TEMP_11_BIT 0x5F // 11 bit | |
#define TEMP_12_BIT 0x7F // 12 bit | |
// Error Codes | |
#define DEVICE_DISCONNECTED -127 | |
typedef uint8_t DeviceAddress[8]; | |
class DallasTemperature | |
{ | |
public: | |
DallasTemperature(OneWire*); | |
// initalise bus | |
void begin(void); | |
// returns the number of devices found on the bus | |
uint8_t getDeviceCount(void); | |
// Is a conversion complete on the wire? | |
bool isConversionComplete(void); | |
// returns true if address is valid | |
bool validAddress(uint8_t*); | |
// finds an address at a given index on the bus | |
bool getAddress(uint8_t*, const uint8_t); | |
// attempt to determine if the device at the given address is connected to the bus | |
bool isConnected(uint8_t*); | |
// attempt to determine if the device at the given address is connected to the bus | |
// also allows for updating the read scratchpad | |
bool isConnected(uint8_t*, uint8_t*); | |
// read device's scratchpad | |
void readScratchPad(uint8_t*, uint8_t*); | |
// write device's scratchpad | |
void writeScratchPad(uint8_t*, const uint8_t*); | |
// read device's power requirements | |
bool readPowerSupply(uint8_t*); | |
// get global resolution | |
uint8_t getResolution(); | |
// set global resolution to 9, 10, 11, or 12 bits | |
void setResolution(uint8_t); | |
// returns the device resolution, 9-12 | |
uint8_t getResolution(uint8_t*); | |
// set resolution of a device to 9, 10, 11, or 12 bits | |
bool setResolution(uint8_t*, uint8_t); | |
// sets/gets the waitForConversion flag | |
void setWaitForConversion(bool); | |
bool getWaitForConversion(void); | |
// sets/gets the checkForConversion flag | |
void setCheckForConversion(bool); | |
bool getCheckForConversion(void); | |
// sends command for all devices on the bus to perform a temperature conversion | |
void requestTemperatures(void); | |
// sends command for one device to perform a temperature conversion by address | |
bool requestTemperaturesByAddress(uint8_t*); | |
// sends command for one device to perform a temperature conversion by index | |
bool requestTemperaturesByIndex(uint8_t); | |
// returns temperature in degrees C | |
float getTempC(uint8_t*); | |
// returns temperature in degrees F | |
float getTempF(uint8_t*); | |
// Get temperature for device index (slow) | |
float getTempCByIndex(uint8_t); | |
// Get temperature for device index (slow) | |
float getTempFByIndex(uint8_t); | |
// returns true if the bus requires parasite power | |
bool isParasitePowerMode(void); | |
bool isConversionAvailable(uint8_t*); | |
#if REQUIRESALARMS | |
typedef void AlarmHandler(uint8_t*); | |
// sets the high alarm temperature for a device | |
// accepts a char. valid range is -55C - 125C | |
void setHighAlarmTemp(uint8_t*, const char); | |
// sets the low alarm temperature for a device | |
// accepts a char. valid range is -55C - 125C | |
void setLowAlarmTemp(uint8_t*, const char); | |
// returns a signed char with the current high alarm temperature for a device | |
// in the range -55C - 125C | |
char getHighAlarmTemp(uint8_t*); | |
// returns a signed char with the current low alarm temperature for a device | |
// in the range -55C - 125C | |
char getLowAlarmTemp(uint8_t*); | |
// resets internal variables used for the alarm search | |
void resetAlarmSearch(void); | |
// search the wire for devices with active alarms | |
bool alarmSearch(uint8_t*); | |
// returns true if ia specific device has an alarm | |
bool hasAlarm(uint8_t*); | |
// returns true if any device is reporting an alarm on the bus | |
bool hasAlarm(void); | |
// runs the alarm handler for all devices returned by alarmSearch() | |
void processAlarms(void); | |
// sets the alarm handler | |
void setAlarmHandler(AlarmHandler *); | |
// The default alarm handler | |
static void defaultAlarmHandler(uint8_t*); | |
#endif | |
// convert from celcius to farenheit | |
static float toFahrenheit(const float); | |
// convert from farenheit to celsius | |
static float toCelsius(const float); | |
#if REQUIRESNEW | |
// initalize memory area | |
void* operator new (unsigned int); | |
// delete memory reference | |
void operator delete(void*); | |
#endif | |
private: | |
typedef uint8_t ScratchPad[9]; | |
// parasite power on or off | |
bool parasite; | |
// used to determine the delay amount needed to allow for the | |
// temperature conversion to take place | |
uint8_t bitResolution; | |
// used to requestTemperature with or without delay | |
bool waitForConversion; | |
// used to requestTemperature to dynamically check if a conversion is complete | |
bool checkForConversion; | |
// count of devices on the bus | |
uint8_t devices; | |
// Take a pointer to one wire instance | |
OneWire* _wire; | |
// reads scratchpad and returns the temperature in degrees C | |
float calculateTemperature(uint8_t*, uint8_t*); | |
void blockTillConversionComplete(uint8_t*,uint8_t*); | |
#if REQUIRESALARMS | |
// required for alarmSearch | |
uint8_t alarmSearchAddress[8]; | |
char alarmSearchJunction; | |
uint8_t alarmSearchExhausted; | |
// the alarm handler function pointer | |
AlarmHandler *_AlarmHandler; | |
#endif | |
}; | |
#endif | |
#ifdef __AVR__ | |
#if ARDUINO >= 100 | |
#include "Arduino.h" | |
#else | |
extern "C" { | |
#include "WConstants.h" | |
} | |
#endif | |
#endif | |
#ifdef STM32F10X_MD | |
#include "spark_wiring.h" | |
#endif | |
DallasTemperature::DallasTemperature(OneWire* _oneWire) | |
#if REQUIRESALARMS | |
: _AlarmHandler(&defaultAlarmHandler) | |
#endif | |
{ | |
_wire = _oneWire; | |
devices = 0; | |
parasite = false; | |
bitResolution = 9; | |
waitForConversion = true; | |
checkForConversion = true; | |
} | |
// initialise the bus | |
void DallasTemperature::begin(void) | |
{ | |
DeviceAddress deviceAddress; | |
_wire->reset_search(); | |
devices = 0; // Reset the number of devices when we enumerate wire devices | |
while (_wire->search(deviceAddress)) | |
{ | |
if (validAddress(deviceAddress)) | |
{ | |
if (!parasite && readPowerSupply(deviceAddress)) parasite = true; | |
ScratchPad scratchPad; | |
readScratchPad(deviceAddress, scratchPad); | |
bitResolution = max(bitResolution, getResolution(deviceAddress)); | |
devices++; | |
} | |
} | |
} | |
// returns the number of devices found on the bus | |
uint8_t DallasTemperature::getDeviceCount(void) | |
{ | |
return devices; | |
} | |
// returns true if address is valid | |
bool DallasTemperature::validAddress(uint8_t* deviceAddress) | |
{ | |
return (_wire->crc8(deviceAddress, 7) == deviceAddress[7]); | |
} | |
// finds an address at a given index on the bus | |
// returns true if the device was found | |
bool DallasTemperature::getAddress(uint8_t* deviceAddress, uint8_t index) | |
{ | |
uint8_t depth = 0; | |
_wire->reset_search(); | |
while (depth <= index && _wire->search(deviceAddress)) | |
{ | |
if (depth == index && validAddress(deviceAddress)) return true; | |
depth++; | |
} | |
return false; | |
} | |
// attempt to determine if the device at the given address is connected to the bus | |
bool DallasTemperature::isConnected(uint8_t* deviceAddress) | |
{ | |
ScratchPad scratchPad; | |
return isConnected(deviceAddress, scratchPad); | |
} | |
// attempt to determine if the device at the given address is connected to the bus | |
// also allows for updating the read scratchpad | |
bool DallasTemperature::isConnected(uint8_t* deviceAddress, uint8_t* scratchPad) | |
{ | |
readScratchPad(deviceAddress, scratchPad); | |
return (_wire->crc8(scratchPad, 8) == scratchPad[SCRATCHPAD_CRC]); | |
} | |
// read device's scratch pad | |
void DallasTemperature::readScratchPad(uint8_t* deviceAddress, uint8_t* scratchPad) | |
{ | |
// send the command | |
_wire->reset(); | |
_wire->select(deviceAddress); | |
_wire->write(READSCRATCH); | |
// TODO => collect all comments & use simple loop | |
// byte 0: temperature LSB | |
// byte 1: temperature MSB | |
// byte 2: high alarm temp | |
// byte 3: low alarm temp | |
// byte 4: DS18S20: store for crc | |
// DS18B20 & DS1822: configuration register | |
// byte 5: internal use & crc | |
// byte 6: DS18S20: COUNT_REMAIN | |
// DS18B20 & DS1822: store for crc | |
// byte 7: DS18S20: COUNT_PER_C | |
// DS18B20 & DS1822: store for crc | |
// byte 8: SCRATCHPAD_CRC | |
// | |
// for(int i=0; i<9; i++) | |
// { | |
// scratchPad[i] = _wire->read(); | |
// } | |
// read the response | |
// byte 0: temperature LSB | |
scratchPad[TEMP_LSB] = _wire->read(); | |
// byte 1: temperature MSB | |
scratchPad[TEMP_MSB] = _wire->read(); | |
// byte 2: high alarm temp | |
scratchPad[HIGH_ALARM_TEMP] = _wire->read(); | |
// byte 3: low alarm temp | |
scratchPad[LOW_ALARM_TEMP] = _wire->read(); | |
// byte 4: | |
// DS18S20: store for crc | |
// DS18B20 & DS1822: configuration register | |
scratchPad[CONFIGURATION] = _wire->read(); | |
// byte 5: | |
// internal use & crc | |
scratchPad[INTERNAL_BYTE] = _wire->read(); | |
// byte 6: | |
// DS18S20: COUNT_REMAIN | |
// DS18B20 & DS1822: store for crc | |
scratchPad[COUNT_REMAIN] = _wire->read(); | |
// byte 7: | |
// DS18S20: COUNT_PER_C | |
// DS18B20 & DS1822: store for crc | |
scratchPad[COUNT_PER_C] = _wire->read(); | |
// byte 8: | |
// SCTRACHPAD_CRC | |
scratchPad[SCRATCHPAD_CRC] = _wire->read(); | |
_wire->reset(); | |
} | |
// writes device's scratch pad | |
void DallasTemperature::writeScratchPad(uint8_t* deviceAddress, const uint8_t* scratchPad) | |
{ | |
_wire->reset(); | |
_wire->select(deviceAddress); | |
_wire->write(WRITESCRATCH); | |
_wire->write(scratchPad[HIGH_ALARM_TEMP]); // high alarm temp | |
_wire->write(scratchPad[LOW_ALARM_TEMP]); // low alarm temp | |
// DS18S20 does not use the configuration register | |
if (deviceAddress[0] != DS18S20MODEL) _wire->write(scratchPad[CONFIGURATION]); // configuration | |
_wire->reset(); | |
// save the newly written values to eeprom | |
_wire->write(COPYSCRATCH, parasite); | |
if (parasite) delay(10); // 10ms delay | |
_wire->reset(); | |
} | |
// reads the device's power requirements | |
bool DallasTemperature::readPowerSupply(uint8_t* deviceAddress) | |
{ | |
bool ret = false; | |
_wire->reset(); | |
_wire->select(deviceAddress); | |
_wire->write(READPOWERSUPPLY); | |
if (_wire->read_bit() == 0) ret = true; | |
_wire->reset(); | |
return ret; | |
} | |
// set resolution of all devices to 9, 10, 11, or 12 bits | |
// if new resolution is out of range, it is constrained. | |
void DallasTemperature::setResolution(uint8_t newResolution) | |
{ | |
bitResolution = constrain(newResolution, 9, 12); | |
DeviceAddress deviceAddress; | |
for (int i=0; i<devices; i++) | |
{ | |
getAddress(deviceAddress, i); | |
setResolution(deviceAddress, bitResolution); | |
} | |
} | |
// set resolution of a device to 9, 10, 11, or 12 bits | |
// if new resolution is out of range, 9 bits is used. | |
bool DallasTemperature::setResolution(uint8_t* deviceAddress, uint8_t newResolution) | |
{ | |
ScratchPad scratchPad; | |
if (isConnected(deviceAddress, scratchPad)) | |
{ | |
// DS18S20 has a fixed 9-bit resolution | |
if (deviceAddress[0] != DS18S20MODEL) | |
{ | |
switch (newResolution) | |
{ | |
case 12: | |
scratchPad[CONFIGURATION] = TEMP_12_BIT; | |
break; | |
case 11: | |
scratchPad[CONFIGURATION] = TEMP_11_BIT; | |
break; | |
case 10: | |
scratchPad[CONFIGURATION] = TEMP_10_BIT; | |
break; | |
case 9: | |
default: | |
scratchPad[CONFIGURATION] = TEMP_9_BIT; | |
break; | |
} | |
writeScratchPad(deviceAddress, scratchPad); | |
} | |
return true; // new value set | |
} | |
return false; | |
} | |
// returns the global resolution | |
uint8_t DallasTemperature::getResolution() | |
{ | |
return bitResolution; | |
} | |
// returns the current resolution of the device, 9-12 | |
// returns 0 if device not found | |
uint8_t DallasTemperature::getResolution(uint8_t* deviceAddress) | |
{ | |
if (deviceAddress[0] == DS18S20MODEL) return 9; // this model has a fixed resolution | |
ScratchPad scratchPad; | |
if (isConnected(deviceAddress, scratchPad)) | |
{ | |
switch (scratchPad[CONFIGURATION]) | |
{ | |
case TEMP_12_BIT: | |
return 12; | |
case TEMP_11_BIT: | |
return 11; | |
case TEMP_10_BIT: | |
return 10; | |
case TEMP_9_BIT: | |
return 9; | |
} | |
} | |
return 0; | |
} | |
// sets the value of the waitForConversion flag | |
// TRUE : function requestTemperature() etc returns when conversion is ready | |
// FALSE: function requestTemperature() etc returns immediately (USE WITH CARE!!) | |
// (1) programmer has to check if the needed delay has passed | |
// (2) but the application can do meaningful things in that time | |
void DallasTemperature::setWaitForConversion(bool flag) | |
{ | |
waitForConversion = flag; | |
} | |
// gets the value of the waitForConversion flag | |
bool DallasTemperature::getWaitForConversion() | |
{ | |
return waitForConversion; | |
} | |
// sets the value of the checkForConversion flag | |
// TRUE : function requestTemperature() etc will 'listen' to an IC to determine whether a conversion is complete | |
// FALSE: function requestTemperature() etc will wait a set time (worst case scenario) for a conversion to complete | |
void DallasTemperature::setCheckForConversion(bool flag) | |
{ | |
checkForConversion = flag; | |
} | |
// gets the value of the waitForConversion flag | |
bool DallasTemperature::getCheckForConversion() | |
{ | |
return checkForConversion; | |
} | |
bool DallasTemperature::isConversionAvailable(uint8_t* deviceAddress) | |
{ | |
// Check if the clock has been raised indicating the conversion is complete | |
ScratchPad scratchPad; | |
readScratchPad(deviceAddress, scratchPad); | |
return scratchPad[0]; | |
} | |
// sends command for all devices on the bus to perform a temperature conversion | |
void DallasTemperature::requestTemperatures() | |
{ | |
_wire->reset(); | |
_wire->skip(); | |
_wire->write(STARTCONVO, parasite); | |
// ASYNC mode? | |
if (!waitForConversion) return; | |
blockTillConversionComplete(&bitResolution, 0); | |
return; | |
} | |
// sends command for one device to perform a temperature by address | |
// returns FALSE if device is disconnected | |
// returns TRUE otherwise | |
bool DallasTemperature::requestTemperaturesByAddress(uint8_t* deviceAddress) | |
{ | |
_wire->reset(); | |
_wire->select(deviceAddress); | |
_wire->write(STARTCONVO, parasite); | |
// check device | |
ScratchPad scratchPad; | |
if (!isConnected(deviceAddress, scratchPad)) return false; | |
// ASYNC mode? | |
if (!waitForConversion) return true; | |
uint8_t bitResolution = getResolution(deviceAddress); | |
blockTillConversionComplete(&bitResolution, deviceAddress); | |
return true; | |
} | |
void DallasTemperature::blockTillConversionComplete(uint8_t* bitResolution, uint8_t* deviceAddress) | |
{ | |
if(deviceAddress != 0 && checkForConversion && !parasite) | |
{ | |
// Continue to check if the IC has responded with a temperature | |
// NB: Could cause issues with multiple devices (one device may respond faster) | |
unsigned long start = millis(); | |
while(!isConversionAvailable(0) && ((millis() - start) < 750)); | |
} | |
// Wait a fix number of cycles till conversion is complete (based on IC datasheet) | |
switch (*bitResolution) | |
{ | |
case 9: | |
delay(94); | |
break; | |
case 10: | |
delay(188); | |
break; | |
case 11: | |
delay(375); | |
break; | |
case 12: | |
default: | |
delay(750); | |
break; | |
} | |
} | |
// sends command for one device to perform a temp conversion by index | |
bool DallasTemperature::requestTemperaturesByIndex(uint8_t deviceIndex) | |
{ | |
DeviceAddress deviceAddress; | |
getAddress(deviceAddress, deviceIndex); | |
return requestTemperaturesByAddress(deviceAddress); | |
} | |
// Fetch temperature for device index | |
float DallasTemperature::getTempCByIndex(uint8_t deviceIndex) | |
{ | |
DeviceAddress deviceAddress; | |
getAddress(deviceAddress, deviceIndex); | |
return getTempC((uint8_t*)deviceAddress); | |
} | |
// Fetch temperature for device index | |
float DallasTemperature::getTempFByIndex(uint8_t deviceIndex) | |
{ | |
return toFahrenheit(getTempCByIndex(deviceIndex)); | |
} | |
// reads scratchpad and returns the temperature in degrees C | |
float DallasTemperature::calculateTemperature(uint8_t* deviceAddress, uint8_t* scratchPad) | |
{ | |
int16_t rawTemperature = (((int16_t)scratchPad[TEMP_MSB]) << 8) | scratchPad[TEMP_LSB]; | |
switch (deviceAddress[0]) | |
{ | |
case DS18B20MODEL: | |
case DS1822MODEL: | |
switch (scratchPad[CONFIGURATION]) | |
{ | |
case TEMP_12_BIT: | |
return (float)rawTemperature * 0.0625; | |
break; | |
case TEMP_11_BIT: | |
return (float)(rawTemperature >> 1) * 0.125; | |
break; | |
case TEMP_10_BIT: | |
return (float)(rawTemperature >> 2) * 0.25; | |
break; | |
case TEMP_9_BIT: | |
return (float)(rawTemperature >> 3) * 0.5; | |
break; | |
} | |
break; | |
case DS18S20MODEL: | |
/* | |
Resolutions greater than 9 bits can be calculated using the data from | |
the temperature, COUNT REMAIN and COUNT PER �C registers in the | |
scratchpad. Note that the COUNT PER �C register is hard-wired to 16 | |
(10h). After reading the scratchpad, the TEMP_READ value is obtained | |
by truncating the 0.5�C bit (bit 0) from the temperature data. The | |
extended resolution temperature can then be calculated using the | |
following equation: | |
COUNT_PER_C - COUNT_REMAIN | |
TEMPERATURE = TEMP_READ - 0.25 + -------------------------- | |
COUNT_PER_C | |
*/ | |
// Good spot. Thanks Nic Johns for your contribution | |
return (float)(rawTemperature >> 1) - 0.25 +((float)(scratchPad[COUNT_PER_C] - scratchPad[COUNT_REMAIN]) / (float)scratchPad[COUNT_PER_C] ); | |
break; | |
} | |
return (float)00.00; | |
} | |
// returns temperature in degrees C or DEVICE_DISCONNECTED if the | |
// device's scratch pad cannot be read successfully. | |
// the numeric value of DEVICE_DISCONNECTED is defined in | |
// DallasTemperature.h. It is a large negative number outside the | |
// operating range of the device | |
float DallasTemperature::getTempC(uint8_t* deviceAddress) | |
{ | |
// TODO: Multiple devices (up to 64) on the same bus may take | |
// some time to negotiate a response | |
// What happens in case of collision? | |
ScratchPad scratchPad; | |
if (isConnected(deviceAddress, scratchPad)) return calculateTemperature(deviceAddress, scratchPad); | |
return DEVICE_DISCONNECTED; | |
} | |
// returns temperature in degrees F | |
// TODO: - when getTempC returns DEVICE_DISCONNECTED | |
// -127 gets converted to -196.6 F | |
float DallasTemperature::getTempF(uint8_t* deviceAddress) | |
{ | |
return toFahrenheit(getTempC(deviceAddress)); | |
} | |
// returns true if the bus requires parasite power | |
bool DallasTemperature::isParasitePowerMode(void) | |
{ | |
return parasite; | |
} | |
#if REQUIRESALARMS | |
/* | |
ALARMS: | |
TH and TL Register Format | |
BIT 7 BIT 6 BIT 5 BIT 4 BIT 3 BIT 2 BIT 1 BIT 0 | |
S 2^6 2^5 2^4 2^3 2^2 2^1 2^0 | |
Only bits 11 through 4 of the temperature register are used | |
in the TH and TL comparison since TH and TL are 8-bit | |
registers. If the measured temperature is lower than or equal | |
to TL or higher than or equal to TH, an alarm condition exists | |
and an alarm flag is set inside the DS18B20. This flag is | |
updated after every temperature measurement; therefore, if the | |
alarm condition goes away, the flag will be turned off after | |
the next temperature conversion. | |
*/ | |
// sets the high alarm temperature for a device in degrees celsius | |
// accepts a float, but the alarm resolution will ignore anything | |
// after a decimal point. valid range is -55C - 125C | |
void DallasTemperature::setHighAlarmTemp(uint8_t* deviceAddress, char celsius) | |
{ | |
// make sure the alarm temperature is within the device's range | |
if (celsius > 125) celsius = 125; | |
else if (celsius < -55) celsius = -55; | |
ScratchPad scratchPad; | |
if (isConnected(deviceAddress, scratchPad)) | |
{ | |
scratchPad[HIGH_ALARM_TEMP] = (uint8_t)celsius; | |
writeScratchPad(deviceAddress, scratchPad); | |
} | |
} | |
// sets the low alarm temperature for a device in degreed celsius | |
// accepts a float, but the alarm resolution will ignore anything | |
// after a decimal point. valid range is -55C - 125C | |
void DallasTemperature::setLowAlarmTemp(uint8_t* deviceAddress, char celsius) | |
{ | |
// make sure the alarm temperature is within the device's range | |
if (celsius > 125) celsius = 125; | |
else if (celsius < -55) celsius = -55; | |
ScratchPad scratchPad; | |
if (isConnected(deviceAddress, scratchPad)) | |
{ | |
scratchPad[LOW_ALARM_TEMP] = (uint8_t)celsius; | |
writeScratchPad(deviceAddress, scratchPad); | |
} | |
} | |
// returns a char with the current high alarm temperature or | |
// DEVICE_DISCONNECTED for an address | |
char DallasTemperature::getHighAlarmTemp(uint8_t* deviceAddress) | |
{ | |
ScratchPad scratchPad; | |
if (isConnected(deviceAddress, scratchPad)) return (char)scratchPad[HIGH_ALARM_TEMP]; | |
return DEVICE_DISCONNECTED; | |
} | |
// returns a char with the current low alarm temperature or | |
// DEVICE_DISCONNECTED for an address | |
char DallasTemperature::getLowAlarmTemp(uint8_t* deviceAddress) | |
{ | |
ScratchPad scratchPad; | |
if (isConnected(deviceAddress, scratchPad)) return (char)scratchPad[LOW_ALARM_TEMP]; | |
return DEVICE_DISCONNECTED; | |
} | |
// resets internal variables used for the alarm search | |
void DallasTemperature::resetAlarmSearch() | |
{ | |
alarmSearchJunction = -1; | |
alarmSearchExhausted = 0; | |
for(uint8_t i = 0; i < 7; i++) | |
alarmSearchAddress[i] = 0; | |
} | |
// This is a modified version of the OneWire::search method. | |
// | |
// Also added the OneWire search fix documented here: | |
// http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295 | |
// | |
// Perform an alarm search. If this function returns a '1' then it has | |
// enumerated the next device and you may retrieve the ROM from the | |
// OneWire::address variable. If there are no devices, no further | |
// devices, or something horrible happens in the middle of the | |
// enumeration then a 0 is returned. If a new device is found then | |
// its address is copied to newAddr. Use | |
// DallasTemperature::resetAlarmSearch() to start over. | |
bool DallasTemperature::alarmSearch(uint8_t* newAddr) | |
{ | |
uint8_t i; | |
char lastJunction = -1; | |
uint8_t done = 1; | |
if (alarmSearchExhausted) return false; | |
if (!_wire->reset()) return false; | |
// send the alarm search command | |
_wire->write(0xEC, 0); | |
for(i = 0; i < 64; i++) | |
{ | |
uint8_t a = _wire->read_bit( ); | |
uint8_t nota = _wire->read_bit( ); | |
uint8_t ibyte = i / 8; | |
uint8_t ibit = 1 << (i & 7); | |
// I don't think this should happen, this means nothing responded, but maybe if | |
// something vanishes during the search it will come up. | |
if (a && nota) return false; | |
if (!a && !nota) | |
{ | |
if (i == alarmSearchJunction) | |
{ | |
// this is our time to decide differently, we went zero last time, go one. | |
a = 1; | |
alarmSearchJunction = lastJunction; | |
} | |
else if (i < alarmSearchJunction) | |
{ | |
// take whatever we took last time, look in address | |
if (alarmSearchAddress[ibyte] & ibit) a = 1; | |
else | |
{ | |
// Only 0s count as pending junctions, we've already exhasuted the 0 side of 1s | |
a = 0; | |
done = 0; | |
lastJunction = i; | |
} | |
} | |
else | |
{ | |
// we are blazing new tree, take the 0 | |
a = 0; | |
alarmSearchJunction = i; | |
done = 0; | |
} | |
// OneWire search fix | |
// See: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295 | |
} | |
if (a) alarmSearchAddress[ibyte] |= ibit; | |
else alarmSearchAddress[ibyte] &= ~ibit; | |
_wire->write_bit(a); | |
} | |
if (done) alarmSearchExhausted = 1; | |
for (i = 0; i < 8; i++) newAddr[i] = alarmSearchAddress[i]; | |
return true; | |
} | |
// returns true if device address has an alarm condition | |
// TODO: can this be done with only TEMP_MSB REGISTER (faster) | |
// if ((char) scratchPad[TEMP_MSB] <= (char) scratchPad[LOW_ALARM_TEMP]) return true; | |
// if ((char) scratchPad[TEMP_MSB] >= (char) scratchPad[HIGH_ALARM_TEMP]) return true; | |
bool DallasTemperature::hasAlarm(uint8_t* deviceAddress) | |
{ | |
ScratchPad scratchPad; | |
if (isConnected(deviceAddress, scratchPad)) | |
{ | |
float temp = calculateTemperature(deviceAddress, scratchPad); | |
// check low alarm | |
if ((char)temp <= (char)scratchPad[LOW_ALARM_TEMP]) return true; | |
// check high alarm | |
if ((char)temp >= (char)scratchPad[HIGH_ALARM_TEMP]) return true; | |
} | |
// no alarm | |
return false; | |
} | |
// returns true if any device is reporting an alarm condition on the bus | |
bool DallasTemperature::hasAlarm(void) | |
{ | |
DeviceAddress deviceAddress; | |
resetAlarmSearch(); | |
return alarmSearch(deviceAddress); | |
} | |
// runs the alarm handler for all devices returned by alarmSearch() | |
void DallasTemperature::processAlarms(void) | |
{ | |
resetAlarmSearch(); | |
DeviceAddress alarmAddr; | |
while (alarmSearch(alarmAddr)) | |
{ | |
if (validAddress(alarmAddr)) | |
_AlarmHandler(alarmAddr); | |
} | |
} | |
// sets the alarm handler | |
void DallasTemperature::setAlarmHandler(AlarmHandler *handler) | |
{ | |
_AlarmHandler = handler; | |
} | |
// The default alarm handler | |
void DallasTemperature::defaultAlarmHandler(uint8_t* deviceAddress) | |
{ | |
} | |
#endif | |
// Convert float celsius to fahrenheit | |
float DallasTemperature::toFahrenheit(float celsius) | |
{ | |
return (celsius * 1.8) + 32; | |
} | |
// Convert float fahrenheit to celsius | |
float DallasTemperature::toCelsius(float fahrenheit) | |
{ | |
return (fahrenheit - 32) / 1.8; | |
} | |
#if REQUIRESNEW | |
// MnetCS - Allocates memory for DallasTemperature. Allows us to instance a new object | |
void* DallasTemperature::operator new(unsigned int size) // Implicit NSS obj size | |
{ | |
void * p; // void pointer | |
p = malloc(size); // Allocate memory | |
memset((DallasTemperature*)p,0,size); // Initalise memory | |
//!!! CANT EXPLICITLY CALL CONSTRUCTOR - workaround by using an init() methodR - workaround by using an init() method | |
return (DallasTemperature*) p; // Cast blank region to NSS pointer | |
} | |
// MnetCS 2009 - Unallocates the memory used by this instance | |
void DallasTemperature::operator delete(void* p) | |
{ | |
DallasTemperature* pNss = (DallasTemperature*) p; // Cast to NSS pointer | |
pNss->~DallasTemperature(); // Destruct the object | |
free(p); // Free the memory | |
} | |
#endif | |
Garan player; | |
Servo servo1; | |
int playerNext(String args) { | |
player.next(); | |
return 0; | |
} | |
int playerStop(String args) { | |
player.stop(); | |
return 0; | |
} | |
int playerVolume(String args) { | |
player.setVolume(args.toInt()); | |
return 0; | |
} | |
int setServo(String args) { | |
servo1.write(args.toInt()); | |
return 0; | |
} | |
int displayTest(String args) { | |
lcd->setCursor(0,0); | |
lcd->print(args); | |
lcd->print(" "); | |
return 0; | |
} | |
void setup() | |
{ | |
lcd = new LiquidCrystal_I2C(0x27, 16, 2); // set the LCD address to 0x20 for a 16x2 //SparkCore bug, address is actually 27 but shifted (0x27*2) | |
lcd->init(); // initialize the lcd | |
lcd->backlight(); | |
lcd->clear(); | |
lcd->setCursor(0,0); | |
lcd->print("---Spark*Core---"); | |
lcd->setCursor(0,1); | |
lcd->print("Uptime:"); | |
Spark.function("next", playerNext); | |
Spark.function("stop", playerStop); | |
Spark.function("display", displayTest); | |
Spark.function("volume", playerVolume); | |
Spark.function("servo", setServo); | |
servo1.attach(A6); | |
servo1.write(90); | |
} | |
void loop() | |
{ | |
lcd->setCursor(7,1); | |
lcd->print((int)(millis()/1000)); | |
delay(200); | |
if((int)(millis()/1000)==10) { | |
player.setVolume(15); | |
setServo("120"); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment