gkone2
Published © GPL3+

KellyKegerator

It measures the beer poured from your kegerator! And reads up to two flow meters and a oneWire temperature sensor.

IntermediateShowcase (no instructions)764
KellyKegerator

Things used in this project

Hardware components

Gems FT-330
×1
ds18B20 OneWire Temp sensor
×1
Adafruit 20x4 LCD
×1
Ethernet breakout
×1

Story

Read more

Schematics

Flow Meter Connections

how the flow meters attach to the beer lines

Code

KellyKeg

Arduino
Main sketch
// include the library code:
#include <LiquidCrystal.h>
#include <avr/interrupt.h>
#include <avr/io.h>
#include <EEPROM.h>
#include "OneWire.h"

#define ONEWIREPIN 1
#define LEFTTAP 2
#define RIGHTTAP 3
#define ENTERBUTTON 5
#define NEXTBUTTON 4
#define FLOWLED 6
#define DEBUGMODE 1

unsigned long startMicros = 0;
unsigned long endMicros = 0;
unsigned long deltaMicros = 0;
unsigned long maxExecutionTime = 0;
unsigned long startMicros_debug = 0;
unsigned long endMicros_debug = 0;
unsigned long deltaMicros_debug = 0;

//initialize EEPROM
const int L_edgesRemaining_EE = 0;  // just a pointer, must save 4 bytes (bytes 0,1,2,3)
const int R_edgesRemaining_EE = 4;  // just a pointer, must save 4 bytes (bytes 4,5,6,7)
const int L_kegSize_EE        = 8;  // just a pointer, must save 4 bytes (bytes 8,9,10,11)
const int R_kegSize_EE        = 12;  // just a pointer, must save 4 bytes (bytes 12,13,14,15)
const int nextAvailEEaddr     = 16;  //not used for now. just so i don't forgot to reserve bytes 13,14, and 15

//declare display vars
volatile bool clearDisp = true;
volatile byte displayPage = 1;
volatile bool refreshData = false;
const int loopsPerSec = 10;
int OneSecondDelayCntr = 0;                   //triggers 1000msec interrupt
signed char ScreenSaverTimer = 0;             //switches displayPage every few seconds to clear screen gibberish //char is signed, byte can NOT be signed...
const int refreshRate = 15624 / loopsPerSec;  //units: counter cycles, 15624 = 1 second (assumes clk/1024 prescaler)

//declare edge counters
volatile int L_edges = 0;
int L_edges_last = 0;
volatile int R_edges = 0;
int R_edges_last = 0;
int L_currPourEdges = 0;
int R_currPourEdges = 0;
long L_totalEdges = 0;
long R_totalEdges = 0;
long L_edgesRemaining = 0;      //have to wait til setup() fcn to update this w/ EEPROM value //must be signed in case keg meter isn't perfectly accurate 
long R_edgesRemaining = 0;      //have to wait til setup() fcn to update this w/ EEPROM value //must be signed in case keg meter isn't perfectly accurate 

//declare flow vars in physical units (pints)
float L_remain = 0;
float R_remain = 0;
float L_poured = 0;
float R_poured = 0;
float currentPour = 0;                                      //for display only
const float pintsScaleFctr = 1289;                         //1289 pulses per pint
const int pintsPerSixthBbl = 41;
const int pintsPerQuarterBbl = 62;
const int pintsPerHalfBbl = 124;
long L_kegSize = 0; //have to wait til setup() fcn to update this w/ EEPROM value 
long R_kegSize = 0; //have to wait til setup() fcn to update this w/ EEPROM value 


bool L_tapOn = false;
int L_tapOnLoops = 0;
byte L_tapOffStabLoops = 0;
byte L_tapOnStabLoops = 0;
bool R_tapOn = false;
int R_tapOnLoops = 0;
byte R_tapOffStabLoops = 0;
byte R_tapOnStabLoops = 0;  
const byte thresh_tapOffStabLoops = 5 * loopsPerSec;      //wait time before clearing tapOn
const byte thresh_tapOnStabLoops  = 1 * loopsPerSec;      //wait time before setting  tapOn
int flowLedFrac = 1023;

//declare global button vars
bool enterBtnPressed = false;
bool nextBtnPressed = false;
bool kegSizeUpdateDone = false; //flag to say user input is received for a new keg's size
bool remPintsUpdateDone = false; //flag to say user input is received for beer left in keg
long newKegSize = 0;            //size of new keg as input by user
long newEdgesRemaining = 0;     //amount of beer left as input by user

//OneWire global variables
OneWire oneWireBus(ONEWIREPIN);
byte oneWireType_s;
byte oneWiredata[9];
byte oneWireAddr[8];
int oneWireTempHex;            //rawTemp used to combine 8 separate data bytes into one big hex number. this is not physical units.
float oneWireTempF;
byte i;

//compressor states - global variables
float minTemp_forDisp; //in degF
float maxTemp_forDisp; //in degF
float compOnMinutes_forDisp;
float compDutyCycle;   //% times 100
bool compDataReady;    //LCD won't display anything until this sets

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(7,8,9,10,11,12);

void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 4);
  lcd.setRowOffsets(0x00, 0x40, 0x14, 0x54);   //fix row offset issue for 16x4 LCD's

  pinMode(LEFTTAP, INPUT_PULLUP);                  //for INT0 interrupt
  pinMode(RIGHTTAP, INPUT_PULLUP);                  //for INT1 interrupt
  pinMode(ENTERBUTTON, INPUT);                   
  pinMode(FLOWLED, OUTPUT);                   
  digitalWrite(FLOWLED, LOW);                 //LOW = off

  //External Interrupt Mask Reg - set bit for INT0
  EIMSK |= (0x03);   //EIMSK = EIMSK | "value of 1 left shifted by INT0 number of places, OR'ed with 1 shifted INT1 number of places"
  //External Interrupt Control Reg - use rising edges
  EICRA |= (0x0F);                            //both interrupts look for a rising edge
  
  //Timer-Counter1 Control Reg A
  TCCR1A = 0;
  //Timer-Counter1 Control Reg B
  TCCR1B = (1<<CS10 | 1<<CS12);               //increment at clock speed/1024
  TCCR1B |=(1<<WGM12);                        //enable clear-on-match mode
  //
  OCR1A = refreshRate;
  //Timer-Counter1 Interrupt Mask Register
  TIMSK1 = (1 << OCIE1A);                     //enable compare interrupt

  delay(1000/loopsPerSec);                    //avoid false interrupts at init
  sei(); //enable global interrupts, must be after EICRA configuration

  //read EEPROM & initialize to those values
  EEPROM.get(L_edgesRemaining_EE, L_edgesRemaining);  //get the EE value and write it to the volatile variable
  EEPROM.get(R_edgesRemaining_EE, R_edgesRemaining);  //get the EE value and write it to the volatile variable
  EEPROM.get(L_kegSize_EE, L_kegSize);                //get the EE value and write it to the volatile variable
  EEPROM.get(R_kegSize_EE, R_kegSize);                //get the EE value and write it to the volatile variable
}

ISR(INT0_vect){  //flow sensor ISR
  L_edges++;
}

ISR(INT1_vect){   //RIGHTTAP ISR
  R_edges++;
}

ISR(TIMER1_COMPA_vect){
  refreshData = true; //to be cleared when refreshData() function has completed
  
  /*once per each precise timer interrupt, save away the number of edges 
   * in that time window & let background task use that. Reset edge counter
   * immediately. background task will have "refreshRate" number of
   * milliseconds to process the data and catch up */
  L_edges_last = L_edges; 
  L_edges = 0;
  R_edges_last = R_edges; 
  R_edges = 0;
}

void loop() {
  startMicros = micros();
  DebounceButtons();
  oneWireFunctions();
  if (refreshData){               //called once per TMR1 interrupt
    UpdateEdgeCounters();
    UpdateDisplay();
    refreshData = false;

    //1 second interrupt
    if (OneSecondDelayCntr == loopsPerSec){
      ProcCompressorStats();        //don't need to do this fast, so put in in the slow execution loop.
      OneSecondDelayCntr = 0;
      ScreenSaverTimer++;           //increment once per second. other functions will reset this (buttons, edge counts, etc reset it)
    }
    OneSecondDelayCntr++;           //increment counter every refreshData loop, whether it was reset or not
    
    //compute processor load
    endMicros = micros();
    deltaMicros = endMicros - startMicros;
    maxExecutionTime = max(deltaMicros,maxExecutionTime);
  }
}

void UpdateDisplay(void){
  if (clearDisp){
    lcd.clear(); //clear LCD before switching pages
    lcd.noBlink();  //in case power surge changes lcd blink to on
    clearDisp = false;
  }

  switch(displayPage){
    case 1:                                 //page 1 - statistics  
      lcd.setCursor(0, 0); lcd.print(oneWireTempF,0); lcd.print((char)0xDF); lcd.print("F"); //degress symbol
      lcd.setCursor(7, 0); lcd.print("Left:  Right:"); 
      
      lcd.setCursor(0, 1); lcd.print("Drank:  ");
      lcd.setCursor(8, 1); lcd.print(L_poured, 1); 
      lcd.setCursor(15, 1); lcd.print(R_poured, 1);
      
      lcd.setCursor(0, 2); lcd.print("Remain: ");
      lcd.setCursor(8, 2); lcd.print(L_remain, 1);
      lcd.setCursor(15, 2); lcd.print(R_remain, 1);
      
      lcd.setCursor(0, 3); lcd.print("This Pour:");
      lcd.setCursor(11, 3); lcd.print(currentPour, 3);
      if (enterBtnPressed){
        enterBtnPressed = false;
        nextBtnPressed = false;
        displayPage++;
        clearDisp = true;
      }
      else if (ScreenSaverTimer >= 60){  //send screensaver diectly to page 2 after a certain number of seconds
        ScreenSaverTimer = 0;
        displayPage = 2;
        clearDisp = true;
      }
      break;
    
    case 2:
      lcd.setCursor(0, 0); lcd.print("Compressor Stats");
       
      lcd.setCursor(0, 1); lcd.print("On Time:");
      if(compDataReady){
        lcd.setCursor(9, 1); lcd.print(compOnMinutes_forDisp,1);
        lcd.setCursor(13, 1); lcd.print("minutes");
      }
      
      lcd.setCursor(0, 2); lcd.print("Duty Cycle:");
      if(compDataReady){
        lcd.setCursor(12, 2); lcd.print(compDutyCycle,1);
        lcd.setCursor(17, 2); lcd.print((char)0x25);          // % symbol
      }     
      
      lcd.setCursor(0, 3); lcd.print("Max:");
      if(compDataReady){lcd.setCursor(4, 3); lcd.print(maxTemp_forDisp,1); lcd.print((char)0xDF);}
      lcd.setCursor(10, 3); lcd.print("Min:");
      if(compDataReady){lcd.setCursor(14, 3); lcd.print(minTemp_forDisp,1); lcd.print((char)0xDF);}
      
      if (enterBtnPressed){
        enterBtnPressed = false;
        nextBtnPressed = false;
        displayPage++;
        clearDisp = true;
      }
      else if (ScreenSaverTimer >= 5){  //send screensaver diectly to page 3 after a certain number of seconds
        ScreenSaverTimer = 0;
        displayPage = 3;
        clearDisp = true;
      }
      break;
    
    case 3:                                 //page 2 - flow rate check
      lcd.setCursor(0, 0); lcd.print("Hola Heather!");
      //lcd.setCursor(2, 2); lcd.print(" - - - 8=====D - - - "); lcd.print((char)0xE3);  //ascii penis
      lcd.setCursor(16, 0); lcd.print((char)0x2A);
      lcd.setCursor(15, 1); lcd.print("/ "); lcd.print((char)0x60);                      //or ascii wedding ring
      lcd.setCursor(14, 2); lcd.print("(   )");
      lcd.setCursor(15, 3); lcd.print((char)0x60); lcd.print("_/");
      if (enterBtnPressed){
        enterBtnPressed = false;
        nextBtnPressed = false;
        displayPage++;
        clearDisp = true;
      }
      else if (ScreenSaverTimer >= 5){  //send screensaver diectly to page 6 after a certain number of seconds
        ScreenSaverTimer = 0;          //skip pages 4 and 5 w/ screen saver so that we don't interrupt a user
        displayPage = 6;               //trying to reprogram the device
        clearDisp = true;
      }      
      break;  

    case 4:
      ProcessKegSizePage();             //give this it's own file since there's a lot to it
      break;

    case 5:
      ProcessEditRemnPage();             //give this it's own file since there's a lot to it
      break;

    case 6: //onewire data
      lcd.setCursor(0, 0); lcd.print("OneWire Bus");
      lcd.setCursor(0, 1); lcd.print("a:");
      for( i = 0; i < sizeof(oneWireAddr); i++) {
        if (oneWireAddr[i] < 16){
          lcd.print(0);  //print leading zero if hex is one digit
        }
        lcd.print(String(oneWireAddr[i],HEX));
      }
      lcd.setCursor(0, 2); lcd.print("d:");
      for( i = 0; i < sizeof(oneWiredata); i++) {
        if (oneWiredata[i] < 16){
          lcd.print(0);  //print leading zero if hex is one digit
        }
        lcd.print(String(oneWiredata[i],HEX));
      }
      lcd.setCursor(0, 3); lcd.print("temp:"); lcd.print(oneWireTempF,4);
      
      if (enterBtnPressed){
        enterBtnPressed = false;
        nextBtnPressed = false;
        displayPage++;
        clearDisp = true;
      }
      else if (ScreenSaverTimer >= 5){  //send screensaver diectly to default page after a certain number of seconds
        ScreenSaverTimer = 0;
        displayPage = 7; //default page
        clearDisp = true;
      }   
      break;
          
    default:                             //make CPU stats the last page
      lcd.setCursor(0, 0); lcd.print("Proccessor Stats");
      
      lcd.setCursor(0, 1); lcd.print("LoopTm:");
      lcd.setCursor(8, 1); lcd.print(maxExecutionTime);
      lcd.setCursor(15, 1); lcd.print((char)0xE4); lcd.print("s");  //microsec
      
      lcd.setCursor(0, 2); lcd.print("Utilz:");
      lcd.setCursor(8, 2); lcd.print((loopsPerSec*(float)maxExecutionTime/10000)); //float to allow decimals
      lcd.setCursor(15, 2); lcd.print((char)0x25); //%
  
      lcd.setCursor(0, 3); lcd.print("DebugTmr:");
      lcd.setCursor(9, 3); lcd.print(deltaMicros_debug);
      
      if (enterBtnPressed){
        enterBtnPressed = 0;
        displayPage = 1;                      //return to first page if button pressed on last pg
        clearDisp = true;
      }
      else if (ScreenSaverTimer >= 5){  //send screensaver diectly to default page after a certain number of seconds
        ScreenSaverTimer = 0;
        displayPage = 1; //default page
        clearDisp = true;
      }   
      break; 
  }
}

DebounceButtons

Arduino
void DebounceButtons(void){   //this fcn just handles deboucing, not actions taken for the press
static bool button1;      //local var
static bool button1_last; //debounced state
static bool button1_prev;  //just one sw loop prior, not debounced
static bool button2;      //local var
static bool button2_last; //debounced state
static bool button2_prev;  //just one sw loop prior, not debounced
static long startMillis = millis();
const long debounceTime = 20; //msec since last switch edge
  
  //button 1
  button1_prev = button1;                       //save value from last s/w loop
  button1 = digitalRead(ENTERBUTTON);
  if (button1 != button1_prev) {
    startMillis= millis();                      //reset debounce timer
  }
  if (button1){
    if ((millis() - startMillis) > debounceTime){ //if debounced
      if (!button1_last){
        button1_last = true;    //internal state flag used only for debouncing the release of the button
        enterBtnPressed = true; //global flag used for routines to take action, will be cleared by routines
        ScreenSaverTimer = -55;   //delay screensaver an addition minute when user is interacting with the device
      }
    }
  }
  else { //else button1 == 0
    if ((millis() - startMillis) > debounceTime){ //debounce
      button1_last = false;
    }
  }
  
  //button 2
  button2_prev = button2;                       //save value from last s/w loop
  startMicros_debug = micros();
  button2 = digitalRead(NEXTBUTTON);
  endMicros_debug = micros();
  deltaMicros_debug = endMicros_debug - startMicros_debug;
  if (button2 != button2_prev) {
    startMillis= millis();                      //reset debounce timer
  }
  if (button2){
    if ((millis() - startMillis) > debounceTime){ //if debounced
      if (!button2_last){
        button2_last = true;   //internal state flag used only for debouncing the release of the button
        nextBtnPressed = true; //global flag used for routines to take action, will be cleared by routines
        ScreenSaverTimer = -55;   //delay screensaver an addition minute when user is interacting with the device
      }
    }
  }
  else { //else button2 == 0
    if ((millis() - startMillis) > debounceTime){ //debounce
      button2_last = false;
    }
  }
}

oneWireFunctions

Arduino
custom code to interface with the standard OneWire Library
#define MAX_CONVERSION_TIME 1000

void oneWireFunctions(void){
  static bool oneWireInitialized;
  static long conversionStartMillis;
  static bool conversionInProgress;
  byte i;

  //search one time for an address. if found, search() fcn
  //returns 1 and writes device ID to oneWireAddr pointer
  if (!oneWireInitialized) {
    oneWireInitialized = oneWireBus.search(oneWireAddr);
    /*address response is as follows:
     * B0 - sensor type (0x28 == DS18B20 temp sensor
     * B1-B6 - serial number
     * B7 - checksum
     */
    return;                             //don't move on until sensor is found
  }

  if (!conversionInProgress){           //if not converting, start converting!
    oneWireBus.reset();                 //do reset before reading any device, if you don't then you're gonna have a bad time
    oneWireBus.select(oneWireAddr);     //select the only sensor, but protect for more later
    oneWireBus.write(0x44);             //0x44 tells the device to perform a temperature conversion internally
                                        /*during write, master pulls pin low for 10uS, then high for 55uS to send a 1
                                         * to send a 0, master pulls pin low for 65uS, then high for 5uS
                                         */
    conversionInProgress = true;
    conversionStartMillis = millis();
    return;
  }
  else{                                 //else conversion is ongoing. may take up to 1000msec
    //if we can reasonably expect the conversion to have finshed
    if ( (millis() - conversionStartMillis) > MAX_CONVERSION_TIME ){
      oneWireBus.reset();                 //do reset before reading any device, if you don't then you're gonna have a bad time
      oneWireBus.select(oneWireAddr);     //select the only sensor, but protect for more later
      oneWireBus.write(0xBE);             // 0xBE tells the device to send the data in it's 9-byte 'scratchpad' memory
      for ( i = 0; i < 9; i++) {          // we need 9 bytes
        oneWiredata[i] = oneWireBus.read();
        /*during read command, master pulls pin low for 3uS, then let's pin 'float' knowing 
         * pullup will raise pin high. device will either leave pin high to signify a high bit,
         * or pull the pin low within 10 uS to signify a low bit. then delay at least 53uS and repeat.
         * 
         * Data response is as follows:
         * B0 - temperature LSB, bit0 is lowest bit
         * B1 - temperature MSB, only bits 0-2 are used on DS18B20
         * B2 - high temp alarm limit
         * B3 - low temp alarm limit
         * B4 - resolution configuration register
         * B5, B6, B7 - reserved
         * B8 - checksum
        */
        oneWireTempHex = (oneWiredata[1] << 8) | oneWiredata[0];   //shift MSB up and then OR with LSB to get a single 2byte number                  
        oneWireTempF = hex2degF(oneWireTempHex);
      }
      
      conversionInProgress = false;
    }
    //else just wait for conversion to finish
  }
}

float hex2degF(int hexTemp){
  return ( ((float)hexTemp/16) * 9/5) + 32;  //default scaling on the temp sensor is 1/16th degC, then convert to Farenheit
}

int degF2hex(float degFtemp){
  return (int)(((degFtemp + 32) * 5/9) * 16);
}

ProcCompressorStats

Arduino
process compressor on/off time statistics
#define ON true
#define OFF false

void ProcCompressorStats(void){    //this function is called once per second
  const int compHysteresis = (int)((float) 2/*degF*/ * 5/9 * 16); /* This is the threshold you have to rise
                                    *above the min or sink below the max to know the compressor
                                    *changed state. the math converts degF -> degC -> hex*/
  static int maxTemp;          //hottest temp reached the last time the compressor was off
  static int minTemp;          //coldest temp reached the last time the compressor was on
  static int compOnSeconds;       //in units of seconds since this function is called once per second
  static int compOffSeconds;      //in units of seconds since this function is called once per second
  static byte initWaitTmr;
  static bool initDone;
  static bool compressorState;      //0 = off, 1=on.

  if(!initDone){
    if (initWaitTmr >= 2){             //initialize, need to wait for oneWire sensor to send first reading
      maxTemp = oneWireTempHex;
      minTemp = oneWireTempHex;
      compressorState = OFF;        // assume off at initialization
      initDone = true;
    } else {initWaitTmr++;}
  }

  if (compressorState){         //if compressor is on, cooling down
    compOnSeconds++;
    minTemp = min(minTemp, oneWireTempHex);

    if( (oneWireTempHex - minTemp) > compHysteresis){ //compressor has turned off since temp is rising
      //Process cycle stats now
      minTemp_forDisp       = hex2degF(minTemp);         //for display, latch thru next cycle and convert to degreesF
      maxTemp_forDisp       = hex2degF(maxTemp);         //for display, latch thru next cycle and convert to degreesF
      compOnMinutes_forDisp = (float)compOnSeconds/60;   //convert to minutes
      compDutyCycle         = (float)compOnSeconds/(compOnSeconds + compOffSeconds) * 100;
      compDataReady         = true;                      //nothing will be displayed on LCD until this bit sets
      
      //prepare for compressor OFF state
      compressorState = OFF;
      compOffSeconds = 0;           //reset so it can start incrementing again
      maxTemp = oneWireTempHex;  //reset so it can find a new max next cycle
    }
  }
  else{                         //else compressor is off, warming up
    compOffSeconds++;
    maxTemp = max(maxTemp, oneWireTempHex);
    
    if( (maxTemp - oneWireTempHex) > compHysteresis){ //compressor has turned on since temp is falling
      //prepare for compressor ON state
      compressorState = ON;
      compOnSeconds = 0; //reset so it can start incrementing again
      minTemp = oneWireTempHex;  //reset so it can find a new min next cycle
    }
  }
  //debug
//  minTemp_forDisp =  hex2degF(minTemp);
//  maxTemp_forDisp =  hex2degF(maxTemp);
//  compDataReady = true;
}

ProcessEditRemnPage

Arduino
Process "Edit Remaining Beer" page
void ProcessEditRemnPage(void){
  static int localPointer;
  static bool getRemPintsState;   //latch state while waiting for user input

  if (enterBtnPressed || getRemPintsState){  //always call while waiting 
    if (!getRemPintsState){
      enterBtnPressed = 0;          //if running getRemainingPints() fcn, pass enter button along to it, else reset it here
      newEdgesRemaining = 0;        //reinitialize to zero
      clearDisp = true;
    }
    switch (localPointer){
      case 1:                         //return to main menu
        displayPage++;
        clearDisp = true;
        break;

      case 2:                         //reset left keg EEPROM
      getRemPintsState = true;
      getRemainingPints(); 
      if (remPintsUpdateDone){
        EEPROM.put(L_edgesRemaining_EE, newEdgesRemaining);
        L_edgesRemaining = newEdgesRemaining;
        remPintsUpdateDone = false;
        getRemPintsState = false;
        displayPage = 1; //return to home
        localPointer = 0;                //reset for next time you come to this page
        clearDisp = true;
      }
      if (displayPage == 1){ //if user pressed cancel inside the getRemainingPints() fcn
        localPointer = 0;
        getRemPintsState = false;
      }
      return; //skip display update logic below, let getRemainingPints() function control display
      
      case 3:                         //reset right keg EEPROM
      getRemPintsState = true;
      getRemainingPints(); 
      if (remPintsUpdateDone){
        EEPROM.put(R_edgesRemaining_EE, newEdgesRemaining);
        R_edgesRemaining = newEdgesRemaining;
        remPintsUpdateDone = false;
        getRemPintsState = false;
        displayPage = 1; //return to home
        localPointer = 0;                //reset for next time you come to this page
        clearDisp = true;
      }
      if (displayPage == 1){ //if user pressed cancel inside the getRemainingPints() fcn
        localPointer = 0;
        getRemPintsState = false;
      }
      return; //skip display update logic below, let getRemainingPints() function control display
    }
  }

  //set up display for next loop - must be after reading enterBtn
  lcd.setCursor(0, 0); lcd.print("EDIT # OF PINTS LEFT"); 
  lcd.setCursor(1, 1); lcd.print("Return to main menu"); 
  lcd.setCursor(1, 2); lcd.print("Edit Left Keg?"); 
  lcd.setCursor(1, 3); lcd.print("Edit Right Keg?");

  if (nextBtnPressed && localPointer != 0){            //don't advance pointer when first entering this state
    nextBtnPressed = false;
    localPointer++;
    clearDisp = true;
  }
  if (localPointer > 3 || localPointer < 1){
    localPointer = 1;                                  //overflow protect
    clearDisp = true;
  }

  lcd.setCursor(0, localPointer); lcd.print((char)0x7E); //arrow pointer character 
}

void getRemainingPints(void){                //prompt user to input keg size
  static int remPintsPointer;
  static byte remPintsByte1; //100's
  static byte remPintsByte2; // 10's
  static byte remPintsByte3; //  1's
  static byte remPintsByte4; //0.1's

  remPintsUpdateDone = false;
  if (nextBtnPressed){
    nextBtnPressed = 0;
    switch (remPintsPointer){
      case 0:                         //100's
          remPintsByte1 = remPintsByte1 + 1;
          if (remPintsByte1 > 9){     //overflow protection
            remPintsByte1 = 0;
          }
        break;
      case 1:                         // 10's
          remPintsByte2++;
          if (remPintsByte2 > 9){     //overflow protection
            remPintsByte2 = 0;
          }
        break;
        
      case 2:                         // 1's
          remPintsByte3++;
          if (remPintsByte3 > 9){     //overflow protection
            remPintsByte3 = 0;
          }
        break;

      case 4:                         // 0.1's
          remPintsByte4++;
          if (remPintsByte4 > 9){     //overflow protection
            remPintsByte4 = 0;
          }
        break;
      case 5:                        //user pressed cancel
        displayPage = 1; //return to home
        clearDisp = true;
        break;
    }
  }

  if (enterBtnPressed){
    enterBtnPressed = false;
    remPintsPointer++;
    if (remPintsPointer == 3){
      remPintsPointer++; //skip the decimal character
    }
    else if (remPintsPointer > 5){  //process entry & return
      newEdgesRemaining = pintsScaleFctr * remPintsByte1 * 100 +
                          pintsScaleFctr * remPintsByte2 * 10 + 
                          pintsScaleFctr * remPintsByte3 * 1  + 
                          pintsScaleFctr * remPintsByte4 / 10;
      remPintsUpdateDone = true;
      remPintsPointer = 0;
      remPintsByte1 = 0; //100's
      remPintsByte2 = 0; // 10's
      remPintsByte3 = 0; //  1's
      remPintsByte4 = 0;
      return;
    }
    clearDisp = true;
  }

    //set up display for next loop - must be after reading enterBtn
  lcd.setCursor(0, 0); lcd.print("How many pints left?"); 
  lcd.setCursor(1, 1); lcd.print(remPintsByte1); lcd.print(remPintsByte2); 
  lcd.print(remPintsByte3); lcd.print("."); lcd.print(remPintsByte4); 
  lcd.setCursor(7, 1); lcd.print("pints");
  if (remPintsPointer > 4){
    lcd.noBlink();                   //turn off the blinking       
    lcd.setCursor(0, 2); lcd.print("Press Enter to save,");
    lcd.setCursor(0, 3); lcd.print("select to Cancel");  
  }
  else{  
    lcd.blink();
    lcd.setCursor(remPintsPointer+1,1);
  }
}

ProcessKegSizePage

Arduino
Process "Edit Keg Size" screen
void ProcessKegSizePage(void){
  static int localPointer;
  static bool getKegSizeState;   //latch state while waiting for user input

  if (enterBtnPressed || getKegSizeState){  //always call while waiting 
    if (!getKegSizeState){
      enterBtnPressed = 0;          //if running "getKegSize" fcn, pass enter button along to it, else reset it here
    }
    switch (localPointer){
      case 1:                         //return to main menu
        displayPage++;
        clearDisp = true;
        break;

      case 2:                         //reset left keg EEPROM
      getKegSizeState = true;
      getKegSize(); 
      if (kegSizeUpdateDone){
        EEPROM.put(L_kegSize_EE, newKegSize);         //save size
        EEPROM.put(L_edgesRemaining_EE, newKegSize);         //save size
        L_kegSize = newKegSize;
        L_edgesRemaining = newKegSize;
        kegSizeUpdateDone = false;
        getKegSizeState = false;
        displayPage = 1; //return to home
        localPointer = 0;                //reset for next time you come to this page
        clearDisp = true;
      }
      return;  //skip display update logic below, let getKegSize() function control display

      case 3:                         //reset right keg EEPROM
      getKegSizeState = true;
      getKegSize(); 
      if (kegSizeUpdateDone){
        EEPROM.put(R_kegSize_EE, newKegSize);         //save size
        EEPROM.put(R_edgesRemaining_EE, newKegSize);         //save size
        R_kegSize = newKegSize;
        R_edgesRemaining = newKegSize;
        kegSizeUpdateDone = false;
        getKegSizeState = false;
        displayPage = 1; //return to home
        localPointer = 0;                //reset for next time you come to this page
        clearDisp = true;
      }
      return;  //skip display update logic below, let getKegSize() function control display
    }    
  }

  //set up display for next loop - must be after reading enterBtn
  lcd.setCursor(0, 0); lcd.print("CHANGE KEG SIZE"); 
  lcd.setCursor(1, 1); lcd.print("Return to main menu"); 
  lcd.setCursor(1, 2); lcd.print("Resize Left Keg?"); 
  lcd.setCursor(1, 3); lcd.print("Resize Right Keg?");

  if (nextBtnPressed && localPointer != 0){            //don't advance pointer when first entering this state
    nextBtnPressed = false;
    localPointer++;
    clearDisp = true;
  }
  if (localPointer > 3 || localPointer < 1){
    localPointer = 1;                                  //overflow protect
    clearDisp = true;
  }

  lcd.setCursor(0, localPointer); lcd.print((char)0x7E); //arrow pointer character
}

void getKegSize(void){                //prompt user to input keg size
  static int kegSizePointer;

  kegSizeUpdateDone = false;
  if (enterBtnPressed){
    enterBtnPressed = 0;
    switch (kegSizePointer){
      case 1:                         // 1/6 BBL
        newKegSize = pintsPerSixthBbl * pintsScaleFctr;    //size in total edges
        clearDisp = true;
        kegSizeUpdateDone = true;
        break;

      case 2:                         // 1/4 BBL
        newKegSize = pintsPerQuarterBbl * pintsScaleFctr;    //size in total edges
        clearDisp = true;
        kegSizeUpdateDone = true;
        break;
        
      case 3:                         // 1/2 BBL
        newKegSize = pintsPerHalfBbl * pintsScaleFctr;    //size in total edges
        clearDisp = true;
        kegSizeUpdateDone = true;
        break;
    }
    kegSizePointer = 0;    //reset for next time you come to this page
    return;                //skip display update logic below
  }
  
  //set up display for next loop - must be after reading enterBtn
  lcd.setCursor(0, 0); lcd.print("How big is new keg?"); 
  lcd.setCursor(1, 1); lcd.print("1/6 BBL (41 pints)"); 
  lcd.setCursor(1, 2); lcd.print("1/4 BBL (62 pints)"); 
  lcd.setCursor(1, 3); lcd.print("1/2 BBL (124 pints)");

  if (nextBtnPressed && kegSizePointer != 0){            //don't advance pointer when first entering this state
    nextBtnPressed = false;
    kegSizePointer++;
    clearDisp = true;
  }
  if (kegSizePointer > 3 || kegSizePointer < 1){
    kegSizePointer = 1;                                  //overflow protect
    clearDisp = true;
  }

  lcd.setCursor(0, kegSizePointer); lcd.print((char)0x7E); //arrow pointer character
}

UpdateEdgeCounters

Arduino
Count the beer that's flowing!
void UpdateEdgeCounters(){ //state machine...
//Left Tap
  if (L_edges_last > 0){                      //if beer is flowing
    L_currPourEdges += L_edges_last;          //don't miss a drop!
    if (L_tapOn){                             //if beer was flowing before
      L_tapOnLoops++;
      L_tapOffStabLoops = 0;
    }
    else{                                    //else state just transitioned to tap on - use stab tmr
      L_tapOnStabLoops++;
      if ((displayPage != 4) && (displayPage != 5) && (displayPage != 1)){ //switch back to main screen only
        displayPage = 1;                                                   //if user isn't editing keg info
        clearDisp = true;                                                  //or it's already on page 1
        ScreenSaverTimer = 0;   //don't use screen saver if user is interacting with the device
      }
      if (L_tapOnStabLoops > thresh_tapOnStabLoops){
        L_tapOn = true;
        //L_tapOffStabLoops was reset before
        R_currPourEdges = 0;  //reset so it doesn't compete for the display space
        analogWrite(FLOWLED, 255);
        clearDisp = true;   
      }
      else{
        if (L_tapOnStabLoops < 2){
          L_currPourEdges = 0;              //don't clear til next pour starts
        }
      }
    }
  }
  else{                                     //else beer not flowing, but wait before clearing bit
    if (L_tapOn){
      L_tapOffStabLoops++;
      flowLedFrac = 255*L_tapOffStabLoops/thresh_tapOffStabLoops;
      analogWrite(FLOWLED, (255-flowLedFrac) );
      if (L_tapOffStabLoops > thresh_tapOffStabLoops){
        L_tapOn = false; 
        L_tapOffStabLoops = 0;
        L_tapOnLoops = 1;                 //clear
        digitalWrite(FLOWLED, LOW);
        EEPROM.put(L_edgesRemaining_EE, L_edgesRemaining);  //save new value in case power is lost
        clearDisp = true;                   
      }
    }
    else{
      L_tapOnStabLoops = 0;
    }
  }

//Right Tap
  if (R_edges_last > 0){                      //if beer is flowing
    R_currPourEdges += R_edges_last;          //don't miss a drop!
    if (R_tapOn){                             //if beer was flowing before
      R_tapOnLoops++;
      R_tapOffStabLoops = 0;
    }
    else{                                    //else state just transitioned to tap on - use stab tmr
      R_tapOnStabLoops++;
      if ((displayPage != 4) && (displayPage != 5) && (displayPage != 1)){ //switch back to main screen only
        displayPage = 1;                                                   //if user isn't editing keg info
        clearDisp = true;                                                  //or it's already on page 1
        ScreenSaverTimer = 0;   //don't use screen saver if user is interacting with the device
      }
      if (R_tapOnStabLoops > thresh_tapOnStabLoops){
        R_tapOn = true;
        //R_tapOffStabLoops was reset before
        L_currPourEdges = 0;  //reset so it doesn't compete for the display space
        analogWrite(FLOWLED, 255);
        clearDisp = true;   
      }
      else{
        if (R_tapOnStabLoops < 2){
          R_currPourEdges = 0;              //don't clear til next pour starts
        }
      }
    }
  }
  else{                                     //else beer not flowing, but wait before clearing bit
    if (R_tapOn){
      R_tapOffStabLoops++;
      flowLedFrac = 255*R_tapOffStabLoops/thresh_tapOffStabLoops;
      analogWrite(FLOWLED, (255-flowLedFrac) );
      if (R_tapOffStabLoops > thresh_tapOffStabLoops){
        R_tapOn = false; 
        R_tapOffStabLoops = 0;
        R_tapOnLoops = 1;                 //clear
        digitalWrite(FLOWLED, LOW);
        EEPROM.put(R_edgesRemaining_EE, R_edgesRemaining);  //save new value in case power is lost
        clearDisp = true;                   
      }
    }
    else{
      R_tapOnStabLoops = 0;
    }
  }

//convert edges to physical units
  L_edgesRemaining -= L_edges_last;
  L_totalEdges = L_kegSize - L_edgesRemaining;
  L_poured = (float)L_totalEdges / pintsScaleFctr;
  L_remain = (float)L_edgesRemaining / pintsScaleFctr;

  R_edgesRemaining -= R_edges_last;
  R_totalEdges = R_kegSize - R_edgesRemaining;
  R_poured = (float)R_totalEdges / pintsScaleFctr;
  R_remain = (float)R_edgesRemaining / pintsScaleFctr;
  currentPour = max((float)R_currPourEdges,(float)L_currPourEdges) / pintsScaleFctr; 
}

OneWire.cpp

C/C++
standard library
/*
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.
//--------------------------------------------------------------------------
*/

#include "OneWire.h"


OneWire::OneWire(uint8_t pin)
{
	pinMode(pin, INPUT);
	bitmask = PIN_TO_BITMASK(pin);
	baseReg = PIN_TO_BASEREG(pin);
#if ONEWIRE_SEARCH
	reset_search();
#endif
}


// 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)
{
	IO_REG_TYPE mask = bitmask;
	volatile IO_REG_TYPE *reg IO_REG_ASM = baseReg;
	uint8_t r;
	uint8_t retries = 125;

	noInterrupts();
	DIRECT_MODE_INPUT(reg, mask);
	interrupts();
	// wait until the wire is high... just in case
	do {
		if (--retries == 0) return 0;
		delayMicroseconds(2);
	} while ( !DIRECT_READ(reg, mask));

	noInterrupts();
	DIRECT_WRITE_LOW(reg, mask);
	DIRECT_MODE_OUTPUT(reg, mask);	// drive output low
	interrupts();
	delayMicroseconds(480);
	noInterrupts();
	DIRECT_MODE_INPUT(reg, mask);	// allow it to float
	delayMicroseconds(70);
	r = !DIRECT_READ(reg, mask);
	interrupts();
	delayMicroseconds(410);
	return r;
}

//
// Write a bit. Port and bit is used to cut lookup time and provide
// more certain timing.
//
void OneWire::write_bit(uint8_t v)
{
	IO_REG_TYPE mask=bitmask;
	volatile IO_REG_TYPE *reg IO_REG_ASM = baseReg;

	if (v & 1) {
		noInterrupts();
		DIRECT_WRITE_LOW(reg, mask);
		DIRECT_MODE_OUTPUT(reg, mask);	// drive output low
		delayMicroseconds(10);
		DIRECT_WRITE_HIGH(reg, mask);	// drive output high
		interrupts();
		delayMicroseconds(55);
	} else {
		noInterrupts();
		DIRECT_WRITE_LOW(reg, mask);
		DIRECT_MODE_OUTPUT(reg, mask);	// drive output low
		delayMicroseconds(65);
		DIRECT_WRITE_HIGH(reg, mask);	// 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)
{
	IO_REG_TYPE mask=bitmask;
	volatile IO_REG_TYPE *reg IO_REG_ASM = baseReg;
	uint8_t r;

	noInterrupts();
	DIRECT_MODE_OUTPUT(reg, mask);
	DIRECT_WRITE_LOW(reg, mask);
	delayMicroseconds(3);
	DIRECT_MODE_INPUT(reg, mask);	// let pin float, pull up will raise
	delayMicroseconds(10);
	r = DIRECT_READ(reg, mask);
	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(baseReg, bitmask);
	DIRECT_WRITE_LOW(baseReg, bitmask);
	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(baseReg, bitmask);
    DIRECT_WRITE_LOW(baseReg, bitmask);
    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(baseReg, bitmask);
	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"
//

#if ONEWIRE_CRC8_TABLE
// This table comes from Dallas sample code where it is freely reusable,
// though Copyright (C) 2000 Dallas Semiconductor Corporation
static const uint8_t PROGMEM dscrc_table[] = {
      0, 94,188,226, 97, 63,221,131,194,156,126, 32,163,253, 31, 65,
    157,195, 33,127,252,162, 64, 30, 95,  1,227,189, 62, 96,130,220,
     35,125,159,193, 66, 28,254,160,225,191, 93,  3,128,222, 60, 98,
    190,224,  2, 92,223,129, 99, 61,124, 34,192,158, 29, 67,161,255,
     70, 24,250,164, 39,121,155,197,132,218, 56,102,229,187, 89,  7,
    219,133,103, 57,186,228,  6, 88, 25, 71,165,251,120, 38,196,154,
    101, 59,217,135,  4, 90,184,230,167,249, 27, 69,198,152,122, 36,
    248,166, 68, 26,153,199, 37,123, 58,100,134,216, 91,  5,231,185,
    140,210, 48,110,237,179, 81, 15, 78, 16,242,172, 47,113,147,205,
     17, 79,173,243,112, 46,204,146,211,141,111, 49,178,236, 14, 80,
    175,241, 19, 77,206,144,114, 44,109, 51,209,143, 12, 82,176,238,
     50,108,142,208, 83, 13,239,177,240,174, 76, 18,145,207, 45,115,
    202,148,118, 40,171,245, 23, 73,  8, 86,180,234,105, 55,213,139,
     87,  9,235,181, 54,104,138,212,149,203, 41,119,244,170, 72, 22,
    233,183, 85, 11,136,214, 52,106, 43,117,151,201, 74, 20,246,168,
    116, 42,200,150, 21, 75,169,247,182,232, 10, 84,215,137,107, 53};

//
// Compute a Dallas Semiconductor 8 bit CRC. These show up in the ROM
// and the registers.  (note: this might better be done without to
// table, it would probably be smaller and certainly fast enough
// compared to all those delayMicrosecond() calls.  But I got
// confused, so I use this table from the examples.)
//
uint8_t OneWire::crc8(const uint8_t *addr, uint8_t len)
{
	uint8_t crc = 0;

	while (len--) {
		crc = pgm_read_byte(dscrc_table + (crc ^ *addr++));
	}
	return crc;
}
#else
//
// Compute a Dallas Semiconductor 8 bit CRC directly.
// this is much slower, but much smaller, than the lookup table.
//
uint8_t OneWire::crc8(const 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

#endif

OneWire.h

C/C++
standard library
#ifndef OneWire_h
#define OneWire_h

#include <inttypes.h>

#if ARDUINO >= 100
#include "Arduino.h"       // for delayMicroseconds, digitalPinToBitMask, etc
#else
#include "WProgram.h"      // for delayMicroseconds
#include "pins_arduino.h"  // for digitalPinToBitMask, etc
#endif

// You can exclude certain features from OneWire.  In theory, this
// might save some space.  In practice, the compiler automatically
// removes unused code (technically, the linker, using -fdata-sections
// and -ffunction-sections when compiling, and Wl,--gc-sections
// when linking), so most of these will not result in any code size
// reduction.  Well, unless you try to use the missing features
// and redesign your program to not need them!  ONEWIRE_CRC8_TABLE
// is the exception, because it selects a fast but large algorithm
// or a small but slow algorithm.

// 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

// Select the table-lookup method of computing the 8-bit CRC
// by setting this to 1.  The lookup table enlarges code size by
// about 250 bytes.  It does NOT consume RAM (but did in very
// old versions of OneWire).  If you disable this, a slower
// but very compact algorithm is used.
#ifndef ONEWIRE_CRC8_TABLE
#define ONEWIRE_CRC8_TABLE 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

// Platform specific I/O definitions

#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))

#elif defined(__MK20DX128__)
#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 OneWire
{
  private:
    IO_REG_TYPE bitmask;
    volatile IO_REG_TYPE *baseReg;

#if ONEWIRE_SEARCH
    // global search state
    unsigned char ROM_NO[8];
    uint8_t LastDiscrepancy;
    uint8_t LastFamilyDiscrepancy;
    uint8_t LastDeviceFlag;
#endif

  public:
    OneWire( uint8_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(const 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

Credits

gkone2

gkone2

1 project • 0 followers

Comments