Posted on Saturday, March 28, 2015 - 09:56 pm:

---

quote:

// LCD Demo code
// Bill@KilgallonFamily.com
// Revision 1.0, 2015/03/28

// 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-liquidcrystal/wiki/Home
// Find the download link
// https://bitbucket.org/fmalpartida/new-liquidcrystal/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 load code to the Uno, make sure your Arduino IDE tool->programmer is set up
// as AVRISP mkII and your port is correct.

// To wire this 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>

//
// Now define some global variables for use by the entire program
//

// First, create a 17 byte array here to accomodate the 16
// characters the LCD can display, and the extra byte to
// store a null (0x00) so we can use the C string operators
// safely (which we might not bother to do)
char LCDBuffer[17];

// 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 define stuff to blink onboard LED for sanity when debugging
// so we know stuff is running
const int ledPin = 13;

// LED state tracker
bool ledState = 0;

// 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 "init" 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);

// Setup onboard LED to blink to know we are still alive when debugging
pinMode(ledPin, OUTPUT);
}

// Now the stuff that runs forever
void loop()
{
// Set the LCD Cursor to col 0 row 0
lcd.setCursor(0,0);
lcd.print("Hello, world!");

// Set the LCD Cursor to col 0 row 1
lcd.setCursor(0,1);
sprintf(LCDBuffer, "2015/03/28 %d", ledState);
lcd.print(LCDBuffer);

// Flip the on board LCD on and off. A nice assurance when debugging but not
// seeing anything on the LCD (maybe because a wire is wrong).
digitalWrite(ledPin, ledState);
ledState = !ledState;

// Delay half a second (500 microseconds)
delay(500);
}

---

Posted on Saturday, March 28, 2015 - 11:21 pm:

---

quote:

// Temperature and Humidity Monitor
// Bill@KilgallonFamily.com
// Revision 1.0, 2015/03/28

// 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-liquidcrystal/wiki/Home
// Find the download link
// https://bitbucket.org/fmalpartida/new-liquidcrystal/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 load code to the Uno, make sure your Arduino IDE tool->programmer is set up
// as AVRISP mkII and your port is correct.

// To wire this 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>

// Now include the DHT library (temp and humidity sensor)
// I grabbed the libraries from the Sunfounder kit CD, but they
// can be found on the web as well. Installation is similar to the
// LCD library install directions above.
#include <dht.h>

//
// Now define some global variables for use by the entire program
//
float lmTemp = 0;
long lmVal = 0;


//
// Now define the pins for out LM35 temp sensor (really
// just one analog input)
//
#define lmPin A0

//
// And the pin for the DHT (temp and humidity) sensor
//
#define DHT11_PIN 4

// 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 define stuff to blink onboard LED for sanity when debugging
// so we know stuff is running
const int ledPin = 13;

// LED state tracker
bool ledState = 0;

// DHT object (humidity and temp)
dht DHT;

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

// Setup onboard LED to blink to know we are still alive when debugging
pinMode(ledPin, OUTPUT);
}

// Now the stuff that runs forever
void loop()
{
// Read the temperature from the LM35 temp sensor
lmVal = analogRead(lmPin);

// Convert counts to degrees C
// Equation derived from LM35 data sheet
// Device reads 10mv / deg C
// mv = (counts/1024) * 5000 (ratio of 0 to 1024 across 5v)
// degC = mv / 10
// Solving for degC = ((counts/1024) * 5000) / 10
// Simplifying degC = counts * .4883

lmTemp = (lmVal * 0.48828125);

// And convert degrees C t0 degrees F
lmTemp = (((lmTemp * 9.0)/5.0) + 32.0);

// Set the LCD Cursor to col 0 row 0
lcd.setCursor(0,0);
lcd.print("LMTmp=");
lcd.print(lmTemp);
lcd.print(" F ");

// Flip the on board LCD on and off. A nice assurance when debugging but not
// seeing anything on the LCD (maybe because a wire is wrong).
digitalWrite(ledPin, ledState);
ledState = !ledState;

// Now get the DHT temp and humidity
// This returns DHTLIB_OK, DHTLIB_ERROR_CHECKSUM, and DHTLIB_ERROR_TIMEOUT
// but we are ignoring those for this demo
DHT.read11(DHT11_PIN);

// Set LCD cursor to col 0 row 1
lcd.setCursor(0,1);
lcd.print("DT=");

// Gotta convert deg C to degrees F while printing
lcd.print( (((DHT.temperature * 9.0)/5.0) + 32.0), 1);
lcd.print(" Hum=");
lcd.print(DHT.humidity, 1);
lcd.print("%");

// Cant read the DHT more than once every 2 seconds so slow everything down
delay(2500);
}

---

Posted on Sunday, March 29, 2015 - 12:51 am:

---

quote:

Sketch uses 6,974 bytes (21%) of program storage space. Maximum is 32,256 bytes.

Global variables use 340 bytes (16%) of dynamic memory, leaving 1,708 bytes for local variables. Maximum is 2,048 bytes.

---

Posted on Wednesday, April 01, 2015 - 06:14 pm:

---

quote:

// Heated gear controller
// Bill@KilgallonFamily.com
// Revision 1.0, 2015/03/28

// Configuration notes
//
// 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-liquidcrystal/wiki/Home
// Find the download link
// https://bitbucket.org/fmalpartida/new-liquidcrystal/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 load code to the Uno, make sure your Arduino IDE tool->programmer is set up
// as AVRISP mkII and your port is correct.
//
// 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 for the libraries we want to use
//

// 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>
#include <liquidcrystal_i2c.h>

//
// Define the pin for the input voltage to the heater (bike voltage)
// just one analog input)
//
#define bikeVoltPin A0

//
// Now define some global variables for use by the entire program
//
float bikeVolts, highVolts, lowVolts;

// 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 define stuff to blink onboard LED for sanity when debugging
// so we know stuff is running
const int ledPin = 13;

// LED state tracker
bool ledState = 0;

// Counter
short unsigned int counter = 0, burstCounter;

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

// Setup onboard LED to blink to know we are still alive when debugging
pinMode(ledPin, OUTPUT);

// Start them all even so we can compare and get highs and lows right
bikeVolts = highVolts = lowVolts = analogRead(bikeVoltPin) * .0293255;
}

// Now the stuff that runs forever
void loop()
{
// Counters gonna count
counter++;

// Read the voltage from the precision resistor divider
// on Vin instead of regulated 5v. Should work all the
// way up to the point where the magic smoke comes out
//
// Convert counts to volts
// Equation derivation:
// 1024 counts = 5V (how Arduino is set up)
// So 5.0 * (counts / 1023) is voltage read
// Or voltRead = .00488759 * counts
//
// But this is reading a voltage divider, not pure input
// voltage (so we can read more than 5 volts)
// So Vin = ((10k + 2k) / 2k) * voltage read
// or Vin = 6 * voltage read
//
// Combining these two equations gives
// bikeVolts = (.00488759 * analogRead(bikeVoltPin)) * 6.0;
// Which can be simplified to analogRead(bikeVoltPin) * .0293255

for ( burstCounter = 0; burstCounter < 1000; burstCounter++ )
{
bikeVolts = analogRead(bikeVoltPin) * .0293255;

// See if we have a new high score
if (bikeVolts > highVolts )
{
highVolts = bikeVolts;
}

// Or a new low score
if (bikeVolts < lowVolts)
{
lowVolts = bikeVolts;
}
}

// Set the LCD Cursor to col 0 row 0
lcd.setCursor(0,0);

// Display current voltage with one decimal place
lcd.print(bikeVolts,1);
lcd.print("V");

lcd.print("(");
lcd.print(lowVolts, 1);
lcd.print("/");
lcd.print(highVolts,1);
lcd.print(") ");

// Display count
// lcd.setCursor(0,1);
// lcd.print(counter);
// lcd.print(" ");

// Flip the on board LCD on and off. A nice assurance when debugging but not
// seeing anything on the LCD (maybe because a wire is wrong).
digitalWrite(ledPin, ledState);
ledState = !ledState;

// Delay to make LCD more readable
delay(0);
}

---