Posted on Tuesday, August 18, 2015 - 08:28 am:

---

quote:

I wish it was a trivial task to add a cylinder head temperature display to my 08XT.

---

Posted on Monday, August 31, 2015 - 09:58 pm:

 
// Thermocouple 
// Bill@KilgallonFamily.com 
// Revision 1.0, 2015/08/31 
 
// This program uses the LiquidCrystal_I2C library, which is 
// different (and much richer) than the one that came in  
// the SunFounder kit CD.   
// To install and use this new library (at least what I had to do today) 
// Go to https://bitbucket.org/fmalpartida/new-liquidcrysta l/wiki/Home 
// Find the download link 
// https://bitbucket.org/fmalpartida/new-liquidcrysta l/downloads 
// Download the latest version (LiquidCrystal_V1.2.1.zip 2012/04/05) 
// Go to your arduino install library location 
// (i.e. C:\Arduino\libraries) 
// Move the LiquidCrystal folder to a new location and name it LiquidCrystal.orig 
// Extract the zip file you downloaded to create a new LiquidCrystal 
// folder in that library directory 
// In the Arduino IDE, go to Sketch->Import Library, and navigate to the LCD library 
 
// To wire the LCD  up: 
// Hook the GND and VCC to the GND and Vin pins on the Arduino 
// Hook the A4 line on the Arduino up to the SDA line on the LCD I2C LCD module 
// Hook the A5 line on the Arduino up to the SCL line on the LCD I2C LCD module 
// 
 
// 
// Define include files necessary to simplify interaction with 
// peripherals 
// 
 
// Include headers for the two wire communication with the LCD 
// module.  You can talk to the LCD directly using 7 output pins, 
// which works fine, or you can use an I2C module to talk to it 
// using only one pin.  The I2C modules are only $2 or so, and 
// just connectors cost more than that, so even aside from eating up 
// fewer outputs, it makes sense to use more electronics and  
// and less wire.   
// 
// Plus, the two wires carry the concept of 
// an address, meanining they are really a bus, and you can 
// put more than just the LCD on these two wires, you can 
// also add other peripherals. 
#include <wire.h> 
 
// Now include the LCD library (again, the I2C version) 
#include <liquidcrystal_i2c.h> 
 
// Include the MAX6675 library to talk to the chip that talks  
// to the thermocouple 
#include <max6675.h> 
 
// Declare pins for max6675 thermocouple interface 
int thermoDO = 3; 
int thermoCS = 4; 
int thermoCLK = 5; 
 
// Create max6675 thermocouple object 
MAX6675 myThermocouple(thermoCLK, thermoCS, thermoDO); 
 
// 
// Now define some global variables for use by the entire program 
// 
 
// Now initialize the library to tell it about the LCD. 
// 
// The I2C interface basically lets us stuff a variety of parallel data 
// through a two wire interface.  This saves pins on the arduino output, 
// and wires in the connector.  Because the I2C bus is addressed, several 
// peripherals can all sit on the same two wires and be seperately addressed 
//  
// The arduino has plenty of pins if you just want to play with a LCD, you can 
// hook it up directly and not use the I2C stuff as well.   
//  
// The arguments are (in order):  
// * The LCD I2C address (can vary by maker) 
// * Which pin is the LCD EN pin 
// * Which pin is the LCD RW pin 
// * Which pin is the LCD RS pin 
// * Which pin is the LCD D4 pin 
// * Which pin is the LCD D5 pin 
// * Which pin is the LCD D6 pin 
// * Which pin is the LCD D7 pin 
// * Which pin is the LCD Backlight pin 
// * What the LCD backlight polarity is (POSITIVE | NEGATIVE) 
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); 
 
 
// Now do the necessary setup calls 
void setup()  
{ 
  // Send a command to the LCD module to tell it to initialize 
  // itself.  This is important because when the module comes 
  // online or if it browns out due to a voltage dip, it can get 
  // in an indeterminate state until it is reset (or re-reset). 
  // 
  // "lcd" is an object of type LiquidCrystal_I2C, and we are 
  // invoking the "begin" method for that object.  We are 
  // passing it two arguments, the width of the display (16 chars) 
  // and the height of the display (two rows). 
  lcd.begin(16,2);  
   
  // Play with Backlight 
  lcd.noBacklight(); 
  delay(100); 
  lcd.backlight(); 
  delay(100); 
  lcd.noBacklight(); 
  delay(100); 
  lcd.backlight(); 
  delay(100); 
} 
 
// Now the stuff that runs forever 
void loop()  
{ 
  // Set the LCD Cursor to col 0 row 0 
  lcd.setCursor(0,0); 
  lcd.print("MAX6675 thrmcpl"); 
   
  lcd.setCursor(0,1); 
  lcd.print("Deg F="); 
  lcd.print(myThermocouple.readFarenheit()); 
  lcd.print("     "); 
  
  // Delay a quarter second (250 milliseconds)   
  delay(250); 
} 

Posted on Wednesday, September 02, 2015 - 11:22 am:

 
// Thermocouple 
// Bill@KilgallonFamily.com 
// Revision 1.0, 2015/08/31 
 
// This program uses the LiquidCrystal_I2C library, which is 
// different (and much richer) than the one that came in  
// the SunFounder kit CD.   
// To install and use this new library (at least what I had to do today) 
// Go to https://bitbucket.org/fmalpartida/new-liquidcrysta l/wiki/Home 
// Find the download link 
// https://bitbucket.org/fmalpartida/new-liquidcrysta l/downloads 
// Download the latest version (LiquidCrystal_V1.2.1.zip 2012/04/05) 
// Go to your arduino install library location 
// (i.e. C:\Arduino\libraries) 
// Move the LiquidCrystal folder to a new location and name it LiquidCrystal.orig 
// Extract the zip file you downloaded to create a new LiquidCrystal 
// folder in that library directory 
// In the Arduino IDE, go to Sketch->Import Library, and navigate to the LCD library 
 
// To wire the LCD  up: 
// Hook the GND and VCC to the GND and Vin pins on the Arduino 
// Hook the A4 line on the Arduino up to the SDA line on the LCD I2C LCD module 
// Hook the A5 line on the Arduino up to the SCL line on the LCD I2C LCD module 
// 
 
// 
// Define include files necessary to simplify interaction with 
// peripherals 
// 
 
// Include headers for the two wire communication with the LCD 
// module.  You can talk to the LCD directly using 7 output pins, 
// which works fine, or you can use an I2C module to talk to it 
// using only one pin.  The I2C modules are only $2 or so, and 
// just connectors cost more than that, so even aside from eating up 
// fewer outputs, it makes sense to use more electronics and  
// and less wire.   
// 
// Plus, the two wires carry the concept of 
// an address, meanining they are really a bus, and you can 
// put more than just the LCD on these two wires, you can 
// also add other peripherals. 
#include <wire.h> 
 
// Now include the LCD library (again, the I2C version) 
#include <liquidcrystal_i2c.h> 
 
// Include the MAX6675 library to talk to the chip that talks  
// to the thermocouple 
#include <max6675.h> 
 
// Declare pins for first max6675 thermocouple interface 
int thermoDO = 3; 
int thermoACS = 4; 
int thermoCLK = 5; 
 
// Create first max6675 thermocouple object 
MAX6675 myThermocoupleA(thermoCLK, thermoACS, thermoDO); 
 
// Variables for high / low memory 
int thermoAVal = 0; 
int thermoAHigh = 0; 
int thermoALow = 0; 
 
// Declare pins for second max6675 thermocouple interface 
// All We reuse all the pins except CS (chip select).  The 
// chip select line defines which chip has control of the  
// defactor bus (DO and CLK) at any given time. 
int thermoBCS = 6; 
MAX6675 myThermocoupleB(thermoCLK, thermoBCS, thermoDO); 
 
// Variables for high / low memory 
int thermoBVal = 0; 
int thermoBHigh = 0; 
int thermoBLow = 0; 
 
// Define switch pin 
int buttonPin = 2; 
 
// 
// Now define some global variables for use by the entire program 
// 
 
// Now initialize the library to tell it about the LCD. 
// 
// The I2C interface basically lets us stuff a variety of parallel data 
// through a two wire interface.  This saves pins on the arduino output, 
// and wires in the connector.  Because the I2C bus is addressed, several 
// peripherals can all sit on the same two wires and be seperately addressed 
//  
// The arduino has plenty of pins if you just want to play with a LCD, you can 
// hook it up directly and not use the I2C stuff as well.   
//  
// The arguments are (in order):  
// * The LCD I2C address (can vary by maker) 
// * Which pin is the LCD EN pin 
// * Which pin is the LCD RW pin 
// * Which pin is the LCD RS pin 
// * Which pin is the LCD D4 pin 
// * Which pin is the LCD D5 pin 
// * Which pin is the LCD D6 pin 
// * Which pin is the LCD D7 pin 
// * Which pin is the LCD Backlight pin 
// * What the LCD backlight polarity is (POSITIVE | NEGATIVE) 
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); 
 
 
// Now do the necessary setup calls 
void setup()  
{ 
  // Send a command to the LCD module to tell it to initialize 
  // itself.  This is important because when the module comes 
  // online or if it browns out due to a voltage dip, it can get 
  // in an indeterminate state until it is reset (or re-reset). 
  // 
  // "lcd" is an object of type LiquidCrystal_I2C, and we are 
  // invoking the "begin" method for that object.  We are 
  // passing it two arguments, the width of the display (16 chars) 
  // and the height of the display (two rows). 
  lcd.begin(16,2);  
   
  // Set the LCD Cursor to col 0 row 0 
  lcd.setCursor(0,0); 
  lcd.print("MAX6675"); 
  lcd.setCursor(0,1); 
  lcd.print("Thermocouples"); 
   
  // Play with Backlight, and kill a little time while 
  // peripherals stabilize 
  lcd.noBacklight(); 
  delay(100); 
  lcd.backlight(); 
  delay(100); 
  lcd.noBacklight(); 
  delay(100); 
  lcd.backlight(); 
  delay(100); 
   
  // Initialize our high / low settings 
  thermoAHigh = thermoALow = (int)myThermocoupleA.readFarenheit(); 
  thermoBHigh = thermoBLow = (int)myThermocoupleB.readFarenheit(); 
   
  // Set up the switch as a digital input 
  pinMode(buttonPin, INPUT); 
} 
 
// Now the stuff that runs forever 
void loop()  
{ 
  // See if the button has been pushed to reset the high 
  // low values 
  while ( digitalRead(buttonPin) == 0 ) 
  { 
    thermoAHigh = thermoALow = (int)myThermocoupleA.readFarenheit(); 
    thermoBHigh = thermoBLow = (int)myThermocoupleB.readFarenheit(); 
    lcd.setCursor(0,0); 
    lcd.print("-----RESET------"); 
    delay(250);  // debounce on principal, though not really necessary here 
  } 
   
  // These sensors are 3% accurate, so anything to the 
  // right of the decimal place is generally a fantasy 
  // anyway, so we will be just using ints and 
  // making better use of our limited LCD real estate and RAM 
   
  // Read both values and set new highs and lows if appropriate 
  thermoAVal = (int)myThermocoupleA.readFarenheit(); 
  if (thermoAVal > thermoAHigh) {thermoAHigh = thermoAVal;} 
  if (thermoAVal < thermoALow) {thermoALow = thermoAVal;} 
   
  thermoBVal = (int)myThermocoupleB.readFarenheit(); 
  if (thermoBVal > thermoBHigh) {thermoBHigh = thermoBVal;} 
  if (thermoBVal < thermoBLow) {thermoBLow = thermoBVal;} 
   
  // Report the first temp 
  lcd.setCursor(0,0); 
  lcd.print("A "); 
  lcd.print(thermoALow); 
  lcd.print("   "); 
   
  lcd.setCursor(5,0); 
  lcd.print("| "); 
  lcd.print(thermoAVal); 
  lcd.print("   "); 
   
  lcd.setCursor(11,0); 
  lcd.print("| "); 
  lcd.print(thermoAHigh); 
  lcd.print("   "); 
   
   // Report the second temp 
    
  lcd.setCursor(0,1); 
  lcd.print("B "); 
  lcd.print(thermoBLow); 
  lcd.print("   "); 
   
  lcd.setCursor(5,1); 
  lcd.print("| "); 
  lcd.print(thermoBVal); 
  lcd.print("   "); 
   
  lcd.setCursor(11,1); 
  lcd.print("| "); 
  lcd.print(thermoBHigh); 
  lcd.print("   "); 
   
  // Delay a quarter second (250 milliseconds)   
  delay(1000); 
} 

Posted on Saturday, September 19, 2015 - 06:03 pm:

 
// Max 6675 Type N thermocouple library 
// Updated by Bill@KilgallonFamily.com, 2015/09/11 
// Updated from an origionally published ladyada.net library: 
//    this library is public domain. enjoy! 
//    www.ladyada.net/learn/sensors/thermocouple 
// 
// My updates include improved internal documentation and 
// formatting to make the library more of a teaching tool, and code 
// enhancements so that if you are reading the device too quickly you 
// still get data that is as valid as possible (it previously failed 
// silently and it would just keep returning old data). 
// 
// This version with these updates released under the Artistic 
// License. The origional ladyada code remains under the public 
// domain. 
// 
// Also note that this update, while removing a hidden pitfall, 
// is arguably *worse* than the original version.  It requires 
// more memory, requires more CPU, and has removed things that 
// were not necessary for the modern Arduino platform, but that may 
// have been useful for other platforms 
// 
 
// Include header definitions for this library (this *is* needed  ) 
#include "max6675.h" 
 
// Constructor 
MAX6675::MAX6675(byte SCLK, byte CS, byte MISO) 
{ 
 
  // Save the information on pins, we need this for every read 
  sclk = SCLK; 
  cs = CS; 
  miso = MISO; 
 
  // Set the pin modes.  Has to be done once, so do it here (why not). 
  // But it can be messed up later outside of this method 
  pinMode(cs, OUTPUT); 
  pinMode(sclk, OUTPUT); 
  pinMode(miso, INPUT); 
 
  // Set the chip select to indicate we are not trying to read this chip 
  // at this moment 
 
  digitalWrite(cs, HIGH); 
 
  // Set the last read time and last temperature 
  lastMillis = 0; 
  lastDegCRead = 0.0; 
} 
 
// Implement the method to read and return temperature in Celsius 
// MAX6675 chip actually does most of the work here. 
// 
// Bill (needs to add) logic here to prevent reading too frequently, 
// which causes the MAX6675 to just keep returning an old value 
// (potentially *very* old, like since you started reading an hour 
// ago) 
// 
double MAX6675::readCelsius(void) 
{ 
  unsigned int tempC; 
 
  // There is a quirk to the MAX6675 in that if you read it too quickly, 
  // it will keep returning the old value, and never read a new one. 
  // So if you just read full speed, you get the first value forever. 
  // 
  // The code here checks to see if you are reading too quickly, and 
  // if so, returns the previously read value without pinging the 
  // actual chip. 
  // 
  // Conversion times in the data sheet are quoted at .17 min to .22 
  // max We will assume it is .250 to play it safe.  4 Hz is decent 
  // for temperature measurements anyway, the thermal intertia of the 
  // system will likely be higher than that anyway 
  // 
  if ( (millis() - lastMillis) < 250 ) 
  { 
    // First make sure this isn't the once every 50 day case 
    // where millis rolls over 
    if ( (millis() - lastMillis) > 0 ) 
    { 
      // OK, time hasn't gone backwards but it hasn't been 250ms yet. 
      // Caller is an optimist, leave them in their happy place 
      return (lastDegCRead); 
    } 
  } 
 
  // Set the chip select low to enable communication with this 
  // particular device (could have many of them on the same 
  // communication bus, but each has to have it's own chip select 
  digitalWrite(cs, LOW); 
  delay(1); 
 
  // Use the SPI read routine (part of this class) to grab the 12 bit 
  // number from the SPI bus on the MAX6675 chip 
 
  // Read first 8 bits 
  tempC = spiread(); 
 
  // Shift them left 8 positions 
  tempC <<= 8; 
 
  // Now fill in bottom 8 positions 
 tempC |= spiread(); 
 
  // Now we have the full 16 bit return value. 
 
  // Set chip select low again so any other devices on the bus can talk 
  digitalWrite(cs, HIGH); 
 
  // From the MAX6675 data sheet: 
  // Bit Position : Meaning 
  // 15   : Always a 0 
  // 14-3 : Counts (each count is .25 deg C) 
  //      : 14 is most significant bit, 3 is least significant bit 
  //      : That gives a toal of 12 bits of resolution 
  // 2    : Indicates if it's an open thermocouple (i.e. broken wire) 
  // 1    : Device ID (always 0) 
  // 0    : Mumble.  See note below. 
  // 
  // (Mumble: The datasheet described this as a "three state" 
  // bit, but I don't know how a serially read bit can be three 
  // states, it has to be a one or a zero.  Perhaps there is a gate 
  // somewhere behind it that is three state (which means it can be a 
  // one, a zero, or just high resistance to let something else 
  // attached set it.  Makes sense for a gate, but for a serial bit? 
  // Huh?  Oh well, we don't need it, and we are just going to shift 
  // it into oblivion anyway...) 
 
  // Store conversion time so we can do checks next time so we don't 
  // oversample (which makes the chip return stale data) 
  lastMillis = millis(); 
 
  // Look and see if it's an open TC (indicated by a 1 in bit position 2) 
  if (tempC & 0B00000100) 
  { 
    lastDegCRead = NAN; 
  } 
 
  // Otherwise it must be a real temp 
  else 
  { 
    // Shift the bottom three "junk bits" into oblivion so we are left 
    // with just the 12 bit temp reading in counts, where each count is 
    // equal to .25 degrees Celsius. 
    tempC >>= 3; 
 
    // Convert to celsius by multiplying the counts by .25 
    lastDegCRead = tempC * 0.25; 
  } 
 
  // Return the degrees C 
  return (lastDegCRead); 
} 
 
 
// Implement the method to read and return temperature in Degrees 
// (Which just uses Celsius function and then converts it to 
// Farenheit 
double MAX6675::readFarenheit(void) 
{ 
  // Farenheit = Celsius * (9/5) + 32 
  return ( (readCelsius() * 1.8) + 32); 
} 
 
// Implement function to do the SPI read from the MAX6675 chip 
byte MAX6675::spiread(void) 
{ 
  // Counter (only needs to count to 8, it can be small) 
  signed char bitPosition; 
 
  // Start with the value of 0 so we can just "or" the bits in 
  byte value = 0; 
 
  // Now pluck a bit at a time off of our serial bus and slam it 
  // unconditionally into the target at that bit position 
  // We go MSB (Most Significant Bit) to LSB (Least Significant Bit) 
  for (bitPosition=7; bitPosition>=0; bitPosition--) 
  { 
    // Set clock low to tell chip to write next value on SPI data pin 
    digitalWrite(sclk, LOW); 
    delay(1);  // Delay one millisecond 
 
    // Read value on spi data pin 
    if (digitalRead(miso)) 
    { 
      // Shift the bit the appropriate number of positions over, 
      // and use a bitwise logical OR to set it in the target 
      // position 
      value |= (1 << bitPosition); 
    } 
 
    // Set clock like back high 
    digitalWrite(sclk, HIGH); 
    delay(1); // Delay one millisecond 
  } 
 
  return value; 
} 
 
 
 

Posted on Saturday, September 19, 2015 - 06:07 pm:

 
 
// Max 6675 Type N thermocouple library 
// Updated by Bill@KilgallonFamily.com, 2015/09/11 
// Updated from ladyada.net library: 
//    this library is public domain. enjoy! 
//    www.ladyada.net/learn/sensors/thermocouple 
// 
// My updates include improved internal documentation and 
// formatting to make the library more of a teaching tool, and code 
// enhancements so that if you are reading the device too quickly you 
// still get data that is as valid as possible (it previously failed 
// silently and it would just keep returning old data). 
// 
// This version with these updates released under the Artistic 
// License. The origional ladyada code remains under the public 
// domain. 
// 
// Also note that this update, while removing a hidden pitfall, 
// is arguably *worse* than the original version.  It requires 
// more memory, requires more CPU, and has removed things that 
// were not necessary for the modern Arduino platform, but that may 
// have been necessary for other platforms 
// 
 
#include "Arduino.h" 
 
// Define the MAX6675 class (does not implement functions, that is done in 
// the max6675.cpp library, and does not instantiate an object of the class, 
// that will be done in your Arduino sketch when you invoke the 
// constructor. 
 
class MAX6675 
{ 
 public: 
 
  // Constructor 
  MAX6675(byte SCLK, byte CS, byte MISO); 
 
  // Method to read and return temperature in Celsius 
  double readCelsius(void); 
 
  // Method to read and return temperature in Farenheit 
  double readFarenheit(void); 
 
 private: 
 
  // Internal persistent variables maintain assigned pins for this 
  // device (you can have more than one at one time, each on 
  // differnt pins.  For that matter, only the CS pin needs to be 
  // different for any number of connected devices (the SPI is a 
  // bus architecture)) 
  byte sclk, miso, cs; 
 
  // Define a method to read from the SPI bus that we only want 
  // used internally for this class.  Will not be available for use 
  // by anything but methods of this class. 
  byte spiread(void); 
 
  // Define memory to hold the last value read, and the last read 
  // time.  The chip itself can't read any faster then .17 seconds, so 
  // you are basically wasting your time reading at more than 10 hz anyway. 
  unsigned long lastMillis; 
  int lastDegCRead; 
}; 

Posted on Saturday, September 19, 2015 - 06:10 pm:

 
 
// Thermocouple 
// Bill@KilgallonFamily.com 
// Revision 1.0, 2015/08/31 
 
// This program uses the LiquidCrystal_I2C library, which is 
// different (and much richer) than the one that came in  
// the SunFounder kit CD.   
// To install and use this new library (at least what I had to do today) 
// Go to https://bitbucket.org/fmalpartida/new-liquidcrysta l/wiki/Home 
// Find the download link 
// https://bitbucket.org/fmalpartida/new-liquidcrysta l/downloads 
// Download the latest version (LiquidCrystal_V1.2.1.zip 2012/04/05) 
// Go to your arduino install library location 
// (i.e. C:\Arduino\libraries) 
// Move the LiquidCrystal folder to a new location and name it LiquidCrystal.orig 
// Extract the zip file you downloaded to create a new LiquidCrystal 
// folder in that library directory 
// In the Arduino IDE, go to Sketch->Import Library, and navigate to the LCD library 
 
// To wire the LCD  up: 
// Hook the GND and VCC to the GND and Vin pins on the Arduino 
// Hook the A4 line on the Arduino up to the SDA line on the LCD I2C LCD module 
// Hook the A5 line on the Arduino up to the SCL line on the LCD I2C LCD module 
// 
 
// 
// Define include files necessary to simplify interaction with 
// peripherals 
// 
 
// Include headers for the two wire communication with the LCD 
// module.  You can talk to the LCD directly using 7 output pins, 
// which works fine, or you can use an I2C module to talk to it 
// using only one pin.  The I2C modules are only $2 or so, and 
// just connectors cost more than that, so even aside from eating up 
// fewer outputs, it makes sense to use more electronics and  
// and less wire.   
// 
// Plus, the two wires carry the concept of 
// an address, meanining they are really a bus, and you can 
// put more than just the LCD on these two wires, you can 
// also add other peripherals. 
#include <wire.h> 
 
// Now include the LCD library (again, the I2C version) 
#include <liquidcrystal_i2c.h> 
 
// Include the MAX6675 library to talk to the chip that talks  
// to the thermocouple 
#include <max6675.h> 
 
// Declare pins for first max6675 thermocouple interface 
int thermoDO = 3; 
int thermoACS = 4; 
int thermoCLK = 5; 
 
// Create first max6675 thermocouple object 
MAX6675 myThermocoupleA(thermoCLK, thermoACS, thermoDO); 
 
// Variables for high / low memory 
int thermoAVal = 0; 
int thermoAHigh = 0; 
int thermoALow = 0; 
 
// Declare pins for second max6675 thermocouple interface 
// All We reuse all the pins except CS (chip select).  The 
// chip select line defines which chip has control of the  
// defactor bus (DO and CLK) at any given time. 
int thermoBCS = 6; 
MAX6675 myThermocoupleB(thermoCLK, thermoBCS, thermoDO); 
 
// Variables for high / low memory 
int thermoBVal = 0; 
int thermoBHigh = 0; 
int thermoBLow = 0; 
 
// Define switch pin 
int buttonPin = 2; 
 
// 
// Now define some global variables for use by the entire program 
// 
 
// Now initialize the library to tell it about the LCD. 
// 
// The I2C interface basically lets us stuff a variety of parallel data 
// through a two wire interface.  This saves pins on the arduino output, 
// and wires in the connector.  Because the I2C bus is addressed, several 
// peripherals can all sit on the same two wires and be seperately addressed 
//  
// The arduino has plenty of pins if you just want to play with a LCD, you can 
// hook it up directly and not use the I2C stuff as well.   
//  
// The arguments are (in order):  
// * The LCD I2C address (can vary by maker) 
// * Which pin is the LCD EN pin 
// * Which pin is the LCD RW pin 
// * Which pin is the LCD RS pin 
// * Which pin is the LCD D4 pin 
// * Which pin is the LCD D5 pin 
// * Which pin is the LCD D6 pin 
// * Which pin is the LCD D7 pin 
// * Which pin is the LCD Backlight pin 
// * What the LCD backlight polarity is (POSITIVE | NEGATIVE) 
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); 
 
 
// Now do the necessary setup calls 
void setup()  
{ 
  // Send a command to the LCD module to tell it to initialize 
  // itself.  This is important because when the module comes 
  // online or if it browns out due to a voltage dip, it can get 
  // in an indeterminate state until it is reset (or re-reset). 
  // 
  // "lcd" is an object of type LiquidCrystal_I2C, and we are 
  // invoking the "begin" method for that object.  We are 
  // passing it two arguments, the width of the display (16 chars) 
  // and the height of the display (two rows). 
  lcd.begin(16,2);  
   
  // Set the LCD Cursor to col 0 row 0 
  lcd.setCursor(0,0); 
  lcd.print("MAX6675"); 
  lcd.setCursor(0,1); 
  lcd.print("Thermocouples"); 
   
  // Play with Backlight, and kill a little time while 
  // peripherals stabilize 
  lcd.noBacklight(); 
  delay(100); 
  lcd.backlight(); 
  delay(100); 
  lcd.noBacklight(); 
  delay(100); 
  lcd.backlight(); 
  delay(100); 
   
  // Initialize our high / low settings 
  thermoAHigh = thermoALow = (int)myThermocoupleA.readFarenheit(); 
  thermoBHigh = thermoBLow = (int)myThermocoupleB.readFarenheit(); 
   
  // Set up the switch as a digital input 
  pinMode(buttonPin, INPUT); 
} 
 
// Now the stuff that runs forever 
void loop()  
{ 
  // Next TODO....  create class version of the MAX library that  
  // doesn't allow sampling faster than can be handled by the chip 
   
  // See if the button has been pushed to reset the high 
  // low values 
  while ( digitalRead(buttonPin) == 0 ) 
  { 
    thermoAHigh = thermoALow = (int)myThermocoupleA.readFarenheit(); 
    thermoBHigh = thermoBLow = (int)myThermocoupleB.readFarenheit(); 
    lcd.setCursor(0,0); 
    lcd.print("-----RESET------"); 
    delay(250);  // debounce on principal, though not really necessary here 
  } 
   
  // These sensors are 3% accurate, so anything to the 
  // right of the decimal place is generally a fantasy 
  // anyway, so we will be just using ints and 
  // making better use of our limited LCD real estate and RAM 
   
  // Read both values and set new highs and lows if appropriate 
  thermoAVal = (int) myThermocoupleA.readFarenheit(); 
  if (thermoAVal > thermoAHigh) {thermoAHigh = thermoAVal;} 
  if (thermoAVal < thermoALow) {thermoALow = thermoAVal;} 
   
  thermoBVal = (int) myThermocoupleB.readFarenheit(); 
  if (thermoBVal > thermoBHigh) {thermoBHigh = thermoBVal;} 
  if (thermoBVal < thermoBLow) {thermoBLow = thermoBVal;} 
   
  // Report the first temp 
  lcd.setCursor(0,0); 
  lcd.print("A "); 
  lcd.print(thermoALow); 
  lcd.print("   "); 
   
  lcd.setCursor(5,0); 
  lcd.print("| "); 
  lcd.print(thermoAVal); 
  lcd.print("   "); 
   
  lcd.setCursor(11,0); 
  lcd.print("| "); 
  lcd.print(thermoAHigh); 
  lcd.print("   "); 
   
   // Report the second temp 
    
  lcd.setCursor(0,1); 
  lcd.print("B "); 
  lcd.print(thermoBLow); 
  lcd.print("   "); 
   
  lcd.setCursor(5,1); 
  lcd.print("| "); 
  lcd.print(thermoBVal); 
  lcd.print("   "); 
   
  lcd.setCursor(11,1); 
  lcd.print("| "); 
  lcd.print(thermoBHigh); 
  lcd.print("   "); 
   
  // Delay (in milliseconds) 
  delay(500); 
}