Memorial day is 05/25/2015 – Orders will ship out on May 26th. There will not be any deliveries or shipping on Monday. Any order placed after 11am ET on Friday May 22nd will not start to ship out until Tuesday May 26th.

RGB LCD Plate - Code to display weather information
Moderators: adafruit_support_bill, adafruit

Forum rules
Talk about Adafruit Raspberry Pi® accessories! Please do not ask for Linux support, this is for Adafruit products only! For Raspberry Pi help please visit: http://www.raspberrypi.org/phpBB3/

RGB LCD Plate - Code to display weather information

by nsnick on Sun Feb 03, 2013 6:35 pm

Code: Select all | TOGGLE FULL SIZE
#!/usr/bin/pythonhttp://raspberrypi.local/editor

#
# based on code from lrvick and LiquidCrystal
# lrvic - https://github.com/lrvick/raspi-hd44780/blob/master/hd44780.py
# LiquidCrystal - https://github.com/arduino/Arduino/blob/master/libraries/LiquidCrystal/LiquidCrystal.cpp
#
#Modified to display weather data from openweathermap.org on an adafruit LCD plate shield for raspberry pi 2/3/2013
#
#

import urllib2, json #added for weather
from Adafruit_I2C import Adafruit_I2C
from Adafruit_MCP230xx import Adafruit_MCP230XX
import smbus

# change busnum = 0 to bbusnum = 1 if you have a rev 2 Pi!
mcp = Adafruit_MCP230XX(busnum = 0, address = 0x20, num_gpios = 16)

class Adafruit_CharLCD:

    OUTPUT = 0
    INPUT = 1
   
    # LED colors
    RED = 0x01
    GREEN = 0x02
    BLUE = 0x04
    YELLOW = 0x03
    TEAL = 0x06
    VIOLET = 0x05
    ON = 0x07
    OFF = 0x0

    # buttons
    SELECT = 0
    RIGHT = 1
    DOWN = 2
    UP = 3
    LEFT = 4

    # commands
    LCD_CLEARDISPLAY        = 0x01
    LCD_RETURNHOME       = 0x02
    LCD_ENTRYMODESET       = 0x04
    LCD_DISPLAYCONTROL       = 0x08
    LCD_CURSORSHIFT       = 0x10
    LCD_FUNCTIONSET       = 0x20
    LCD_SETCGRAMADDR       = 0x40
    LCD_SETDDRAMADDR       = 0x80

    # flags for display entry mode
    LCD_ENTRYRIGHT       = 0x00
    LCD_ENTRYLEFT       = 0x02
    LCD_ENTRYSHIFTINCREMENT    = 0x01
    LCD_ENTRYSHIFTDECREMENT    = 0x00

    # flags for display on/off control
    LCD_DISPLAYON       = 0x04
    LCD_DISPLAYOFF       = 0x00
    LCD_CURSORON       = 0x02
    LCD_CURSOROFF       = 0x00
    LCD_BLINKON       = 0x01
    LCD_BLINKOFF       = 0x00

    # flags for display/cursor shift
    LCD_DISPLAYMOVE       = 0x08
    LCD_CURSORMOVE       = 0x00

    # flags for display/cursor shift
    LCD_DISPLAYMOVE       = 0x08
    LCD_CURSORMOVE       = 0x00
    LCD_MOVERIGHT       = 0x04
    LCD_MOVELEFT       = 0x00

    # flags for function set
    LCD_8BITMODE       = 0x10
    LCD_4BITMODE       = 0x00
    LCD_2LINE          = 0x08
    LCD_1LINE          = 0x00
    LCD_5x10DOTS       = 0x04
    LCD_5x8DOTS       = 0x00



    def __init__(self, pin_rs=25, pin_e=24, pins_db=[23, 17, 21, 22], pin_rw=0):
        self.pin_rs = pin_rs
        self.pin_e = pin_e
        self.pin_rw = pin_rw
        self.pins_db = pins_db

        mcp.config(self.pin_e, self.OUTPUT)
        mcp.config(self.pin_rs,  self.OUTPUT)
        mcp.config(self.pin_rw,  self.OUTPUT)
        mcp.output(self.pin_rw, 0)
        mcp.output(self.pin_e, 0)
       
        for pin in self.pins_db:
            mcp.config(pin,  self.OUTPUT)

   self.write4bits(0x33) # initialization
   self.write4bits(0x32) # initialization
   self.write4bits(0x28) # 2 line 5x7 matrix
   self.write4bits(0x0C) # turn cursor off 0x0E to enable cursor
   self.write4bits(0x06) # shift cursor right

   self.displaycontrol = self.LCD_DISPLAYON | self.LCD_CURSOROFF | self.LCD_BLINKOFF

   self.displayfunction = self.LCD_4BITMODE | self.LCD_1LINE | self.LCD_5x8DOTS
   self.displayfunction |= self.LCD_2LINE

   """ Initialize to default text direction (for romance languages) """
   self.displaymode =  self.LCD_ENTRYLEFT | self.LCD_ENTRYSHIFTDECREMENT
   self.write4bits(self.LCD_ENTRYMODESET | self.displaymode) #  set the entry mode

   # turn on backlights!
       mcp.config(6, mcp.OUTPUT)
       mcp.config(7, mcp.OUTPUT)
       mcp.config(8, mcp.OUTPUT)
       mcp.output(6, 0) # red
       mcp.output(7, 0) # green
       mcp.output(8, 0) # blue

   # turn on pullups
        mcp.pullup(self.SELECT, True)
        mcp.pullup(self.LEFT, True)
        mcp.pullup(self.RIGHT, True)
        mcp.pullup(self.UP, True)
        mcp.pullup(self.DOWN, True)
   mcp.config(self.SELECT, mcp.INPUT)
   mcp.config(self.LEFT, mcp.INPUT)
   mcp.config(self.RIGHT, mcp.INPUT)
   mcp.config(self.DOWN, mcp.INPUT)
   mcp.config(self.UP, mcp.INPUT)

    def begin(self, cols, lines):
        if (lines > 1):
            self.numlines = lines
            self.displayfunction |= self.LCD_2LINE
        self.currline = 0
        self.clear()

    def home(self):
        self.write4bits(self.LCD_RETURNHOME) # set cursor position to zero
        self.delayMicroseconds(2000) # this command takes a long time!

    def clear(self):
        self.write4bits(self.LCD_CLEARDISPLAY) # command to clear display
        self.delayMicroseconds(2000)   # 2000 microsecond sleep, clearing the display takes a long time

    def setCursor(self, col, row):
        self.row_offsets = [ 0x00, 0x40, 0x14, 0x54 ]
        if ( row > self.numlines ):
          row = self.numlines - 1 # we count rows starting w/0
        self.write4bits(self.LCD_SETDDRAMADDR | (col + self.row_offsets[row]))

    def noDisplay(self):
        """ Turn the display off (quickly) """
        self.displaycontrol &= ~self.LCD_DISPLAYON
        self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)

    def display(self):
        """ Turn the display on (quickly) """
        self.displaycontrol |= self.LCD_DISPLAYON
        self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)

    def noCursor(self):
        """ Turns the underline cursor on/off """
        self.displaycontrol &= ~self.LCD_CURSORON
        self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)


    def cursor(self):
        """ Cursor On """
        self.displaycontrol |= self.LCD_CURSORON
        self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)

    def noBlink(self):
   """ Turn on and off the blinking cursor """
        self.displaycontrol &= ~self.LCD_BLINKON
        self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)

    def noBlink(self):
   """ Turn on and off the blinking cursor """
        self.displaycontrol &= ~self.LCD_BLINKON
        self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)

    def DisplayLeft(self):
        """ These commands scroll the display without changing the RAM """
        self.write4bits(self.LCD_CURSORSHIFT | self.LCD_DISPLAYMOVE | self.LCD_MOVELEFT)

    def scrollDisplayRight(self):
   """ These commands scroll the display without changing the RAM """
        self.write4bits(self.LCD_CURSORSHIFT | self.LCD_DISPLAYMOVE | self.LCD_MOVERIGHT);

    def leftToRight(self):
   """ This is for text that flows Left to Right """
        self.displaymode |= self.LCD_ENTRYLEFT
        self.write4bits(self.LCD_ENTRYMODESET | self.displaymode);

    def rightToLeft(self):
   """ This is for text that flows Right to Left """
        self.displaymode &= ~self.LCD_ENTRYLEFT
        self.write4bits(self.LCD_ENTRYMODESET | self.displaymode)

    def autoscroll(self):
   """ This will 'right justify' text from the cursor """
        self.displaymode |= self.LCD_ENTRYSHIFTINCREMENT
        self.write4bits(self.LCD_ENTRYMODESET | self.displaymode)

    def noAutoscroll(self):
   """ This will 'left justify' text from the cursor """
        self.displaymode &= ~self.LCD_ENTRYSHIFTINCREMENT
        self.write4bits(self.LCD_ENTRYMODESET | self.displaymode)

    def write4bits(self, bits, char_mode=False):
        """ Send command to LCD """
        #self.delayMicroseconds(1000) # 1000 microsecond sleep
        bits=bin(bits)[2:].zfill(8)
        mcp.output(self.pin_rs, char_mode)

        for i in range(4):
            if bits[i] == "1":
                mcp.output(self.pins_db[::-1][i], True)
            else:
                mcp.output(self.pins_db[::-1][i], False)
        self.pulseEnable()

        for i in range(4,8):
            if bits[i] == "1":
                mcp.output(self.pins_db[::-1][i-4], True)
            else:
                mcp.output(self.pins_db[::-1][i-4], False)
        self.pulseEnable()

    def delayMicroseconds(self, microseconds):
        seconds = microseconds / 1000000   # divide microseconds by 1 million for seconds
        sleep(seconds)

    def pulseEnable(self):
        mcp.output(self.pin_e, True)
        self.delayMicroseconds(1)      # 1 microsecond pause - enable pulse must be > 450ns
        mcp.output(self.pin_e, False)
        #self.delayMicroseconds(1)      # commands need > 37us to settle

    def message(self, text):
        """ Send string to LCD. Newline wraps to second line"""
        for char in text:
            if char == '\n':
                self.write4bits(0xC0) # next line
            else:
                self.write4bits(ord(char),True)

    def backlight(self, color):
   mcp.output(6, not color & 0x01)
   mcp.output(7, not color & 0x02)
   mcp.output(8, not color & 0x04)


#if __name__ == '__main__':


lcd = Adafruit_CharLCD(15, 13, [12,11,10,9], 14)
latitude = '40.44'    #change this value for your location
longitude = '-79.99'  #change this value for your location
dp = 1                #decimal places
disp_delay = 10       #number of seconds to wait to refresh display
update_delay = 15      #number of minutes to wait to update information
update_iterations = 60 * update_delay / disp_delay

def ctof(c):
   f = (c * 1.8) + 32
   return f
   
def getWeather():
   url_string = 'http://api.openweathermap.org/data/2.1/find/city?lat=' + latitude + '&lon=' + longitude + '&cnt=10'

   f = urllib2.urlopen(url_string)
   json_string = f.read()   
   parsed_json = json.loads(json_string)
   data = parsed_json['list']
   first_entry = data[0]
   print first_entry
   city = first_entry['name']
   print city
   weather_text_a = first_entry['weather']
   weather_text = weather_text_a[0]
   weather_current = weather_text['main']
   weather_current_desc = weather_text['description']
   weather_data = first_entry['main']
   weather_temp_max_k_fl = weather_data['temp_max']
   weather_temp_min_k_fl = weather_data['temp_min']
   weather_temp_current_k_fl = weather_data['temp']
   weather_humidity_percent_fl = weather_data['humidity']
   weather_pressure_fl = weather_data['pressure']
   weather_temp_max_c_fl = weather_temp_max_k_fl - 273.15
   weather_temp_min_c_fl = weather_temp_min_k_fl - 273.15
   weather_temp_current_c_fl = weather_temp_current_k_fl - 273.15
   weather_temp_max_f_fl = ctof(weather_temp_max_c_fl)
   weather_temp_min_f_fl = ctof(weather_temp_min_c_fl)
   weather_temp_current_f_fl = ctof(weather_temp_current_c_fl)
   weather_temp_max_k = round(weather_temp_max_k_fl, dp)
   weather_temp_min_k = round(weather_temp_min_k_fl, dp)
   weather_temp_current_k = round(weather_temp_current_k_fl, dp)
   weather_temp_max_c = round(weather_temp_max_c_fl, dp)
   weather_temp_min_c = round(weather_temp_min_c_fl, dp)
   weather_temp_current_c = round(weather_temp_current_c_fl, dp)
   weather_temp_max_f = round(weather_temp_max_f_fl, dp)
   weather_temp_min_f = round(weather_temp_min_f_fl, dp)
   weather_temp_current_f = round(weather_temp_current_f_fl, dp)
   weather_humidity_percent = round(weather_humidity_percent_fl, dp)
   weather_pressure = round(weather_pressure_fl, dp)

   city_str = "City: " + city + "\n"
   conditions_str = weather_current + "\n"
   desc_str = weather_current_desc + "\n"
   max_str = "Max: %.1fC %.1fF\n" % (weather_temp_max_c, weather_temp_max_f)
   min_str =  "Min: %.1fC %.1fF\n" % (weather_temp_min_c, weather_temp_min_f)
   now_str = "Now: %.1fC %.1fF\n" % (weather_temp_current_c, weather_temp_current_f)
   humidity_str = "Humidity: %.1f%%\n" % weather_humidity_percent
   pressure_str = "Pressure: %.1f\n" % weather_pressure

   weather_list = [city_str, conditions_str, desc_str, max_str, min_str, now_str, humidity_str, pressure_str]
   print weather_list
   return weather_list

def setDisplayTextAndColor():
   weather_list = getWeather()
   if 'warning' in weather_list[2]: lcd.backlight(lcd.YELLOW)
   elif 'snow' in weather_list[2]: lcd.backlight(lcd.RED)
   elif 'sleet' in weather_list[2]: lcd.backlight(lcd.VIOLET)
   elif 'rain' in weather_list[2]: lcd.backlight(lcd.GREEN)
   elif 'clouds' or 'overcast' in weather_list[2]: lcd.backlight(lcd.BLUE)
   else: lcd.backlight(lcd.TEAL)
   return weather_list

weather_list = setDisplayTextAndColor()
      
i0 = 0
i1 = 1
j = 0
while 1:
   sleep(disp_delay)
   lcd.clear()
      lcd.message(weather_list[i0] + "\n" + weather_list[i1])
   i0 = i0 + 1
   if i0 > len(weather_list) - 1: i0 = 0
   i1 = i0 + 1
   if i1 > len(weather_list) - 1: i1 = 0
   j = j + 1
   if j == update_iterations:
      j = 0
      weather_list = setDisplayTextAndColor()
   
   
      

Enjoy!
nsnick
 
Posts: 1
Joined: Mon Nov 07, 2011 3:27 pm

Re: RGB LCD Plate - Code to display weather information

by adafruit on Thu Feb 07, 2013 12:38 am

Neat, can you post a photo? :)

adafruit
 
Posts: 11905
Joined: Thu Apr 06, 2006 4:21 pm
Location: nyc