Created
November 26, 2012 19:43
-
-
Save anonymous/4150185 to your computer and use it in GitHub Desktop.
Arduino; Nokia LCD, LDR, Analogue Backlight
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// Arduino - Temperature gauge, LCD and light-based dimmer | |
#include <OneWire.h> // Includes temp gauge library | |
// Defines LCD characteristics | |
#define PIN_SCE 7 // Pin 3 on LCD, Arduino Pin 7 | |
#define PIN_RESET 6 // Pin 4 on LCD, Arduino Pin 6 | |
#define PIN_DC 5 // Pin 5 on LCD, Arduino Pin 5 | |
#define PIN_SDIN 4 // Pin 6 on LCD, Arduino Pin 4 | |
#define PIN_SCLK 3 // Pin 7 on LCD, Arduino Pin 3 | |
#define LCD_COMMAND 0 // The DC pin tells the LCD if we are sending a command or data | |
#define LCD_DATA 1 // The DC pin tells the LCD if we are sending a command or data | |
#define LCD_X 84 // Screen height | |
#define LCD_Y 48 // Screen Width | |
const int LED = 11; // Defines Pin 11 as a constant | |
int DS18S20_Pin = 2; // DS18S20 Signal pin on digital 2 | |
OneWire ds(DS18S20_Pin); // Temp gauge on digital pin 2 | |
long previousMillis = 0; // Last time temp updated | |
long interval = 1500; // Interval to gather temp | |
void setup(void) | |
{ | |
LCDInit(); // Init the LCD | |
pinMode(LED,OUTPUT); // Sets Pin 11 to output. Odd Arduino d-pins are analogue out | |
} | |
void loop(void) | |
{ | |
int light = analogRead(0)/4; | |
if(light<30) | |
{ | |
light = 30; | |
} | |
analogWrite(LED,light); // Sets LED brightness to quarter of ambient light reading | |
unsigned long currentMillis = millis(); | |
if(currentMillis - previousMillis > interval) | |
{ | |
previousMillis = currentMillis; | |
LCDClear(); // Clears LCD | |
int temperature = 0; | |
temperature = getTemp(); // Retrieves a temperature value as an integer | |
char temp[0]; // | |
sprintf(temp, "Temp:%dC",temperature); // | |
LCDString(temp); // Writes the temp | |
} | |
} | |
//ASCII Character table | |
static const byte ASCII[][5] = | |
{ | |
{0x00, 0x00, 0x00, 0x00, 0x00} // 20 | |
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 ! | |
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 " | |
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 # | |
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $ | |
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 % | |
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 & | |
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 ' | |
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 ( | |
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 ) | |
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a * | |
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b + | |
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c , | |
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d - | |
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e . | |
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f / | |
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0 | |
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1 | |
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2 | |
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3 | |
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4 | |
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5 | |
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6 | |
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7 | |
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8 | |
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9 | |
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a : | |
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ; | |
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c < | |
,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d = | |
,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e > | |
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ? | |
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @ | |
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A | |
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B | |
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C | |
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D | |
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E | |
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F | |
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G | |
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H | |
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I | |
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J | |
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K | |
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L | |
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M | |
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N | |
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O | |
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P | |
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q | |
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R | |
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S | |
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T | |
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U | |
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V | |
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W | |
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X | |
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y | |
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z | |
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [ | |
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c "\" | |
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ] | |
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^ | |
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _ | |
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 ` | |
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a | |
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b | |
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c | |
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d | |
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e | |
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f | |
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g | |
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h | |
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i | |
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j | |
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k | |
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l | |
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m | |
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n | |
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o | |
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p | |
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q | |
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r | |
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s | |
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t | |
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u | |
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v | |
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w | |
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x | |
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y | |
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z | |
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b { | |
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c | | |
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d } | |
,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ~ | |
,{0x78, 0x46, 0x41, 0x46, 0x78} // 7f DEL | |
}; | |
//returns the temperature from one DS18S20 in DEG Celsius | |
float getTemp() | |
{ | |
byte data[12]; | |
byte addr[8]; | |
if ( !ds.search(addr)) | |
{ | |
//no more sensors on chain, reset search | |
ds.reset_search(); | |
return -1000; | |
} | |
if ( OneWire::crc8( addr, 7) != addr[7]) | |
{ | |
Serial.println("CRC is not valid!"); | |
return -1000; | |
} | |
if ( addr[0] != 0x10 && addr[0] != 0x28) | |
{ | |
Serial.print("Device is not recognized"); | |
return -1000; | |
} | |
ds.reset(); | |
ds.select(addr); | |
ds.write(0x44,1); // start conversion, with parasite power on at the end | |
byte present = ds.reset(); | |
ds.select(addr); | |
ds.write(0xBE); // Read Scratchpad | |
for (int i = 0; i < 9; i++) //we need 9 bits | |
{ | |
data[i] = ds.read(); | |
} | |
ds.reset_search(); | |
byte MSB = data[1]; | |
byte LSB = data[0]; | |
float tempRead = ((MSB << 8) | LSB); //using two's compliment | |
float TemperatureSum = tempRead / 16; | |
return TemperatureSum; | |
} | |
void gotoXY(int x, int y) | |
{ | |
LCDWrite(0, 0x80 | x); // Column. | |
LCDWrite(0, 0x40 | y); // Row. ? | |
} | |
//This takes a large array of bits and sends them to the LCD | |
void LCDBitmap(char my_array[]) | |
{ | |
for (int index = 0 ; index < (LCD_X * LCD_Y / 8) ; index++) | |
LCDWrite(LCD_DATA, my_array[index]); | |
} | |
//This function takes in a character, looks it up in the font table/array | |
//And writes it to the screen | |
//Each character is 8 bits tall and 5 bits wide. We pad one blank column of | |
//pixels on each side of the character for readability. | |
void LCDCharacter(char character) | |
{ | |
LCDWrite(LCD_DATA, 0x00); //Blank vertical line padding | |
for (int index = 0 ; index < 5 ; index++) | |
LCDWrite(LCD_DATA, ASCII[character - 0x20][index]); | |
//0x20 is the ASCII character for Space (' '). The font table starts with this character | |
LCDWrite(LCD_DATA, 0x00); //Blank vertical line padding | |
} | |
//Given a string of characters, one by one is passed to the LCD | |
void LCDString(char *characters) | |
{ | |
while (*characters) | |
LCDCharacter(*characters++); | |
} | |
//Clears the LCD by writing zeros to the entire screen | |
void LCDClear(void) | |
{ | |
for (int index = 0 ; index < (LCD_X * LCD_Y / 8) ; index++) | |
LCDWrite(LCD_DATA, 0x00); | |
gotoXY(0, 0); //After we clear the display, return to the home position | |
} | |
//This sends the magical commands to the PCD8544 | |
void LCDInit(void) | |
{ | |
//Configure control pins | |
pinMode(PIN_SCE, OUTPUT); | |
pinMode(PIN_RESET, OUTPUT); | |
pinMode(PIN_DC, OUTPUT); | |
pinMode(PIN_SDIN, OUTPUT); | |
pinMode(PIN_SCLK, OUTPUT); | |
//Reset the LCD to a known state | |
digitalWrite(PIN_RESET, LOW); | |
digitalWrite(PIN_RESET, HIGH); | |
LCDWrite(LCD_COMMAND, 0x21); //Tell LCD that extended commands follow | |
LCDWrite(LCD_COMMAND, 0xB0); //Set LCD Vop (Contrast): Try 0xB1(good @ 3.3V) or 0xBF if your display is too dark | |
LCDWrite(LCD_COMMAND, 0x04); //Set Temp coefficent | |
LCDWrite(LCD_COMMAND, 0x14); //LCD bias mode 1:48: Try 0x13 or 0x14 | |
LCDWrite(LCD_COMMAND, 0x20); //We must send 0x20 before modifying the display control mode | |
LCDWrite(LCD_COMMAND, 0x0C); //Set display control, 0x0C normal mode. 0x0D for inverse | |
} | |
//There are two memory banks in the LCD, data/RAM and commands. This | |
//function sets the DC pin high or low depending, and then sends | |
//the data byte | |
void LCDWrite(byte data_or_command, byte data) | |
{ | |
digitalWrite(PIN_DC, data_or_command); //Tell the LCD that we are writing either to data or a command | |
//Send the data | |
digitalWrite(PIN_SCE, LOW); | |
shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data); | |
digitalWrite(PIN_SCE, HIGH); | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment