Пример #1
0
 def __init__(self, path):
     super(EventHandler, self).__init__()
     self.lcd = LCDSysInfo()
     self.lcd.set_brightness(BRIGHTNESS)
     self.lcd.dim_when_idle(False)
     self.lcd.clear_lines(TextLines.ALL, BGCOLOR)
     self.old_lines = [''] * 6
     self.path = path
def showDefaultScreen(firstTime, summary, mtgoxLastPrice, mtgoxDirectionCode, toggleSinceLast, mtgoxToggleState):

    # extract just the data we want from the API result and
    #  build up display strings for each using the data
        
    avg = float(summary['SUMMARY'][0]['MHS av'])
    avgMhs = convertSize(avg*1000000.0)
    foundBlocks = str(int(summary['SUMMARY'][0]['Found Blocks']))    
    difficultyAccepted = "A:" + str(int(summary['SUMMARY'][0]['Difficulty Accepted']))
    if 'Pool Rejected%' in summary['SUMMARY'][0]:
        rej = str(summary['SUMMARY'][0]['Pool Rejected%'])
        if (rej == '0'):
            rejp = rej + "%"
        else:
            rejp = rej.split('.')[0] + "." + rej.split('.')[1][:2] + "%"
    else:
        rejp = str(int(summary['SUMMARY'][0]['Difficulty Rejected']))
    reject = "R:" + rejp
    if 'Device Hardware%' in summary['SUMMARY'][0]:
        hw = str(summary['SUMMARY'][0]['Device Hardware%'])
        if (hw == '0'):
            hwp = hw + "%"
        else:
            hwp = hw.split('.')[0] + "." + hw.split('.')[1][:2] + "%"
    else:
        hwp = str(int(summary['SUMMARY'][0]['Hardware Errors']))
    hardware = "HW:" + hwp
    bestShare = "S:" + convertSize(int(summary['SUMMARY'][0]['Best Share']))
    workUtility = "WU:" + str(summary['SUMMARY'][0]['Work Utility']) + "/m"
   
    # get current time, and format it per user selection
    theTime = ""   
    time.ctime() # formatted like this: 'Mon Oct 18 13:35:29 2010'
    if timeDisplayFormat == '12':
        theTime = time.strftime("%I:%M%p")  # 12 hour display
    else:    
        theTime = time.strftime("%H:%M:%S")  # 24 hour display

    # strip common prefixes and suffixes off of the pool URL (to save display space) 
    # TODO add code to remove all ":dddd" instead of adding port numbers to ignore
    commonStringPattern = ['http://', 'stratum+tcp://', 'stratum.', 'www.', '.com', 'mining.', ':3333', ':3334', ':8330']  
    shortPoolURL = str(poolURL)
    for i in commonStringPattern:
        shortPoolURL = shortPoolURL.replace(i, '', 1).rstrip()   
      
    # build the display strings
    line1String = shortPoolURL + "\t" + theTime
    line2String = "Uptime:  " + upTime
    line3String = "Avg:" + avgMhs + "h/s" + "  B:" + foundBlocks
    if int(foundBlocks) > 0:
        line3Colour = TextColours.RED
    else:
        line3Colour = TextColours.GREEN

    #line3String = "Avg:" + avgMhs + "\tB:" + foundBlocks
    line4String = difficultyAccepted + "  " + bestShare
    line5String = reject + "  " + hardware
    
    if mtgoxToggleState: # if we have MtGox data, get ready to display it
        line6String = "MtGox: " + mtgoxLastPrice 
    else:
        line6String = workUtility
        
    # set up to write to the LCD screen
    #
    # Init the LCD screen
    display = LCDSysInfo()
    display.dim_when_idle(False)
    display.set_brightness(255)
    display.save_brightness(100, 255)
    
    if (firstTime == True):
        # clear screen
        display.clear_lines(TextLines.ALL, BackgroundColours.BLACK)

    # write all lines
    display.display_text_on_line(1, line1String, True, (TextAlignment.LEFT, TextAlignment.RIGHT), TextColours.YELLOW)
    display.display_text_on_line(2, line2String, True, (TextAlignment.LEFT, TextAlignment.RIGHT), TextColours.LIGHT_BLUE)    
    display.display_text_on_line(3, line3String, True, (TextAlignment.LEFT), line3Colour)
    display.display_text_on_line(4, line4String, True, (TextAlignment.LEFT), TextColours.GREEN)
    display.display_text_on_line(5, line5String, True, (TextAlignment.LEFT), TextColours.GREEN)
    
    # check to see if the mtgoxDisplay just toggled, if so, display black text to remove traces of previous icon
    if toggleSinceLast == True:
        display.display_text_anywhere(0, 197, '       ', TextColours.BLACK)
    
    if mtgoxToggleState == True:
        display.display_icon(41, mtgoxDirectionCode) # directionCode should contain the icon number for up or down arrow
        display.display_text_anywhere(95, 200, line6String, TextColours.GREEN)
    else:
        display.display_text_on_line(6, line6String, True, (TextAlignment.LEFT), TextColours.GREEN)
def showSimplifiedScreen(firstTime, summary):

    # extract just the data we want from the API result
    hardwareErrors = str(summary['SUMMARY'][0]['Hardware Errors'])
    avg = int(summary['SUMMARY'][0]['MHS av'])
    avgStr = convertSize(avg*1000000.0)
    avgMhs = "Average: " + avgStr
    
    # set up to write to the LCD screen
    #
    # Init the LCD screen
    display = LCDSysInfo()
    display.dim_when_idle(False)
    display.set_brightness(255)
    display.save_brightness(100, 255) 
    
    if (firstTime == True):
        display.clear_lines(TextLines.ALL, BackgroundColours.BLACK)

    display.display_text_on_line(1, str(poolURL), True, (TextAlignment.LEFT), TextColours.LIGHT_BLUE)
    display.display_text_on_line(2, "Uptime: \t" + upTime, True, (TextAlignment.LEFT, TextAlignment.RIGHT), TextColours.LIGHT_BLUE)
    display.display_text_on_line(3, avgMhs + "h/s", True, TextAlignment.LEFT, TextColours.LIGHT_BLUE)
    display.display_text_on_line(4, "HW Errors: " + hardwareErrors, True, TextAlignment.LEFT, TextColours.LIGHT_BLUE)
Пример #4
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

from pylcdsysinfo import BackgroundColours, TextColours, TextAlignment, TextLines, LCDSysInfo
from time import sleep

d = LCDSysInfo()
d.clear_lines(TextLines.ALL, BackgroundColours.BLACK)
d.dim_when_idle(False)
d.set_brightness(255)
d.save_brightness(127, 255)
d.set_text_background_colour(BackgroundColours.BLACK)
d.display_cpu_info(8010, 32, TextColours.RED, TextColours.WHITE)
d.display_ram_gpu_info(1994, 32, TextColours.RED, TextColours.GREEN)
d.display_network_info(1, 2, TextColours.RED, TextColours.GREEN, 0, 1) 
d.display_fan_info(1994, 1994, TextColours.RED, TextColours.GREEN)
for pos in range(0, 48):
    d.display_icon(pos, 1 + pos % 32)
d.clear_lines(63, BackgroundColours.WHITE)
d.set_text_background_colour(BackgroundColours.BLUE)
sleep(1)
for line in range(1, 7):
    d.display_text_on_line(line, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.", False, TextAlignment.LEFT, TextColours.WHITE)
Пример #5
0
def main_loop(bg=None, fg=None):
    update_display_period = 1  # number of seconds to wait before updating display
    floor = math.floor  # minor optimization

    if bg is None:
        bg = BackgroundColours.BLACK
    if fg is None:
        fg = TextColours.GREEN

    line_num = 3

    d = LCDSysInfo()
    d.clear_lines(TextLines.ALL, bg)
    d.dim_when_idle(False)
    d.set_brightness(127)
    d.save_brightness(127, 255)
    d.set_text_background_colour(bg)

    class Data(object):
        def __init__(self, d):
            self.d = d
            self.count = 0

    data = Data(owner)

    def onbuttondown(data):
        data.count += 1
        data.d.display_text_on_line(line_num, str(data.count), False, None, fg)

    read_wait(onbuttondown=functools.partial(onbuttondown, owner))
Пример #6
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

from __future__ import print_function
import sys
from pylcdsysinfo import LCDSysInfo

try:
    slot = int(sys.argv[1])
    if not 0 < slot <= 43:
        raise ValueError("Out of bounds")
except (ValueError, IndexError):
        print("Syntax: %s <1-43>" % (sys.argv[0]), file=sys.stderr)
        sys.exit(1)

d = LCDSysInfo()
d.display_icon(0, slot)
Пример #7
0
			d.display_text_on_line(lineCount+1, my_str[prev_n:n], False, TextAlignment.CENTRE, TextColours.CYAN)
			prev_n = n
			lineCount += 1
	return

try:
	# start the logger
	logging.basicConfig(filename='screen.log',format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p', level=logging.DEBUG)
	logging.info('Script Started!')

	# generate client name and connect to mqtt
	mypid = os.getpid()
	client_uniq = "pubclient_"+str(mypid)

	# set the screen up
	d = LCDSysInfo()
	d.clear_lines(TextLines.ALL, bg)
	d.dim_when_idle(False)
	d.set_brightness(127)
	d.save_brightness(127, 255)
	d.set_text_background_colour(bg)

	# connect mqtt
	connect()

	#remain connected and publis
	mqttc.loop_forever()

	# bad
	logging.info("Dropped out of the loop, Exiting")
	time.sleep(2)
Пример #8
0
class Screen():
    def __init__(self):
        self.lcd = LCDSysInfo()
        self.lcd.clear_lines(TextLines.ALL, BackgroundColours.BLACK)
        self.lcd.dim_when_idle(False)
        self.lcd.set_brightness(127)
        self.lcd.save_brightness(127, 127)

    def clear(self):
        self.lcd.clear_lines(TextLines.ALL, BackgroundColours.BLACK)

    def printc(self, data, sensors_to_display):
        line = 1
        for key in sensors_to_display:
            for sensor in data:
                if sensor['id'] == key:
                    value = str(sensor['value'])
                    txt = unicode(sensor['name'] + "\t " + value + "" + sensor['unit'])
                    txt = txt.replace(u"\u00B0", "^")
                    txt = unicodedata.normalize('NFKD', txt).encode('ascii', 'ignore')
                    print(txt)
                    self.lcd.display_text_on_line(line, txt, False, TextAlignment.LEFT, TextColours.LAVENDER)
                    line +=1
Пример #9
0
 def __init__(self):
     self.lcd = LCDSysInfo()
     self.lcd.clear_lines(TextLines.ALL, BackgroundColours.BLACK)
     self.lcd.dim_when_idle(False)
     self.lcd.set_brightness(127)
     self.lcd.save_brightness(127, 127)
Пример #10
0
def main_loop(bg=None, fg=None):
    update_display_period = 1  # number of seconds to wait before updating display
    floor = math.floor  # minor optimization
    
    if bg is None:
        bg = BackgroundColours.BLACK
    if fg is None:
        fg = TextColours.GREEN
    
    line_num = 3

    d = LCDSysInfo()
    d.clear_lines(TextLines.ALL, bg)
    d.dim_when_idle(False)
    d.set_brightness(127)
    d.save_brightness(127, 255)
    d.set_text_background_colour(bg)
    
    class Data(object):
        def __init__(self, d):
            self.d = d
            self.count = 0

    data = Data(owner)

    def onbuttondown(data):
        data.count += 1
        data.d.display_text_on_line(line_num, str(data.count), False, None, fg)

    read_wait(onbuttondown=functools.partial(onbuttondown, owner))
Пример #11
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

from pylcdsysinfo import LCDSysInfo, TextAlignment, TextColours
from time import sleep

d = LCDSysInfo()
while True:
    for c in range(0, 8):
        dest = 180 + (c * 38)
        d.display_icon(0, dest)
        d.display_text_on_line(1, "{{{" + str(c), False, TextAlignment.NONE, TextColours.WHITE)
        sleep(1)
Пример #12
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import sys
from pylcdsysinfo import LCDSysInfo, TextAlignment, TextColours

try:
    if int(sys.argv[1]) < 1 or int(sys.argv[1]) > 180:
        raise ValueError("Out of bounds")
except ValueError:
        print >>sys.stderr, "Syntax: %s <1-42>" % (sys.argv[0])
        sys.exit(1)

d = LCDSysInfo()
d.display_icon(0, int(sys.argv[1]))
def showDefaultScreen(firstTime, summary, mtgoxLastPrice, mtgoxDirectionCode,
                      toggleSinceLast, mtgoxToggleState):

    # extract just the data we want from the API result and
    #  build up display strings for each using the data

    avg = float(summary['SUMMARY'][0]['MHS av'])
    avgMhs = convertSize(avg * 1000000.0)
    foundBlocks = str(int(summary['SUMMARY'][0]['Found Blocks']))
    difficultyAccepted = "A:" + str(
        int(summary['SUMMARY'][0]['Difficulty Accepted']))
    if 'Pool Rejected%' in summary['SUMMARY'][0]:
        rej = str(summary['SUMMARY'][0]['Pool Rejected%'])
        if (rej == '0'):
            rejp = rej + "%"
        else:
            rejp = rej.split('.')[0] + "." + rej.split('.')[1][:2] + "%"
    else:
        rejp = str(int(summary['SUMMARY'][0]['Difficulty Rejected']))
    reject = "R:" + rejp
    if 'Device Hardware%' in summary['SUMMARY'][0]:
        hw = str(summary['SUMMARY'][0]['Device Hardware%'])
        if (hw == '0'):
            hwp = hw + "%"
        else:
            hwp = hw.split('.')[0] + "." + hw.split('.')[1][:2] + "%"
    else:
        hwp = str(int(summary['SUMMARY'][0]['Hardware Errors']))
    hardware = "HW:" + hwp
    bestShare = "S:" + convertSize(int(summary['SUMMARY'][0]['Best Share']))
    workUtility = "WU:" + str(summary['SUMMARY'][0]['Work Utility']) + "/m"

    # get current time, and format it per user selection
    theTime = ""
    time.ctime()  # formatted like this: 'Mon Oct 18 13:35:29 2010'
    if timeDisplayFormat == '12':
        theTime = time.strftime("%I:%M%p")  # 12 hour display
    else:
        theTime = time.strftime("%H:%M:%S")  # 24 hour display

    # strip common prefixes and suffixes off of the pool URL (to save display space)
    # TODO add code to remove all ":dddd" instead of adding port numbers to ignore
    commonStringPattern = [
        'http://', 'stratum+tcp://', 'stratum.', 'www.', '.com', 'mining.',
        ':3333', ':3334', ':8330'
    ]
    shortPoolURL = str(poolURL)
    for i in commonStringPattern:
        shortPoolURL = shortPoolURL.replace(i, '', 1).rstrip()

    # build the display strings
    line1String = shortPoolURL + "\t" + theTime
    line2String = "Uptime:  " + upTime
    line3String = "Avg:" + avgMhs + "h/s" + "  B:" + foundBlocks
    if int(foundBlocks) > 0:
        line3Colour = TextColours.RED
    else:
        line3Colour = TextColours.GREEN

    #line3String = "Avg:" + avgMhs + "\tB:" + foundBlocks
    line4String = difficultyAccepted + "  " + bestShare
    line5String = reject + "  " + hardware

    if mtgoxToggleState:  # if we have MtGox data, get ready to display it
        line6String = "MtGox: " + mtgoxLastPrice
    else:
        line6String = workUtility

    # set up to write to the LCD screen
    #
    # Init the LCD screen
    display = LCDSysInfo()
    display.dim_when_idle(False)
    display.set_brightness(255)
    display.save_brightness(100, 255)

    if (firstTime == True):
        # clear screen
        display.clear_lines(TextLines.ALL, BackgroundColours.BLACK)

    # write all lines
    display.display_text_on_line(1, line1String, True,
                                 (TextAlignment.LEFT, TextAlignment.RIGHT),
                                 TextColours.YELLOW)
    display.display_text_on_line(2, line2String, True,
                                 (TextAlignment.LEFT, TextAlignment.RIGHT),
                                 TextColours.LIGHT_BLUE)
    display.display_text_on_line(3, line3String, True, (TextAlignment.LEFT),
                                 line3Colour)
    display.display_text_on_line(4, line4String, True, (TextAlignment.LEFT),
                                 TextColours.GREEN)
    display.display_text_on_line(5, line5String, True, (TextAlignment.LEFT),
                                 TextColours.GREEN)

    # check to see if the mtgoxDisplay just toggled, if so, display black text to remove traces of previous icon
    if toggleSinceLast == True:
        display.display_text_anywhere(0, 197, '       ', TextColours.BLACK)

    if mtgoxToggleState == True:
        display.display_icon(
            41, mtgoxDirectionCode
        )  # directionCode should contain the icon number for up or down arrow
        display.display_text_anywhere(95, 200, line6String, TextColours.GREEN)
    else:
        display.display_text_on_line(6, line6String, True,
                                     (TextAlignment.LEFT), TextColours.GREEN)
Пример #14
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

from pylcdsysinfo import LCDSysInfo, TextAlignment, TextColours, large_image_indexes
from time import sleep

d = LCDSysInfo()
while True:
    for num, idx in enumerate(large_image_indexes):
        d.display_icon(0, idx)
        d.display_text_on_line(1, "{{{" + str(num), False, TextAlignment.NONE, TextColours.WHITE)
        sleep(1)
Пример #15
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import sys
from pylcdsysinfo import LCDSysInfo, large_image_indexes

try:
    slot = int(sys.argv[1])
    if not 0 <= slot <= 7:
        raise ValueError("Out of bounds")
except (ValueError, IndexError):
        print("Syntax: %s <0-7>" % (sys.argv[0]), file=sys.stderr)
        sys.exit(1)

d = LCDSysInfo()
d.display_icon(0, large_image_indexes[slot])
Пример #16
0
def getArrivalTime(stationcode, stationname):
    url = 'https://smrtfd18.herokuapp.com/webhook'
    payload = {
        'stationcode': stationcode,
        'key': 'MEtSAm6Tzl5PPT3bmLq1JqkFvcpXmKL2M7EWbq15'
    }

    r = requests.post(url, data=payload)

    output = json.loads(r.content)

    nextTrain = ''
    subTrain = ''
    nextTrainFinalDtn = ''
    j = 0

    d = LCDSysInfo()
    d.clear_lines(TextLines.ALL, BackgroundColours.BLACK)
    d.dim_when_idle(False)
    d.set_brightness(127)
    d.save_brightness(127, 255)
    d.set_text_background_colour(BackgroundColours.BLACK)

    for rows in output['Arrivals']:
        for x in output['Arrivals'][rows]:
            if x > 0:
                for y in output['Arrivals'][rows][x]:
                    print x, ':', y, ':', output['Arrivals'][rows][x][y]

                    if (y == 'nextTrainFinalDtn'):
                        nextTrainFinalDtn = output['Arrivals'][rows][x][
                            y].strip()
                        j += 1

                    if (y == 'nextTrain'):
                        str_ = str(output['Arrivals'][rows][x][y])
                        nextTrain = filter(str.isdigit, str_)
                        j += 1

                    if (y == 'subTrain'):
                        str_ = str(output['Arrivals'][rows][x][y])
                        subTrain = filter(str.isdigit, str_)
                        j += 1

                    if (j == 3):
                        print 'To: ', nextTrainFinalDtn, '> ', nextTrain, ' ', subTrain

                        if (nextTrainFinalDtn != ''):
                            clock_str = str(
                                datetime.datetime.now()).split('.')[0]

                            d.display_text_on_line(1, stationname, False,
                                                   TextAlignment.CENTRE,
                                                   TextColours.PINK)
                            d.display_text_on_line(
                                2, '---------------------------------------',
                                False, TextAlignment.CENTRE, TextColours.PINK)
                            d.display_text_on_line(3,
                                                   'To ' + nextTrainFinalDtn,
                                                   False, TextAlignment.CENTRE,
                                                   TextColours.GREEN)
                            d.display_text_on_line(
                                4, 'Next train: ' + nextTrain + ' min(s)',
                                False, TextAlignment.LEFT, TextColours.YELLOW)
                            d.display_text_on_line(
                                5, 'Sub. train: ' + subTrain + ' min(s)',
                                False, TextAlignment.LEFT, TextColours.CYAN)
                            d.display_text_on_line(6, clock_str, False,
                                                   TextAlignment.CENTRE,
                                                   TextColours.WHITE)

                            time.sleep(5)
                            d.clear_lines(TextLines.ALL,
                                          BackgroundColours.BLACK)

                        j = 0
Пример #17
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

from pylcdsysinfo import BackgroundColours, TextColours, TextAlignment, TextLines, LCDSysInfo
from time import sleep

d = LCDSysInfo()
d.clear_lines(TextLines.ALL, BackgroundColours.BLACK)
d.dim_when_idle(False)
d.set_brightness(255)
d.save_brightness(127, 255)
d.set_text_background_colour(BackgroundColours.BLACK)
d.display_cpu_info(8010, 32, TextColours.RED, TextColours.WHITE)
d.display_ram_gpu_info(1994, 32, TextColours.RED, TextColours.GREEN)
d.display_network_info(1, 2, TextColours.RED, TextColours.GREEN, 0, 1)
d.display_fan_info(1994, 1994, TextColours.RED, TextColours.GREEN)
for pos in range(0, 48):
    d.display_icon(pos, 1 + pos % 32)
d.clear_lines(63, BackgroundColours.WHITE)
d.set_text_background_colour(BackgroundColours.BLUE)
sleep(1)
for line in range(1, 7):
    d.display_text_on_line(
        line, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
        False, TextAlignment.LEFT, TextColours.WHITE)
Пример #18
0
def clock_loop(bg=None, fg=None):
    update_display_period = 1  # number of seconds to wait before updating display
    floor = math.floor  # minor optimization

    if bg is None:
        bg = BackgroundColours.BLACK
    if fg is None:
        fg = TextColours.WHITE

    line_num = 1

    d = LCDSysInfo()
    d.clear_lines(TextLines.ALL, bg)
    d.dim_when_idle(False)
    d.set_brightness(127)
    d.save_brightness(127, 255)
    d.set_text_background_colour(bg)

    jsonAfdak = domoticzData(805)
    jsonBuiten = domoticzData(16)
    jsonBinnen = domoticzData(447)
    jsonPower = domoticzData(616)

    d.display_text_on_line(2, 'Buiten:' + jsonBuiten['result'][0]['Data'], False, None, fg)
    d.display_text_on_line(3, 'Afdak:' + jsonAfdak['result'][0]['Data'], False, None, fg)
    d.display_text_on_line(4, 'Binnen:' + jsonBinnen['result'][0]['Data'], False, None, fg)
    d.display_text_on_line(5, 'Verbruik:' + jsonPower['result'][0]['Usage'], False, None, fg)
    d.display_text_on_line(6, 'Vandaag:' + jsonPower['result'][0]['CounterToday'], False, None, fg)

    #print(jsonBuiten['Result']['Name'])
    print(jsonBuiten['result'][0]['Data'])
    timeout = time.time() + 60*2

    while 1:
        clock_str = str(datetime.datetime.now()).split('.')[0]
        d.display_text_on_line(line_num, clock_str, False, None, fg)

        if (time.time() > timeout):
            break
        # Work out when to wake up for the next round/whole (non-fractional) time
        start_time = time.time()
        future_time = floor(start_time) + update_display_period  # pure float math
        sleep_time = future_time - start_time
        time.sleep(sleep_time)

    print('stopped after timeout')
    d.clear_lines(TextLines.ALL, bg)
    d.dim_when_idle(False)
    d.set_brightness(0)
    d.save_brightness(0, 255)
    d.set_text_background_colour(bg)
Пример #19
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import sys
from pylcdsysinfo import LCDSysInfo

try:
    slot = int(sys.argv[1])
    if not 0 < slot <= 43:
        raise ValueError("Out of bounds")
except (ValueError, IndexError):
        print("Syntax: %s <1-43>" % (sys.argv[0]), file=sys.stderr)
        sys.exit(1)

d = LCDSysInfo()
d.display_icon(0, slot)
Пример #20
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

from pylcdsysinfo import BackgroundColours, COL2LEFT, TextColours, TextAlignment, TextLines, LCDSysInfo
from time import sleep

d = LCDSysInfo()
d.clear_lines(TextLines.ALL, BackgroundColours.BLACK)
d.dim_when_idle(False)
d.set_brightness(255)
d.save_brightness(127, 255)

# System Info
d.set_text_background_colour(BackgroundColours.BLACK)
d.display_cpu_info(8010, 32, TextColours.RED, TextColours.WHITE)
d.display_ram_gpu_info(1994, 32, TextColours.RED, TextColours.GREEN)
d.display_network_info(1, 2, TextColours.RED, TextColours.GREEN, False, True)
d.display_fan_info(1994, 1994, TextColours.RED, TextColours.GREEN)

# All icons
for pos in range(0, 48):
    d.display_icon(pos, 1 + pos)
sleep(1)

# Arbitrary text drawing
d.clear_lines(TextLines.ALL, BackgroundColours.WHITE)
d.set_text_background_colour(BackgroundColours.BLUE)
for line in range(1, 7):
    d.display_text_on_line(line, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.", False, TextAlignment.LEFT, TextColours.WHITE)
sleep(1)
Пример #21
0
# handle the imports needed
from pylcdsysinfo import BackgroundColours, COL2LEFT, TextColours, TextAlignment, TextLines, LCDSysInfo
from time import sleep

# used to communicate with bitcoind rpc
import bitcoinrpc
from bitcoinrpc.exceptions import InsufficientFunds

# used to parse the webpage ticker data.
import urllib
import urllib2
import re

# Init the LCD screen
display = LCDSysInfo()
display.dim_when_idle(False)
display.clear_lines(TextLines.ALL, BackgroundColours.BLACK)
display.set_brightness(255)
display.save_brightness(100, 255)

# Connect to the remote bitcoind running on another machine (can be localhost too!)
# conn = bitcoinrpc.connect_to_remote('bbb6f1bd-b3aa-5c38-b8df-f0763e973aaa', 'BDBtoys1284', host='rpc.blockchain.info', port=8332)
conn = bitcoinrpc.connect_to_remote("greg", "socrates", host="192.168.69.40", port=8332)

# Grab the latest price from mtgox
aResp = urllib2.urlopen("http://data.mtgox.com/api/1/BTCUSD/ticker")
web_pg = aResp.read()

# read and 'strip' the resulting string so that it can be used.
# this is the response as string
Пример #22
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

from pylcdsysinfo import BackgroundColours, COL2LEFT, TextColours, TextAlignment, TextLines, LCDSysInfo
from time import sleep

d = LCDSysInfo()
d.clear_lines(TextLines.ALL, BackgroundColours.BLACK)
d.dim_when_idle(False)
d.set_brightness(255)
d.save_brightness(127, 255)

# System Info
d.set_text_background_colour(BackgroundColours.BLACK)
d.display_cpu_info(8010, 32, TextColours.RED, TextColours.WHITE)
d.display_ram_gpu_info(1994, 32, TextColours.RED, TextColours.GREEN)
d.display_network_info(1, 2, TextColours.RED, TextColours.GREEN, False, True)
d.display_fan_info(1994, 1994, TextColours.RED, TextColours.GREEN)

# All icons
for pos in range(0, 48):
    d.display_icon(pos, 1 + pos)
sleep(1)

# Arbitrary text drawing
d.clear_lines(TextLines.ALL, BackgroundColours.WHITE)
d.set_text_background_colour(BackgroundColours.BLUE)
for line in range(1, 7):
    d.display_text_on_line(
        line, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
        False, TextAlignment.LEFT, TextColours.WHITE)
Пример #23
0
from pylcdsysinfo import LCDSysInfo, TextAlignment, TextColours


def usage():
    print >> sys.stderr, "Usage: %s <icon 1-42> <imagefile>" % (sys.argv[0])
    sys.exit(1)


if len(sys.argv) != 3:
    usage()

try:
    if int(sys.argv[1]) < 1 or int(sys.argv[1]) > 42:
        raise ValueError("Out of bounds")
except ValueError:
    usage()

infile = sys.argv[2]

if not os.path.isfile(infile):
    print >> sys.stderr, "No such file '%s'" % (infile)
    sys.exit(1)

# Hack - redirect stderr to /dev/null to prevent noisy ffmpeg output
bmpfile = os.popen(
    "ffmpeg -f image2 -i %s -vcodec bmp -pix_fmt rgb565 -f image2 - 2>/dev/null"
    % (infile)).read()

d = LCDSysInfo()
d.write_image_to_flash(int(sys.argv[1]), bmpfile)
Пример #24
0
import time
import datetime
import xbmc
import xbmcaddon
import textwrap

__settings__ = xbmcaddon.Addon(id='script.service.lcdsysinfo')
__cwd__ = __settings__.getAddonInfo('path')
BASE_RESOURCE_PATH = xbmc.translatePath(os.path.join( __cwd__, 'resources', 'lib'))
sys.path.append (BASE_RESOURCE_PATH)
from pylcdsysinfo import LCDSysInfo, TextLines, BackgroundColours, TextColours

bg = BackgroundColours.BLACK
fg = TextColours.GREEN

d = LCDSysInfo()
d.clear_lines(TextLines.ALL, bg)
d.dim_when_idle(False)
d.set_brightness(127)
d.save_brightness(127, 255)
d.set_text_background_colour(bg)

def draw_lines(lines, first = 0):
  for i in range(0, (6 - first)):
    d.clear_lines(1 << (first + i), bg)
    if i < len(lines):
      d.display_text_on_line(1 + first + i, lines[i], False, None, fg)

draw_lines(['starting desu ...'])

p = xbmc.Player()
Пример #25
0
#!/usr/bin/env python

import sys, os
from pylcdsysinfo import LCDSysInfo, TextAlignment, TextColours

def usage():
    print >>sys.stderr, "Usage: %s <slot 0-7> <imagefile>" % (sys.argv[0])
    sys.exit(1)

if len(sys.argv) != 3:
    usage()

try:
    if int(sys.argv[1]) < 0 or int(sys.argv[1]) > 7:
        raise ValueError("Out of bounds")
except ValueError:
    usage()

infile = sys.argv[2]

if not os.path.isfile(infile):
    print >>sys.stderr, "No such file '%s'" % (infile)
    sys.exit(1)

# Hack - redirect stderr to /dev/null to prevent noisy ffmpeg output
bmpfile = os.popen("ffmpeg -f image2 -i %s -vcodec bmp -pix_fmt rgb565 -f image2 - 2>/dev/null" % (infile)).read()

d = LCDSysInfo()
d.write_image_to_flash(180 + int(sys.argv[1]) * 38, bmpfile)
Пример #26
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import sys
from pylcdsysinfo import LCDSysInfo, TextAlignment, TextColours

try:
    if int(sys.argv[1]) < 0 or int(sys.argv[1]) > 7:
        raise ValueError("Out of bounds")
except ValueError:
    print >> sys.stderr, "Syntax: %s <0-7>" % (sys.argv[0])
    sys.exit(1)

d = LCDSysInfo()
d.display_icon(0, 180 + int(sys.argv[1]) * 38)
Пример #27
0
def usage():
    print("Usage: %s <icon 1-42> <imagefile>" % (sys.argv[0]), file=sys.stderr)
    sys.exit(1)


if len(sys.argv) != 3:
    usage()

try:
    slot = int(sys.argv[1])
    if not 0 < slot <= 42:
        raise ValueError("Out of bounds")
except (ValueError, IndexError):
    usage()

infile = sys.argv[2]

if not os.path.isfile(infile):
    print("No such file '%s'" % (infile), file=sys.stderr)
    sys.exit(1)

# Hack - redirect stderr to /dev/null to prevent noisy ffmpeg output
bmpfile = subprocess.Popen(
    "ffmpeg -f image2 -i %s -vcodec bmp -pix_fmt rgb565 -f image2 - 2>/dev/null"
    % (infile),
    shell=True,
    stdout=subprocess.PIPE).stdout.read()

d = LCDSysInfo()
d.write_image_to_flash(slot, bmpfile)
Пример #28
0
try:
    slot = int(sys.argv[1])
    if not 0 < slot <= 42:
        raise ValueError("Out of bounds")
except (ValueError, IndexError):
    usage()

infile = sys.argv[2]

if not os.path.isfile(infile):
    print("No such file '%s'" % (infile), file=sys.stderr)
    sys.exit(1)

if pylcdsysinfo.Image:
    im = pylcdsysinfo.Image.open(infile)
    im = pylcdsysinfo.simpleimage_resize(im, (36, 36))
    rawfile = pylcdsysinfo.image_to_raw(im)
else:
    # lets hope ffmpeg is available......
    print('PIL not available, fallback to spawning ffmpeg')
    # Hack - redirect stderr to /dev/null to prevent noisy ffmpeg output
    bmpfile = subprocess.Popen("ffmpeg -f image2 -i %s -vcodec bmp -pix_fmt rgb565 -f image2 - 2>/dev/null" % (infile),
        shell=True, stdout=subprocess.PIPE).stdout.read()

d = LCDSysInfo()
if pylcdsysinfo.Image:
    d.write_rawimage_to_flash(slot, rawfile)
else:
    d.write_image_to_flash(slot, bmpfile)
def displayErrorScreen(e):
      
    # set up to write to the LCD screen
    #
    # Init the LCD screen
    display = LCDSysInfo()
    display.dim_when_idle(False)
    display.set_brightness(255)
    display.save_brightness(100, 255)
    
    # Always clear the whole screen
    display.clear_lines(TextLines.ALL, BackgroundColours.BLACK)
    display.display_text_on_line(3, "Error: Check Miner", True, (TextAlignment.LEFT), TextColours.RED)
    display.display_text_on_line(4, e, True, (TextAlignment.LEFT), TextColours.RED)
Пример #30
0
def showSimplifiedScreen(firstTime, summary):

    # extract just the data we want from the API result
    hardwareErrors = str(summary['SUMMARY'][0]['Hardware Errors'])
    avg = int(summary['SUMMARY'][0]['MHS av'])
    avgStr = convertSize(avg*1000000.0)
    avgMhs = "Average: " + avgStr
    
    # set up to write to the LCD screen
    #
    # Init the LCD screen
    display = LCDSysInfo()
    display.dim_when_idle(False)
    display.set_brightness(255)
    display.save_brightness(100, 255) 
    
    if (firstTime == True):
        display.clear_lines(TextLines.ALL, BackgroundColours.BLACK)

    display.display_text_on_line(1, str(poolURL), True, (TextAlignment.LEFT), TextColours.LIGHT_BLUE)
    display.display_text_on_line(2, "Uptime: \t" + upTime, True, (TextAlignment.LEFT, TextAlignment.RIGHT), TextColours.LIGHT_BLUE)
    display.display_text_on_line(3, avgMhs + "h/s", True, TextAlignment.LEFT, TextColours.LIGHT_BLUE)
    display.display_text_on_line(4, "HW Errors: " + hardwareErrors, True, TextAlignment.LEFT, TextColours.LIGHT_BLUE)
Пример #31
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import binascii
from pylcdsysinfo import LCDSysInfo

d = LCDSysInfo()
info = d.get_device_info()


def b2h(ba):
    """Convert byte array to hyphen separated hex string."""
    return '-'.join(["%02X" % i for i in ba]).strip()


print """Serial number: %s
Flash Id: %s
EEPROM Data: %s
Device Valid: %s
8Mb Flash: %s
Picture Frame Mode: %s
""" % (
    b2h(info['serial']),
    b2h(info['flash_id']),
    b2h(info['eeprom']),
    info['device_valid'],
    info['8mb_flash'],
    info['picture_frame_mode'],
),
Пример #32
0
def displayErrorScreen(e):
      
    # set up to write to the LCD screen
    #
    # Init the LCD screen
    display = LCDSysInfo()
    display.dim_when_idle(False)
    display.set_brightness(255)
    display.save_brightness(100, 255)
    
    # Always clear the whole screen
    display.clear_lines(TextLines.ALL, BackgroundColours.BLACK)
    display.display_text_on_line(3, "Error: Check Miner", True, (TextAlignment.LEFT), TextColours.RED)
    display.display_text_on_line(4, e, True, (TextAlignment.LEFT), TextColours.RED)
Пример #33
0
try:
    slot = int(sys.argv[1])
    if not 0 <= slot <= 7:
        raise ValueError("Out of bounds")
except (ValueError, IndexError):
    usage()

infile = sys.argv[2]

if not os.path.isfile(infile):
    print("No such file '%s'" % (infile), file=sys.stderr)
    sys.exit(1)

if pylcdsysinfo.Image:
    im = pylcdsysinfo.Image.open(infile)
    im = pylcdsysinfo.simpleimage_resize(im)
    rawfile = pylcdsysinfo.image_to_raw(im)
else:
    # lets hope ffmpeg is available......
    print('PIL not available, fallback to spawning ffmpeg')
    # Hack - redirect stderr to /dev/null to prevent noisy ffmpeg output
    bmpfile = subprocess.Popen("ffmpeg -f image2 -i %s -vcodec bmp -pix_fmt rgb565 -f image2 - 2>/dev/null" % (infile),
        shell=True, stdout=subprocess.PIPE).stdout.read()

d = LCDSysInfo()
if pylcdsysinfo.Image:
    d.write_rawimage_to_flash(large_image_indexes[slot], rawfile)
else:
    d.write_image_to_flash(large_image_indexes[slot], bmpfile)
Пример #34
0
def showDefaultScreen(firstTime, summary):

    # extract just the data we want from the API result and
    #  build up display strings for each using the data
        
    avg = float(summary['SUMMARY'][0]['MHS av'])
    avgMhs = convertSize(avg*1000000.0)
    foundBlocks = str(int(summary['SUMMARY'][0]['Found Blocks']))    
    difficultyAccepted = "A:" + str(int(summary['SUMMARY'][0]['Difficulty Accepted']))
    if 'Pool Rejected%' in summary['SUMMARY'][0]:
        rej = str(summary['SUMMARY'][0]['Pool Rejected%'])
        if (rej == '0'):
            rejp = rej + "%"
        else:
            rejp = rej.split('.')[0] + "." + rej.split('.')[1][:2] + "%"
    else:
        rejp = str(int(summary['SUMMARY'][0]['Difficulty Rejected']))
    reject = "R:" + rejp
    if 'Device Hardware%' in summary['SUMMARY'][0]:
        hw = str(summary['SUMMARY'][0]['Device Hardware%'])
        if (hw == '0'):
            hwp = hw + "%"
        else:
            hwp = hw.split('.')[0] + "." + hw.split('.')[1][:2] + "%"
    else:
        hwp = str(int(summary['SUMMARY'][0]['Hardware Errors']))
    hardware = "HW:" + hwp
    bestShare = "S:" + convertSize(int(summary['SUMMARY'][0]['Best Share']))
    workUtility = "WU:" + str(summary['SUMMARY'][0]['Work Utility']) + "/m"
   
    # get current time, and format it per user selection
    theTime = ""   
    time.ctime() # formatted like this: 'Mon Oct 18 13:35:29 2010'
    if timeDisplayFormat == '12':
        theTime = time.strftime("%I:%M%p")  # 12 hour display
    else:    
        theTime = time.strftime("%H:%M:%S")  # default to 24 hour display

    # strip common prefixes and suffixes off of the pool URL (to save display space)
    commonStringPattern = ['stratum+tcp://', 'stratum.', 'www.', '.com', 'mining.', ':3333', ':3334']  
    shortPoolURL = str(poolURL)
    for i in commonStringPattern:
        shortPoolURL = shortPoolURL.replace(i, '', 1).rstrip()   
      
    # build the display strings
    line1String = shortPoolURL + "\t" + theTime
    line2String = "Uptime:  " + upTime
    line3String = "Avg:" + avgMhs + "h/s" + "  B:" + foundBlocks
    #line3String = "Avg:" + avgMhs + "\tB:" + foundBlocks
    line4String = difficultyAccepted + "  " + bestShare
    line5String = reject + "  " + hardware
    line6String = workUtility
        
    # set up to write to the LCD screen
    #
    # Init the LCD screen
    display = LCDSysInfo()
    display.dim_when_idle(False)
    display.set_brightness(255)
    display.save_brightness(100, 255)
    
    if (firstTime == True):
        # clear screen
        display.clear_lines(TextLines.ALL, BackgroundColours.BLACK)

    # write all lines
    display.display_text_on_line(1, line1String, True, (TextAlignment.LEFT, TextAlignment.RIGHT), TextColours.YELLOW)
    display.display_text_on_line(2, line2String, True, (TextAlignment.LEFT, TextAlignment.RIGHT), TextColours.LIGHT_BLUE)    
    display.display_text_on_line(3, line3String, True, (TextAlignment.LEFT), TextColours.GREEN)
    display.display_text_on_line(4, line4String, True, (TextAlignment.LEFT), TextColours.GREEN)
    display.display_text_on_line(5, line5String, True, (TextAlignment.LEFT), TextColours.GREEN)
    display.display_text_on_line(6, line6String, True, (TextAlignment.LEFT), TextColours.GREEN)
Пример #35
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import sys
from pylcdsysinfo import LCDSysInfo, TextAlignment, TextColours

try:
    if int(sys.argv[1]) < 0 or int(sys.argv[1]) > 7:
        raise ValueError("Out of bounds")
except ValueError:
        print >>sys.stderr, "Syntax: %s <0-7>" % (sys.argv[0])
        sys.exit(1)


d = LCDSysInfo()
d.display_icon(0, 180 + int(sys.argv[1]) * 38)
Пример #36
0
#!/usr/bin/env python

import sys, os
from pylcdsysinfo import LCDSysInfo, TextAlignment, TextColours

def usage():
    print >>sys.stderr, "Usage: %s <icon 1-42> <imagefile>" % (sys.argv[0])
    sys.exit(1)

if len(sys.argv) != 3:
    usage()

try:
    if int(sys.argv[1]) < 1 or int(sys.argv[1]) > 42:
        raise ValueError("Out of bounds")
except ValueError:
    usage()

infile = sys.argv[2]

if not os.path.isfile(infile):
    print >>sys.stderr, "No such file '%s'" % (infile)
    sys.exit(1)

# Hack - redirect stderr to /dev/null to prevent noisy ffmpeg output
bmpfile = os.popen("ffmpeg -f image2 -i %s -vcodec bmp -pix_fmt rgb565 -f image2 - 2>/dev/null" % (infile)).read()

d = LCDSysInfo()
d.write_image_to_flash(int(sys.argv[1]), bmpfile)
Пример #37
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

from pylcdsysinfo import BackgroundColours, TextColours, TextAlignment, TextLines, LCDSysInfo
from time import sleep

d = LCDSysInfo()
d.clear_lines(TextLines.ALL, BackgroundColours.BLACK)
d.dim_when_idle(False)
d.set_brightness(127)
d.save_brightness(127, 255)
d.set_text_background_colour(BackgroundColours.BLACK)

f = open('yw', 'r')
c = 1
col = TextColours.GREEN
for line in f:
        if c == 2:
                col = TextColours.PURPLE
        if c == 3:
                col = TextColours.YELLOW
        if c == 4:
                col = TextColours.LIGHT_BLUE
        if c == 5:
                col = TextColours.ORANGE
        if c == 6:
                col = TextColours.RED

        d.display_text_on_line(c, line, False, TextAlignment.LEFT, col)
        c = c + 1
        if c > 6:
Пример #38
0
from pylcdsysinfo import BackgroundColours, TextColours, TextAlignment, TextLines, LCDSysInfo
from time import sleep

hostname=socket.gethostname()

#Get IP address and concatenate with "IP: " string
ipaddress=socket.gethostbyname(hostname)
ipstring="IP: " + ipaddress
print(ipstring)

if sys.platform == 'darwin':
    ipaddress=socket.gethostbyname(hostname)
    print("Mac detected")
    

d = LCDSysInfo()
d.clear_lines(TextLines.ALL, BackgroundColours.BLACK)
d.dim_when_idle(False)
d.set_brightness(255)
d.save_brightness(127, 255)
d.set_text_background_colour(BackgroundColours.BLACK)

#d.display_cpu_info(8010, 32, TextColours.RED, TextColours.WHITE)
#d.display_ram_gpu_info(1994, 32, TextColours.RED, TextColours.GREEN)
#d.display_network_info(1, 2, TextColours.RED, TextColours.GREEN, 0, 1) 
#d.display_fan_info(1994, 1994, TextColours.RED, TextColours.GREEN)

d.display_text_on_line(2, "Hostname: ", True, TextAlignment.LEFT, TextColours.GREEN)
d.display_text_on_line(3, hostname, True, TextAlignment.LEFT, TextColours.GREEN)
d.display_text_on_line(4, ipstring, True, TextAlignment.LEFT, TextColours.WHITE)
#d.display_text_on_line(5, ipaddress, True, TextAlignment.LEFT, TextColours.WHITE)
Пример #39
0
class EventHandler(pyinotify.ProcessEvent):
    last_updated = 0

    def __init__(self, path):
        super(EventHandler, self).__init__()
        self.lcd = LCDSysInfo()
        self.lcd.set_brightness(BRIGHTNESS)
        self.lcd.dim_when_idle(False)
        self.lcd.clear_lines(TextLines.ALL, BGCOLOR)
        self.old_lines = [''] * 6
        self.path = path

    @staticmethod
    def fmt_task(task):
        try:
            if task.startswith('+'):
                task = '+ ' + task[1:]
            else:
                task = '- ' + task
            return '____%s' % task
        except AttributeError as err:
            return '- %s' % err

    @staticmethod
    def _parse_todos(path):
        with open(path, 'rU') as fobj:
            yobj = yaml.safe_load_all(fobj)


            # Python 2/3 adapter
            if hasattr(yobj, 'next'):
                yobj_next = yobj.next
            elif hasattr(yobj, '__next__'):
                yobj_next = yobj.__next__
            else:
                raise Exception("Python is broken")

            # Skip header text
            yobj_next()

            return yobj_next() or {}

    def process_IN_MODIFY(self, event):
        # Workaround for race condition when using IN_MODIFY
        # (Because IN_CLOSE_WRITE | IN_MOVED_TO doesn't fire with Leafpad)
        this_stat, waited = os.stat(self.path), 0
        while this_stat.st_size == 0 and waited < 3:
            time.sleep(0.3)
            this_stat = os.stat(self.path)
            waited += 0.3

        # Ensure we fire only once per change
        if self.last_updated == this_stat.st_mtime:
            return

        try:
            data = self._parse_todos(self.path)
        except BaseException as err:
            log.debug("Couldn't parse data from file: %s", self.path)
            lines = ["Error parsing TODO YAML",
                     "%d bytes" % this_stat.st_size,
                     "",
                     str(err)]
            print(err)
        else:
            tasks = data.get('TODO', None)
            if tasks:
                lines = ["TODO:"] + [self.fmt_task(x) for x in tasks]
            else:
                lines = ["No TODOs found"]

        # Waste as little time as possible overwriting lines that haven't
        # changed
        for pos, line in enumerate(lines[:6]):
            if line != self.old_lines[pos]:
                # Work around the ASCII-only-ness of the USBLCD API
                if isinstance(line, bytes):
                    line = line.decode('utf8', 'replace')
                line = unidecode(line)

                self.lcd.display_text_on_line(pos + 1, line, False,
                                         TextAlignment.LEFT, FGCOLOR)
                self.old_lines[pos] = line

        # Only erase lines that used to have something on them
        mask = 0
        for pos in range(len(lines), 6):
            if self.old_lines[pos]:
                mask += 1 << int(pos)
                self.old_lines[pos] = ''
        if mask:
            self.lcd.clear_lines(mask, BGCOLOR)

        # Only update this if we successfuly parsed and applied an update
        self.last_updated = this_stat.st_mtime
Пример #40
0
#handle the imports needed
from pylcdsysinfo import BackgroundColours, COL2LEFT, TextColours, TextAlignment, TextLines, LCDSysInfo, time
from time import sleep

#used to communicate with bitcoind rpc
import bitcoinrpc
from bitcoinrpc.exceptions import InsufficientFunds

#used to parse the webpage ticker data.
import urllib
import urllib2
import re

while True:
    # Init the LCD screen
    display = LCDSysInfo()
    display.dim_when_idle(False)
    display.clear_lines(TextLines.ALL, BackgroundColours.BLACK)
    display.set_brightness(255)
    display.save_brightness(100, 255)
    
    #Connect to the remote bitcoind running on another machine (can be localhost too!)
    #conn = bitcoinrpc.connect_to_remote('greg', 'socrates', host='192.168.69.40', port=8332)
    
    #Grab the latest price from mtgox
    aResp = urllib2.urlopen("http://data.mtgox.com/api/1/BTCUSD/ticker");
    web_pg = aResp.read();
    
    #read and 'strip' the resulting string so that it can be used.
    #this is the response as string
    str1 = str(web_pg);
Пример #41
0
#handle the imports needed
from pylcdsysinfo import BackgroundColours, COL2LEFT, TextColours, TextAlignment, TextLines, LCDSysInfo
from time import sleep

#used to communicate with bitcoind rpc
import bitcoinrpc
from bitcoinrpc.exceptions import InsufficientFunds

#used to parse the webpage ticker data.
import urllib
import urllib2
import re

# Init the LCD screen
display = LCDSysInfo()
display.dim_when_idle(False)
display.clear_lines(TextLines.ALL, BackgroundColours.BLACK)
display.set_brightness(255)
display.save_brightness(100, 255)


#Grab LTC
aResp = urllib2.urlopen("https://btc-e.com/api/2/ltc_usd/ticker");
web_pg1 = aResp.read();
#Grab BTC
aResp = urllib2.urlopen("http://data.mtgox.com/api/1/BTCUSD/ticker");
web_pg2 = aResp.read();
#BTC-E BTC
aResp = urllib2.urlopen("https://btc-e.com/api/2/btc_usd/ticker");
web_pg3 = aResp.read();
Пример #42
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import binascii
from pylcdsysinfo import LCDSysInfo

d = LCDSysInfo()
info = d.get_device_info()

def b2h(ba):
    """Convert byte array to hyphen separated hex string."""
    return '-'.join(["%02X" % i for i in ba]).strip()

print """Serial number: %s
Flash Id: %s
EEPROM Data: %s
Device Valid: %s
8Mb Flash: %s
Picture Frame Mode: %s
""" % (
    b2h(info['serial']),
    b2h(info['flash_id']),
    b2h(info['eeprom']),
    info['device_valid'],
    info['8mb_flash'],
    info['picture_frame_mode'],
),
Пример #43
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import sys
from pylcdsysinfo import LCDSysInfo, TextAlignment, TextColours

try:
    if int(sys.argv[1]) < 1 or int(sys.argv[1]) > 180:
        raise ValueError("Out of bounds")
except ValueError:
    print >> sys.stderr, "Syntax: %s <1-42>" % (sys.argv[0])
    sys.exit(1)

d = LCDSysInfo()
d.display_icon(0, int(sys.argv[1]))
Пример #44
0
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

from __future__ import print_function
import sys
from pylcdsysinfo import LCDSysInfo, large_image_indexes

try:
    slot = int(sys.argv[1])
    if not 0 <= slot <= 7:
        raise ValueError("Out of bounds")
except (ValueError, IndexError):
        print("Syntax: %s <0-7>" % (sys.argv[0]), file=sys.stderr)
        sys.exit(1)

d = LCDSysInfo()
d.display_icon(0, large_image_indexes[slot])
Пример #45
0
def clock_loop(bg=None, fg=None):
    update_display_period = 1  # number of seconds to wait before updating display
    floor = math.floor  # minor optimization
    
    if bg is None:
        bg = BackgroundColours.BLACK
    if fg is None:
        fg = TextColours.GREEN
    
    line_num = 3

    d = LCDSysInfo()
    d.clear_lines(TextLines.ALL, bg)
    d.dim_when_idle(False)
    d.set_brightness(127)
    d.save_brightness(127, 255)
    d.set_text_background_colour(bg)

    while 1:
        clock_str = str(datetime.datetime.now()).split('.')[0]
        d.display_text_on_line(line_num, clock_str, False, None, fg)
        
        # Work out when to wake up for the next round/whole (non-fractional) time
        start_time = time.time()
        future_time = floor(start_time) + update_display_period  # pure float math
        sleep_time = future_time - start_time
        time.sleep(sleep_time)
Пример #46
0
def main():
	uptime = getUptime()

	bg = BackgroundColours.BLACK
	fb = TextColours.WHITE

	
	d = LCDSysInfo()
	d.clear_lines(TextLines.ALL, bg)
	d.dim_when_idle(False)
	d.set_brightness(127)
	d.save_brightness(127, 255)
	d.set_text_background_colour(bg)

	d.display_text_on_line(3, "Uptime:", False, None, fb)
	d.display_text_on_line(4, uptime, False, None, fb)