def startUp():
  log("Starting up ThexBerryClock...")
  global TBC, iterations, itime

  iterations = 0
  itime = int(time.time())
  TBC = {}
  TBC['epoch']=datetime.datetime.utcfromtimestamp(0)
  TBC['bhdisplay'] = 0
  TBC['sleep'] = 0.01
  TBC['clockmode'] = effect_startupSplash
  TBC['bitcoin'] = 0
  TBC['btcopen'] = 0
  TBC['rainbowBorderMode'] = 0
  TBC['timers'] = {'bitcoin':0,'bhflipper':0};
  TBC['timerFreqList'] = {'bitcoin':60,'bhflipper':10};
  TBC['timerFuncList'] = {'bitcoin':getBitcoinPrice,'bhflipper':blockheight_flipDisplay};
  TBC['matrix'] = RGBMatrix(32, 2)
  TBC['matrix'].pwmBits = 11
  TBC['matrix'].brightness = 50
  TBC['canvas'] = TBC['matrix'].CreateFrameCanvas()
  TBC['font'] = ImageFont.load(basePath + "/pilfonts/timR08.pil")
  TBC['blockheight'] = 0
  thread.start_new_thread( startup_blockheight, () )
  signal.signal(signal.SIGUSR1, interruptHandler)
Example #2
0
class LedService:
	def __init__(self):
		print "Loading LED configurations"
		
		with open('led.json', 'r') as f:
			self.data = json.load(f)
			f.close()
		
		self.rows = self.data["settings"]["rows"]
		self.chain = self.data["settings"]["chain"]
		self.parallel = self.data["settings"]["parallel"]
		print (self.rows, self.chain, self.parallel)
		
		self.matrix = RGBMatrix(self.rows, self.chain, self.parallel)
		
	def dowork(self):
		print "Loading scene"
	

	def run(self):
		print "Starting LED service"
	
		self._thread = threading.Thread(target=self.dowork)
		self._thread.setDaemon(True)
		self._thread.start()
		
		
	def stop(self):
		self.matrix.clear()
	def __init__(self):
		matrix = RGBMatrix(rows, chain, parallel)
		matrix.pwmBits = pwmbits
		matrix.brightness = brightness
		matrix.luminanceCorrect = luminance
		self.canvas = matrix
		self.font = graphics.Font()
		self.font.LoadFont(font_file)
		self.font_twitter = graphics.Font()
		self.font_twitter.LoadFont(font_file_twitter)
		self.color = graphics.Color(color_codeR, color_codeG, color_codeB)
		self.pos = self.canvas.width
		#self.tweet = "Cakam na tweet :D"
		#self.Twitter()
		self.offscreenCanvas = self.canvas.CreateFrameCanvas()
Example #4
0
	def __init__(self):
		print "Loading LED configurations"
		
		with open('led.json', 'r') as f:
			self.data = json.load(f)
			f.close()
		
		self.rows = self.data["settings"]["rows"]
		self.chain = self.data["settings"]["chain"]
		self.parallel = self.data["settings"]["parallel"]
		print (self.rows, self.chain, self.parallel)
		
		self.matrix = RGBMatrix(self.rows, self.chain, self.parallel)
Example #5
0
class LedDisplay:
    def __init__(self):
        # Configuration for the matrix
        options = RGBMatrixOptions()
        options.rows = 32
        options.cols = 32
        options.chain_length = 1
        options.parallel = 1
        options.gpio_slowdown = 5
        options.hardware_mapping = 'adafruit-hat'

        # Enter in the hardware configurations
        self.matrix = RGBMatrix(options=options)

        # Specifications for Font style of text
        self.font = graphics.Font()
        self.font.LoadFont("rpi-rgb-led-matrix/fonts/4x6.bdf")
        self.textColor = graphics.Color(100, 100, 100)
        self.fontWidth = 4
        self.fontHeight = 6

        self.canvas = self.matrix.CreateFrameCanvas()

    def clear(self):
        self.matrix.Clear()
        self.canvas.Clear()

    def show(self, info):
        # first attempt at code that will print multiple lines, could be rerwitten to be easier
        if type(info) == tuple:
            self.fontHeight = 6  # random constant depending on which font is chosen
            index = self.fontHeight  # First line in which text can be placed on matrix

            for elem in info:
                graphics.DrawText(self.canvas, self.font, 0, index,
                                  self.textColor, elem)
                index += self.fontHeight  # move to next line on matrix

            self.canvas = self.matrix.SwapOnVSync(self.canvas)

        elif type(info) == str:
            if len(info) > 8:
                pos = self.canvas.width
                while True:
                    self.canvas.Clear()
                    length = graphics.DrawText(self.canvas, self.font, pos, 10,
                                               self.textColor, info)
                    pos -= 1
                    if (pos + length < 0):
                        pos = self.canvas.width

                    time.sleep(0.05)
                    self.canvas = self.matrix.SwapOnVSync(self.canvas)
            else:
                graphics.DrawText(self.canvas, self.font, 0, 10,
                                  self.textColor, info)
                self.canvas = self.matrix.SwapOnVSync(self.canvas)

        elif type(info) == list:
            for r in range(self.matrix.height):
                for c in range(self.matrix.width):
                    R, G, B = info[r][c]
                    self.canvas.SetPixel(r, c, R, G, B)
            self.canvas = self.matrix.SwapOnVSync(self.canvas)

        else:
            print("Invalid input: must be a tuple or a list")
            raise ValueError

    def getTextDimensions(self):
        return int(self.matrix.height / self.fontHeight), int(
            self.matrix.width / self.fontWidth)
Example #6
0
from rgbmatrix import RGBMatrix, RGBMatrixOptions
from PIL import Image

if len(sys.argv) < 2:
    sys.exit("Require an image argument")
else:
    image_file = sys.argv[1]

image = Image.open(image_file)

# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = 32
options.chain_length = 1
options.parallel = 1
options.hardware_mapping = 'regular'  # If you have an Adafruit HAT: 'adafruit-hat'

matrix = RGBMatrix(options=options)

# Make image fit our screen.
image = image.resize((matrix.width, matrix.height), Image.ANTIALIAS)

matrix.SetImage(image.convert('RGB'))

try:
    print("Press CTRL-C to stop.")
    while True:
        time.sleep(100)
except KeyboardInterrupt:
    sys.exit(0)
Example #7
0
class Display(threading.Thread):
    def __init__(self, dimmer):
        #def __init__(self, weather, dimmer):
        threading.Thread.__init__(self)
        self.setDaemon(True)

        # Options
        options = RGBMatrixOptions()
        options.pwm_lsb_nanoseconds = 400
        options.rows = 32
        options.cols = 64

        #self._weather = weather
        self._dimmer = dimmer

        # Configure LED matrix driver
        #self._matrix = RGBMatrix(32, 2, 1)
        self._matrix = RGBMatrix(options=options)
        self._matrix.pwmBits = 11
        self._matrix.brightness = 20

        # Load fonts
        self._font_large = graphics.Font()
        self._font_large.LoadFont("rpi-rgb-led-matrix/fonts/10x20.bdf")
        self._font_small = graphics.Font()
        self._font_small.LoadFont("rpi-rgb-led-matrix/fonts/6x10.bdf")
        self._font_tiny = graphics.Font()
        self._font_tiny.LoadFont("rpi-rgb-led-matrix/fonts/4x6.bdf")

        # Define colors
        self._white = graphics.Color(255, 255, 255)
        self._red = graphics.Color(255, 32, 32)
        self._blue = graphics.Color(64, 64, 255)
        rgbtupl = self.random_color()
        #rgbtupl = self.colorsX(3)
        self._randcolorH = graphics.Color(int(rgbtupl[0]), int(rgbtupl[1]),
                                          int(rgbtupl[2]))
        rgbtupl = self.random_color()
        self._randcolorCollon = graphics.Color(int(rgbtupl[0]),
                                               int(rgbtupl[1]),
                                               int(rgbtupl[2]))
        rgbtupl = self.random_color()
        self._randcolorM = graphics.Color(int(rgbtupl[0]), int(rgbtupl[1]),
                                          int(rgbtupl[2]))
        #self._randcolorH = graphics.Color(randint(100, 255), randint(100, 255), randint(100, 255))
        #self._randcolorCollon = graphics.Color(randint(100, 255), randint(100, 255), randint(100, 255))
        #self._randcolorM = graphics.Color(randint(100, 255), randint(100, 255), randint(100, 255))

    def random_color(self):
        num1 = randint(100, 255)
        num2 = randint(10, 255)
        num3 = 250 % num1
        rgbl = [num1, num2, num3]
        shuffle(rgbl)
        print rgbl
        return tuple(rgbl)

    def colorsX(n):
        ret = []
        r = int(random.random() * 256)
        g = int(random.random() * 256)
        b = int(random.random() * 256)
        step = 256 / n
        for i in range(n):
            r += step
            g += step
            b += step
            r = int(r) % 256
            g = int(g) % 256
            b = int(b) % 256
            ret.append((r, g, b))
            return ret

    def _draw(self, canvas):
        # Remember this is a loop so dont generate colors here
        # otherwise they will be blinking and changing constantly
        # do it in above function instead
        canvas.Clear()
        locale.setlocale(locale.LC_TIME, "sv_SE.utf8")

        #graphics.DrawText(canvas, self._font_large, 1, 13, self._white, time.strftime("%-2I:%M"))
        graphics.DrawText(canvas, self._font_large, 5, 16, self._randcolorH,
                          time.strftime("%H"))
        graphics.DrawText(canvas, self._font_large, 25, 16,
                          self._randcolorCollon, time.strftime(":"))
        graphics.DrawText(canvas, self._font_large, 35, 16, self._randcolorM,
                          time.strftime("%M"))
        #graphics.DrawText(canvas, self._font_small, 53, 13, self._white, time.strftime("%p"))

        # day of the month
        #graphics.DrawText(canvas, self._font_small, 2, 22, self._white, time.strftime("%a %-d %b"))

        # Remove these lines when temp is implemented
        hi_str = "Vilken dag idag?"
        #hi_str = "%3.0f" % self._weather.high_temp
        graphics.DrawText(canvas, self._font_tiny, 1, 30, self._red, hi_str)
        #graphics.DrawText(canvas, self._font_tiny, 40, 30, self._red, "F")
        '''
	# For future use when temps added

        temp_str = "Tm"
        #temp_str = "%3.0f" % self._weather.cur_temp
        #graphics.DrawText(canvas, self._font_small, 0, 31, self._white, u'A good idea\u00AE')
        graphics.DrawText(canvas, self._font_tiny, 18, 30, self._white, "F")

        hi_str = "Hi"
        #hi_str = "%3.0f" % self._weather.high_temp
        graphics.DrawText(canvas, self._font_small, 22, 30, self._white, hi_str)
        graphics.DrawText(canvas, self._font_tiny, 40, 30, self._red, "F")

        low_str = "Lo"
        #low_str = "%3.0f" % self._weather.low_temp
        graphics.DrawText(canvas, self._font_small, 43, 30, self._white, low_str)
        graphics.DrawText(canvas, self._font_tiny, 61, 30, self._blue, "F")
	'''

    def run(self):
        canvas = self._matrix.CreateFrameCanvas()

        while True:
            self._draw(canvas)
            time.sleep(0.05)
            canvas = self._matrix.SwapOnVSync(canvas)
            self._matrix.brightness = self._dimmer.brightness
Example #8
0
def run():
    # Kill the splash screen if active
    stop_splash_service()

    # Get supplied command line arguments
    commandArgs = args()

    if commandArgs.terminal_mode and sys.stdin.isatty():
        height, width = os.popen('stty size', 'r').read().split()
        termMatrix = TermMatrix()
        termMatrix.width = int(width)
        termMatrix.height = int(height)
        matrix = Matrix(termMatrix)
    else:
        # Check for led configuration arguments
        matrixOptions = led_matrix_options(commandArgs)
        matrixOptions.drop_privileges = False

        # Initialize the matrix
        matrix = Matrix(RGBMatrix(options = matrixOptions))

     #Riff to add loading screen here
    loading = Loading(matrix)
    loading.render()

    # Read scoreboard options from config.json if it exists
    config = ScoreboardConfig("config", commandArgs, (matrix.width, matrix.height))

    data = Data(config)

    #If we pass the logging arguments on command line, override what's in the config.json, else use what's in config.json (color will always be false in config.json)
    if commandArgs.logcolor and commandArgs.loglevel != None:
        debug.set_debug_status(config,logcolor=commandArgs.logcolor,loglevel=commandArgs.loglevel)
    elif not commandArgs.logcolor and commandArgs.loglevel != None:
        debug.set_debug_status(config,loglevel=commandArgs.loglevel)
    elif commandArgs.logcolor and commandArgs.loglevel == None:
        debug.set_debug_status(config,logcolor=commandArgs.logcolor,loglevel=config.loglevel)
    else:
        debug.set_debug_status(config,loglevel=config.loglevel)

    # Print some basic info on startup
    debug.info("{} - v{} ({}x{})".format(SCRIPT_NAME, SCRIPT_VERSION, matrix.width, matrix.height))
    
    if data.latlng is not None:
        debug.info(data.latlng_msg)
    else:
        debug.error("Unable to find your location.")

    # Event used to sleep when rendering
    # Allows Web API (coming in V2) and pushbutton to cancel the sleep
    # Will also allow for weather alert to interrupt display board if you want
    sleepEvent = threading.Event()


    # Start task scheduler, used for UpdateChecker and screensaver, forecast, dimmer and weather
    scheduler = BackgroundScheduler()
    scheduler.start()

    # Any tasks that are scheduled go below this line

    # Make sure we have a valid location for the data.latlng as the geocode can return a None
    # If there is no valid location, skip the weather boards
    
    #Create EC data feed handler
    if data.config.weather_enabled or data.config.wxalert_show_alerts:
        if data.config.weather_data_feed.lower() == "ec" or data.config.wxalert_alert_feed.lower() == "ec":
            try:
                data.ecData = ECData(coordinates=(data.latlng))
            except Exception as e:
                debug.error("Unable to connect to EC, try running again in a few minutes")
                sys.exit(0)

    if data.config.weather_enabled:
        if data.config.weather_data_feed.lower() == "ec":
            ecWxWorker(data,scheduler)
        elif data.config.weather_data_feed.lower() == "owm":
            owmweather = owmWxWorker(data,scheduler)
        else:
            debug.error("No valid weather providers selected, skipping weather feed")
            data.config.weather_enabled = False


    if data.config.wxalert_show_alerts:
        if data.config.wxalert_alert_feed.lower() == "ec":
            ecalert = ecWxAlerts(data,scheduler,sleepEvent)
        elif data.config.wxalert_alert_feed.lower() == "nws":
            nwsalert = nwsWxAlerts(data,scheduler,sleepEvent)
        else:
            debug.error("No valid weather alerts providers selected, skipping alerts feed")
            data.config.weather_show_alerts = False

    if data.config.weather_forecast_enabled and data.config.weather_enabled:
        wxForecast(data,scheduler)
    #
    # Run check for updates against github on a background thread on a scheduler
    #
    if commandArgs.updatecheck:
        data.UpdateRepo = commandArgs.updaterepo
        checkupdate = UpdateChecker(data,scheduler,commandArgs.ghtoken)

    if data.config.dimmer_enabled:
        dimmer = Dimmer(data, matrix,scheduler)

    screensaver = None
    if data.config.screensaver_enabled:
        screensaver = screenSaver(data, matrix, sleepEvent, scheduler)
        if data.config.screensaver_motionsensor:
            motionsensor = Motion(data,matrix,sleepEvent,scheduler,screensaver)
            motionsensorThread = threading.Thread(target=motionsensor.run, args=())
            motionsensorThread.daemon = True
            motionsensorThread.start()

    if data.config.pushbutton_enabled:
        pushbutton = PushButton(data,matrix,sleepEvent)
        pushbuttonThread = threading.Thread(target=pushbutton.run, args=())
        pushbuttonThread.daemon = True
        pushbuttonThread.start()
    

    MainRenderer(matrix, data, sleepEvent).render()
Example #9
0
# how many matrixes stacked horizontally and vertically
matrix_horizontal = 5
matrix_vertical = 3

total_rows = matrix_rows * matrix_vertical
total_columns = matrix_columns * matrix_horizontal

options = RGBMatrixOptions()
options.rows = matrix_rows
options.cols = matrix_columns
options.chain_length = matrix_horizontal
options.parallel = matrix_vertical
options.hardware_mapping = 'regular'  # If you have an Adafruit HAT: 'adafruit-hat'
options.gpio_slowdown = 2

matrix = RGBMatrix(options=options)

###################################
# Main loop
###################################

try:
    print("Press CTRL-C to stop")
    while True:
        try:
            image = Image.open("temp.jpg").convert('RGB')
        except:
            print "collision!"
            continue

        image = image.resize((total_columns, total_rows))
Example #10
0
    if today == "03-14":
        text = "Pi party! Wohooooooo!!"

        scrollaText(canvas, font, color, text)


# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = 32
options.cols = 64
options.chain_length = 1
options.parallel = 1
options.hardware_mapping = 'adafruit-hat'  # If you have an Adafruit HAT: 'adafruit-hat'

matrix = RGBMatrix(options=options)

#Some variables to play with
fontToUse = "../../../fonts/6x13.bdf"
delayInSec = 5
color = graphics.Color(0, 0, 255)  #just temporary color. Will change each loop

canvas = matrix
font = graphics.Font()
font.LoadFont(fontToUse)
#Loop FOREVER and EVER!
try:
    print("Press CTRL-C to stop.")
    while True:
        hour = datetime.now().strftime('%H')
        minute = datetime.now().strftime('%M')
Example #11
0
from PIL import Image


options = RGBMatrixOptions()
options.rows = 32
options.cols = 32
options.chain_length = 1
options.parallel = 1
options.hardware_mapping = 'adafruit-hat'
options.disable_hardware_pulsing = False  # default: False
options.pwm_bits = 8  # default: 11
options.pwm_lsb_nanoseconds = 200  # default: 130
options.gpio_slowdown = 3  # default: 2
options.drop_privileges = False

matrix = RGBMatrix(options=options)
offscreen_canvas = matrix.CreateFrameCanvas()

image_file = 'cache/temp2.gif'



def panel_gif(filename, loop=1, delay=1):
    global matrix, offscreen_canvas
    image = Image.open(filename)
    for l in range(loop):
        for frame in range(0, image.n_frames):
        print(image.n_frames)
        image.seek(frame)
        offscreen_canvas.SetImage(image.convert('RGB'), unsafe=False)
        offscreen_canvas = matrix.SwapOnVSync(offscreen_canvas)
Example #12
0
 def __init__(self):
     ledOptions = LedOptions()
     options = ledOptions.getOptions()
     self.matrix = RGBMatrix(options=options)
Example #13
0
class GoalLed(object):
    def __init__(self):
        ledOptions = LedOptions()
        options = ledOptions.getOptions()
        self.matrix = RGBMatrix(options=options)

    def goalScored(self, teamName):
        offscreen_canvas = self.matrix.CreateFrameCanvas()
        font = graphics.Font()
        font.LoadFont("../rgblibrary/fonts/9x15.bdf")
        textColor = graphics.Color(0, 0, 255)
        pos = offscreen_canvas.width

        max_brightness = self.matrix.brightness
        count = 0

        while count < 3:
            self.matrix.Fill(255, 0, 0)
            time.sleep(.01)

            if self.matrix.brightness < 1:
                self.matrix.brightness = max_brightness
                count += 1
            else:
                self.matrix.brightness -= 1

        if teamName is not None:
            goalText = teamName + " Score!"
        else:
            goalText = "GOAL!"

        textCount = 0
        while textCount < 2:
            offscreen_canvas.Clear()
            len = graphics.DrawText(offscreen_canvas, font, pos, 13, textColor,
                                    goalText)
            pos -= 1
            if (pos + len < 0):
                pos = offscreen_canvas.width
                textCount += 1

            time.sleep(0.02)
            offscreen_canvas = self.matrix.SwapOnVSync(offscreen_canvas)

    def writeScore(self, awayAbrv, awayScore, homeAbrv, homeScore, time,
                   period):
        font = graphics.Font()
        font.LoadFont("../rgblibrary/fonts/4x6.bdf")
        canvas = self.matrix
        canvas.Clear()

        awayColour = graphics.Color(255, 0, 0)
        homeColour = graphics.Color(255, 128, 0)

        graphics.DrawText(canvas, font, 1, 5, awayColour,
                          awayAbrv + "  " + awayScore)
        graphics.DrawText(canvas, font, 1, 10, homeColour,
                          homeAbrv + "  " + homeScore)
        graphics.DrawText(canvas, font, 1, 16, awayColour, period + " " + time)

    def clearLed(self):
        canvas = self.matrix
        canvas.Clear()

    def writeText(self, text):
        offscreen_canvas = self.matrix.CreateFrameCanvas()
        font = graphics.Font()
        font.LoadFont("../rgblibrary/fonts/9x15.bdf")
        textColor = graphics.Color(0, 255, 0)
        pos = offscreen_canvas.width

        max_brightness = self.matrix.brightness
        count = 0

        while count < 4:
            self.matrix.Fill(0, 255, 0)
            time.sleep(.01)

            if self.matrix.brightness < 1:
                self.matrix.brightness = max_brightness
                count += 1
            else:
                self.matrix.brightness -= 1

        textCount = 0
        while textCount < 2:
            offscreen_canvas.Clear()
            len = graphics.DrawText(offscreen_canvas, font, pos, 13, textColor,
                                    text)
            pos -= 1
            if (pos + len < 0):
                pos = offscreen_canvas.width
                textCount += 1

            time.sleep(0.02)
            offscreen_canvas = self.matrix.SwapOnVSync(offscreen_canvas)

        count = 0

        while count < 4:
            self.matrix.Fill(0, 255, 0)
            time.sleep(.01)

            if self.matrix.brightness < 1:
                self.matrix.brightness = max_brightness
                count += 1
            else:
                self.matrix.brightness -= 1
Example #14
0
class Murapix:
    """
    Create a subclass to use Murapix
    
    The screen surface on which you need to blit the sprites is self.scratch.
    
    Murapix has the following properties:
        self.mapping: how the different LED panels are put in place
        self.demo: 0 if going to the LED panels, a positive int if it is going to the standart screen
        self.width: the total width of the rectangle enclosing all panels in pixel        
        self.height: the total height of the rectangle enclosing all panels in pixel
        self.max_number_of_panels: the number of panels
        self.led_rows: the number of pixel for both height and width of the panels
        self.scratch: the total pygame surface which is going to be processed by the murapix draw methods to either go the LED panels or, in demo mode, to the standart screen.
        self.gamepad: None by default. If set to a path string pointing to an SVG, will start the virtual gamepad
    """
    def __init__(self):
        configfile, demo = process_input_arg(sys.argv)
        (mapping, width, height, max_number_of_panels, led_rows, led_cols,
         parallel) = get_config(configfile)
        self.RUNNING = True
        self.mapping = mapping
        self.demo = demo
        self.width = width
        self.height = height
        self.max_number_of_panels = max_number_of_panels
        self.led_rows = led_rows
        self.led_cols = led_cols
        self.parallel = parallel
        self.scratch = pygame.Surface((width, height))
        self.gamepad = None

        #signal handlers to quite gracefully
        signal.signal(signal.SIGINT, self.quit_gracefully)
        signal.signal(signal.SIGTERM, self.quit_gracefully)
        print("""    murapix  Copyright (C) 2019  [email protected]
    This program comes with ABSOLUTELY NO WARRANTY.
    This is free software, and you are welcome to redistribute it
    under certain conditions.""")  #LICENSE

        if not demo:
            #must be a raspberry pi configured for murapix, hence nodename
            #must be "rpi-murapix"
            if os.uname().nodename not in ("rpi-murapix", "raspberrypi"):
                raise EnvironmentError(
                    "Not a murapix, please select demo mode with --demo=X")

            print('Going on the Murapix!')
            print('{0} channel(s) of [{1}*{2}={3} LED] X [{4} LED]'.format(
                parallel, max_number_of_panels // parallel, led_rows,
                max_number_of_panels * led_rows // parallel, led_cols))
            #the screen is just a single line of panels

            options = RGBMatrixOptions()
            options.rows = options.cols = led_rows
            options.parallel = parallel
            options.chain_length = max_number_of_panels // parallel
            options.hardware_mapping = 'regular'
            options.drop_privileges = 0
            self.matrix = RGBMatrix(options=options)

            self.double_buffer = self.matrix.CreateFrameCanvas()
            self._screen = init_pygame_display(
                (max_number_of_panels // parallel) * led_rows,
                led_cols * parallel)
        else:
            print('Going on the standart screen...')
            pygame.init()
            self._screen = pygame.display.set_mode(
                (width * demo, height * demo), 0, 32)

        self.clock = pygame.time.Clock()
        self.fps = 15

    def setup(self):
        pass

    def logic_loop(self):
        pass

    def graphics_loop(self):
        pass

    def run(self):
        if self.gamepad:
            try:
                self.start_gamepad()
            except Exception as e:
                print("Error starting gamepad")
                print(e)
                self.close()
                raise e
        self.setup()

        if self.demo:
            draw = self.draw_demo
        else:
            draw = self.draw_murapix
        while self.RUNNING:
            self.logic_loop()
            self.graphics_loop()
            draw()
            self.clock.tick(self.fps)

        self.close()

    def draw_demo(self):
        demo = self.demo
        width = self.width
        height = self.height
        pygame.transform.scale(self.scratch, (width * demo, height * demo),
                               self._screen)
        pygame.display.flip()

    def draw_murapix(self):
        scratch = self.scratch
        screen = self._screen
        mapping = self.mapping
        led_rows = self.led_rows
        led_cols = self.led_cols
        parallel = self.parallel
        curr_chain_row = 0
        NoP_per_chain = int(self.max_number_of_panels / parallel)

        #now blit each simulated panel in a row onto screen in the order
        #indicated by the mapping in the config file.
        #TODO: may be more efficient by vectorizing & using blits() instead of blit()
        for i, n in enumerate(mapping):  #x, rows
            for j, m in enumerate(n):  #y, panel number
                if m is None:
                    continue
                #find in which chain "m" is
                curr_chain_row = int((m - 1) / NoP_per_chain)

                #print into a square that fits hzeller doc led addressing
                #see https://github.com/hzeller/rpi-rgb-led-matrix/blob/master/wiring.md#chains
                screen.blit(
                    scratch,  #surface to take from
                    #LED (row,col) on the lined up panels
                    (led_rows * ((m - (NoP_per_chain * curr_chain_row)) - 1),
                     curr_chain_row * led_cols),
                    #rectangle to extract from the width*height scratch surface
                    area=pygame.Rect((led_rows * j, led_rows * i),
                                     (led_rows, led_rows)))

        py_im = pygame.image.tostring(screen, "RGB", False)
        pil_im = Image.frombytes("RGB", screen.get_size(), py_im)
        self.double_buffer.SetImage(pil_im)
        self.matrix.SwapOnVSync(self.double_buffer)

    def start_gamepad(self):
        assert os.path.isfile(
            self.gamepad), "self.gamepad must be a path to an SVG file"
        self.p = set_up_gamepad(self.gamepad)
        self.draw_select_gamepads()
        pygame.joystick.quit()
        pygame.joystick.init()

    def draw_select_gamepads(self):
        rect_area = get_largest_rect_add(self.led_rows, self.mapping)
        ((left, top), (width, height)) = rect_area
        not_selected = True
        no_gamepad = True
        active_joystick = False
        fontsize = 3 * width // 18 - 1
        top = top + (height - fontsize * 4) // 2
        font = pygame.font.Font(None, fontsize)
        text = font.render("Players connected:", False, (255, 255, 255),
                           (0, 0, 0))
        text_end0 = font.render("Press any key", False, (255, 255, 255),
                                (0, 0, 0))
        text_end1 = font.render(" to start", False, (255, 255, 255), (0, 0, 0))

        if self.demo:
            draw = self.draw_demo
        else:
            draw = self.draw_murapix

        while not_selected:
            self.clock.tick(self.fps)
            NoJS = [x.startswith('js')
                    for x in os.listdir("/dev/input")].count(True)

            text_NoP = font.render(str(NoJS), False, (255, 255, 255),
                                   (0, 0, 0))
            if NoJS > 0 and no_gamepad:
                no_gamepad = False
                pygame.joystick.quit()
                pygame.joystick.init()
                active_joystick = pygame.joystick.Joystick(0)
                active_joystick.init()

            for event in pygame.event.get():
                if (active_joystick and event.type == pgl.JOYBUTTONDOWN):
                    not_selected = False
                    print('{} players selected'.format(NoJS))

            tw, th = font.size("Players connected:")
            self.scratch.blit(text, (left + (width - tw) // 2, top))
            self.scratch.blit(text_NoP,
                              (left + width // 2, top + 1 * fontsize))
            tw, th = font.size("Press any key")
            self.scratch.blit(text_end0,
                              (left + (width - tw) // 2, top + 2 * fontsize))
            tw, th = font.size(" to start")
            self.scratch.blit(text_end1,
                              (left + (width - tw) // 2, top + 3 * fontsize))
            draw()

    def close(self):
        #https://stackoverflow.com/questions/2638909/killing-a-subprocess-including-its-children-from-python

        if self.gamepad:
            try:
                os.killpg(os.getpgid(self.p.pid), signal.SIGTERM)
            except Exception as e:
                print("Error trying to kill gamepad node and its children")
                print(e)

        pygame.quit()
        sys.exit()

    def quit_gracefully(self, sig, frame):
        print('\n### {} was catched, terminating ###'.format(
            signal.Signals(sig).name))
        self.RUNNING = False
        self.close()
Example #15
0
i2c.write_word_data(mcp, mcp_gpio, 0x0000)

leds.begin()

options = RGBMatrixOptions()
options.rows = 32
options.cols = 64
options.disable_hardware_pulsing = True
options.pixel_mapper_config = "Rotate:180"

#nfcRdr = NFCReader.NFCReader()
#nfcRdr.run()

paddles = Paddles.Paddles()

matrix = RGBMatrix(options=options)
acmefont = graphics.Font()
acmefont.LoadFont('/home/pi/src/rpi-rgb-led-matrix/fonts/6x13.bdf')
ipfont = graphics.Font()
ipfont.LoadFont('/home/pi/src/rpi-rgb-led-matrix/fonts/5x8.bdf')


def show_ipaddress(matrix, font):
    ipaddress = ((([
        ip for ip in socket.gethostbyname_ex(socket.gethostname())[2]
        if not ip.startswith("127.")
    ] or [[(s.connect(("8.8.8.8", 53)), s.getsockname()[0], s.close())
           for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]][0][1]])
                  + ["no IP found"])[0])
    ypos = 64 - 5 * len(ipaddress)
    graphics.DrawText(matrix, font, ypos, 30, graphics.Color(255, 0, 255),
options.cols = 64
options.chain_length = 2
options.parallel = 1
options.hardware_mapping = 'adafruit-hat-pwm'
options.pixel_mapper_config = 'U-mapper;Rotate:90'

dimension = 4
maxExposure = 256  # maximum exposures
totalExposure = 0  # counter for exposures
grid = [[0 for x in range(dimension)] for y in range(dimension)
        ]  # 2D array of int values representing total exposure of each panel
rowIndex = 0  # row index of currently exposed panel
colIndex = 0  # column index of currently exposed panel
eTime = 0  # countdown of remaining exposure;

matrix = RGBMatrix(options=options)

while totalExposure < maxExposure:
    if eTime <= 0:
        # randomly generate panel index and exposure time
        rowIndex = int(random.random() * dimension)
        colIndex = int(random.random() * dimension)
        eTime = int(random.random() * 6) + 2
    else:
        if grid[rowIndex][colIndex] >= 255:
            grid[rowIndex][colIndex] = 255  # set upper bound
        else:
            grid[rowIndex][colIndex] += 1  # add to grid value
        totalExposure += 1  # add to counter
        eTime -= 1  # subtract from remaining exposure time
Example #17
0
            pass

        if event.is_set():
            break

    print('Rendering Stop')


options = RGBMatrixOptions()
options.rows = 16
options.cols = 32
options.chain_length = 1
options.parallel = 1
options.hardware_mapping = 'adafruit-hat'

matrix = RGBMatrix(options=options)
offscreen_canvas = matrix.CreateFrameCanvas()
font = graphics.Font()
font.LoadFont("../../../fonts/6x13.bdf")
pos = offscreen_canvas.width

color = "green"
stockValue = 0

shared_data = {"driver": driver, "stockValue": stockValue, "color": color}

t = Thread(target=get_values, args=(shared_data, ))
t.start()

while True:
    try:
Example #18
0
    if int(resp) == risultato:
        sound1.play()
        return True
    else:
        sound2.play()
        return False


# 1.a impostazioni per il ledmatrix
# opzioni
options = RGBMatrixOptions()
options.hardware_mapping = 'adafruit-hat'
options.rows = 32
options.chain_length = 2
# impostazione matrice
matrix = RGBMatrix(options=options)
offline_matrix = matrix.CreateFrameCanvas()
#caricamento font
font1 = graphics.Font()
font2 = graphics.Font()
font3 = graphics.Font()
font4 = graphics.Font()
font5 = graphics.Font()
font1.LoadFont("./fonts/6x10.bdf")  # per nomi dei colori
font2.LoadFont("./fonts/5x7.bdf")  # per messaggio di esito
font3.LoadFont("./fonts/4x6.bdf")  # per i tempi
font4.LoadFont("./fonts/9x18.bdf")  # per punteggi
font5.LoadFont("./fonts/9x18B.bdf")  # per punteggi
#COLORI GENERICI
RGBColor = [
    graphics.Color(255, 0, 0),
 def initiate(self):
     self.matrix = RGBMatrix(options=self.options)
     self.offscreen_canvas = self.matrix.CreateFrameCanvas()
class guerillaClockDisplay(object):
    def __init__(self):
        self.options = RGBMatrixOptions()
        self.options.rows = 16
        self.options.chain_length = 1
        self.options.parallel = 1
        self.options.hardware_mapping = 'regular'  # If you have an Adafruit HAT: 'adafruit-hat'
        self.font = graphics.Font()
        self.font.LoadFont("rpi-rgb-led-matrix/fonts/5x8.bdf")
        self.textColor = graphics.Color(255, 0, 0)

    def initiate(self):
        self.matrix = RGBMatrix(options=self.options)
        self.offscreen_canvas = self.matrix.CreateFrameCanvas()

    def nobus(self):
        self.msg = "BUSES AT TERMINAL - STANDBY FOR NEXT BUS."
        self.scroll()

    def announce(self, m):
        self.msg = m
        self.scroll()

    def set(self, m):
        self.msg = m

    def show(self, b, t):
        self.bus = b + ":"
        self.btime = t
        #self.msg = "test"

        pos = 3  #align left
        btlen = graphics.DrawText(self.offscreen_canvas, self.font, pos, 7,
                                  self.textColor,
                                  self.btime)  #width of bus time
        hold = 1
        while (pos + btlen > 0):
            self.offscreen_canvas.Clear()
            blen = graphics.DrawText(self.offscreen_canvas, self.font, pos, 7,
                                     self.textColor, self.bus)  #width of bus
            btlen = graphics.DrawText(self.offscreen_canvas, self.font, pos,
                                      15, self.textColor,
                                      self.btime)  #width of bus time
            pos -= 1
            if (pos + btlen < 0):
                pos = self.offscreen_canvas.width

            time.sleep(0.05)
            self.offscreen_canvas = self.matrix.SwapOnVSync(
                self.offscreen_canvas)
            if hold:
                time.sleep(10)
                hold = 0

    def scroll(self):
        pos = self.offscreen_canvas.width
        loops = 0
        while (loops < 2):
            self.offscreen_canvas.Clear()
            blen = graphics.DrawText(self.offscreen_canvas, self.font, pos, 10,
                                     self.textColor, self.msg)
            pos -= 1
            if (pos + blen < 0):
                pos = self.offscreen_canvas.width
                loops += 1

            time.sleep(0.05)
            self.offscreen_canvas = self.matrix.SwapOnVSync(
                self.offscreen_canvas)

    def off(self):
        self.offscreen_canvas.Clear()
Example #21
0
class RGBBase:
    def __init__(self):
        # RGB Matrix Configuration
        self.__options__ = RGBMatrixOptions()
        self.__options__.rows = 16
        self.__options__.cols = 32
        self.__options__.chain_length = 3
        self.__options__.parallel = 3
        self.__options__.brightness = 100
        self.__options__.pwm_bits = 1
        self.__board_info__ = self._getBoardInfo()

        if self.__board_info__['panelType'] == 1:
            # options for first-batch boards
            self.__options__.multiplexing = 8
            self.__options__.row_address_type = 0
            self.__options__.pwm_lsb_nanoseconds = 90
        elif self.__board_info__['panelType'] == 2:
            # options for second-batch boards
            self.__options__.multiplexing = 3
            self.__options__.row_address_type = 2
            self.__options__.gpio_slowdown = 2

        # (ssid, password) = GetWifiConnectionInfo()
        # ssid = ssid.upper()
        # if ssid in legacy_panel_ssids:
        # # if ssid == "Lederbord103":
        #     # options for production board
        #     self.__options__.multiplexing = 8
        #     self.__options__.row_address_type = 0
        #     self.__options__.pwm_lsb_nanoseconds = 90
        #     # self.__options__.brightness = 100
        # else:
        #     # options for dev board
        #     self.__options__.multiplexing = 3
        #     self.__options__.row_address_type = 2

        # Create the matrix stuff
        self.__matrix__ = RGBMatrix(options=self.__options__)
        self.__offscreen_canvas__ = self.__matrix__.CreateFrameCanvas()
        self.__offscreen_canvas__.Clear()

        # Create arrays to hold the child views
        self.__children__ = []

    def _getBoardInfo(self):
        board_info = {}
        if (os.path.exists("/home/pi/info.json")):
            with open("/home/pi/info.json", "r") as in_json:
                board_info = json.load(in_json)
            return board_info
        else:
            generateInfo()  #create file if nonexistent
            return self._getBoardInfo()

    def redraw(self):
        self.__offscreen_canvas__.Clear()

        for child in self.__children__:
            child.render(self.__matrix__, self.__offscreen_canvas__)
        self.__offscreen_canvas__ = self.__matrix__.SwapOnVSync(
            self.__offscreen_canvas__)

        for child in self.__children__:
            if type(child) != RGBLabel:
                child.render(self.__matrix__, self.__offscreen_canvas__)
            elif (child.__textStyle__ == TextStyle.IMAGE
                  or child.__textStyle__ == TextStyle.IMAGE_RED):
                child.render(self.__matrix__, self.__offscreen_canvas__)

    def addView(self, view):
        self.__children__.append(view)
        self.redraw()

    def removeAllViews(self):
        self.__offscreen_canvas__.Clear()
        self.__children__ = []
        self.redraw()
        print('Removed All View')

    def setBrightness(self, dataStr):
        self.__matrix__.brightness = int(dataStr)
        self.redraw()
Example #22
0
    # Set up the matrix options
    log.info("In app main")
    options = RGBMatrixOptions()
    options.brightness = 100
    options.rows = 32
    options.cols = 64
    options.hardware_mapping = "adafruit-hat-pwm"
    options.gpio_slowdown = 4

    with data_lock:
        common_data[ACTIVE_SCREEN_KEY] = ActiveScreen.REFRESH
        common_data[SCREENS_KEY] = {
            ActiveScreen.REFRESH: InfoScreen("Loading...")
        }
        common_data[SCREENS_KEY][ActiveScreen.REBOOT] = InfoScreen(
            "Rebooting...")
        common_data[MATRIX_KEY] = RGBMatrix(options=options)
        common_data[SCREENS_KEY][ActiveScreen.SYNC] = SyncScreen()
        common_data[SCREENS_KEY][ActiveScreen.HOTSPOT] = WifiHotspot()
        common_data[SCREENS_KEY][
            ActiveScreen.WIFI_DETAILS] = ConnectionScreen()
        common_data[SCREENS_KEY][ActiveScreen.ERROR] = ErrorScreen(
            "Dummy Error Message", ["Error"])

    if not config.testing:
        run_webserver()
    else:  # This is a terrible hack but it helps keep things running in test mode
        web_thread = threading.Thread(target=run_webserver)
        web_thread.start()
        common_data[MATRIX_KEY].master.mainloop()
Example #23
0
    image_file = sys.argv[1]
    image_file2 = sys.argv[2]
    image_file3 = sys.argv[3]

image = Image.open(image_file)
image2 = Image.open(image_file2)
image3 = Image.open(image_file3)

# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = 32
options.chain_length = 1
options.parallel = 1
options.hardware_mapping = 'adafruit-hat'  # If you have an Adafruit HAT: 'adafruit-hat'
 
matrix = RGBMatrix(options = options)

# Make image fit our screen.
image.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)
image2.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)

matrix.SetImage(image.convert('RGB'))

try:
    print("Press CTRL-C to stop.")
    while True:
        matrix.Clear()
        matrix.SetImage(image.convert('RGB'))
        time.sleep(1)
        matrix.Clear()
        matrix.SetImage(image2.convert('RGB'))
Example #24
0
    options.hardware_mapping = 'regular'
    options.inverse_colors = False
    options.led_rgb_sequence = "BGR"
    options.gpio_slowdown = 1
    options.pwm_lsb_nanoseconds = 150
    options.show_refresh_rate = 0
    options.disable_hardware_pulsing = True
    options.scan_mode = 0
    options.pwm_bits = 11
    options.daemon = 0
    options.drop_privileges = 0
    return options


options = rgbmatrix_options()
display = RGBMatrix(options=options)


class ArtNet(DatagramProtocol):
    def addToFrameBufferArray(self, sequence, universe, rgb_length, data):
        global frameArray
        if (sequence > 0):
            #           Die Sequence Nummer wird aus dem Array gelesen
            frameSequenceInt = int(float(str(frameArray[0][0])))
            #           Ist die Sequence Nummer 0, so wurde der Initial Array String erkannt
            #           nach dem befuellen muss der Initail Array entfernt werden
            if (frameSequenceInt == 0):
                frameArray.append([sequence, universe, rgb_length, data])
                frameArray.pop(0)
            else:
                frameArray.append([sequence, universe, rgb_length, data])
Example #25
0
class PulseLedView(object):
    def __init__(self, *args, **kwargs):
        self.parser = argparse.ArgumentParser()

        self.parser.add_argument("-r", "--led-rows", action="store", help="Display rows. 16 for 16x32, 32 for 32x32. Default: 32", default=32, type=int)
        self.parser.add_argument("-c", "--led-chain", action="store", help="Daisy-chained boards. Default: 2.", default=2, type=int)
        self.parser.add_argument("-P", "--led-parallel", action="store", help="For Plus-models or RPi2: parallel chains. 1..3. Default: 1", default=1, type=int)
        self.parser.add_argument("-p", "--led-pwm-bits", action="store", help="Bits used for PWM. Something between 1..11. Default: 11", default=11, type=int)
        self.parser.add_argument("-b", "--led-brightness", action="store", help="Sets brightness level. Default: 100. Range: 1..100", default=100, type=int)
        self.parser.add_argument("-m", "--led-gpio-mapping", help="Hardware Mapping: regular, adafruit-hat, adafruit-hat-pwm Default: adafruit-hat" , choices=['regular', 'adafruit-hat', 'adafruit-hat-pwm'], default="adafruit-hat", type=str)
        self.parser.add_argument("--led-scan-mode", action="store", help="Progressive or interlaced scan. 0 Progressive, 1 Interlaced (default)", default=1, choices=range(2), type=int)
        self.parser.add_argument("--led-pwm-lsb-nanoseconds", action="store", help="Base time-unit for the on-time in the lowest significant bit in nanoseconds. Default: 130", default=130, type=int)
        self.parser.add_argument("--led-show-refresh", action="store_true", help="Shows the current refresh rate of the LED panel")
        self.parser.add_argument("--led-slowdown-gpio", action="store", help="Slow down writing to GPIO. Range: 1..100. Default: 1", choices=range(3), type=int)
        self.parser.add_argument("--led-no-hardware-pulse", action="store", help="Don't use hardware pin-pulse generation")
        self.parser.add_argument("--led-rgb-sequence", action="store", help="Switch if your matrix has led colors swapped. Default: RGB", default="RGB", type=str)
        self.parser.add_argument("--cache-location", action="store", help="Location of the cache folder Default: ./pulse-cache", default="./pulse-cache", type=str)
        self.parser.add_argument("--log-level", action="store", help="Log level Default: DEBUG", default="DEBUG", type=str)

    def initialize_and_run(self):
        self.args = self.parser.parse_args()

        logging_level = logging.getLevelName(self.args.log_level)
        self.logging = logging.basicConfig(level=logging_level, format='%(asctime)-15s [%(levelname)s] (%(threadName)-10s) %(message)s', )

        logging.info("Initializing LED matrix...")
        options = RGBMatrixOptions()

        if self.args.led_gpio_mapping != None:
          options.hardware_mapping = self.args.led_gpio_mapping

        options.rows = self.args.led_rows
        options.chain_length = self.args.led_chain
        options.parallel = self.args.led_parallel
        options.pwm_bits = self.args.led_pwm_bits
        options.brightness = self.args.led_brightness
        options.pwm_lsb_nanoseconds = self.args.led_pwm_lsb_nanoseconds
        options.led_rgb_sequence = self.args.led_rgb_sequence

        if self.args.led_show_refresh:
          options.show_refresh_rate = 1

        if self.args.led_slowdown_gpio != None:
            options.gpio_slowdown = self.args.led_slowdown_gpio

        if self.args.led_no_hardware_pulse:
          options.disable_hardware_pulsing = True

        self.matrix = RGBMatrix(options = options)

        #self.led_pulse_cache = FanoutCache(self.args.cache_location, shards=20, timeout=1)
        self.columns = self.args.led_rows * self.args.led_chain
        self.rows = 32

        # TODO: configure me
        self.pulse_events_url = "http://192.168.1.7:9201/events"

        # TODO: configure me
        self.target_fps = 24.
        self.time_per_frame_ms = (1 / self.target_fps) * 1000.

        self.draw_state = DrawState()
        self.stop_event = threading.Event()

        try:
            # Start loop
            print("Press CTRL-C to stop sample")
            self.run()
        except KeyboardInterrupt:
            print("Exiting\n")
            self.stop_event.set()
            sys.exit(0)

        return True

    def draw_text(self, matrix, x, y, text, size = 20):
        font = ImageFont.truetype('fonts/FiraCode-Regular.ttf', size)
        image = Image.new("RGB", (self.columns, self.rows))
        draw = ImageDraw.Draw(image)

        text_width, text_height = font.getsize(text)

        draw.text((x - text_width/2 ,y - text_height/2), text, font=font, fill=(41,161,228,0))

        self.matrix.SetImage(image.convert('RGB'))

    def draw_logo(self):
        logging.info("Display TS logo...")
        logo_image = Image.open("images/tradeshift.jpg")
        logo_image.thumbnail((self.columns, self.rows), Image.ANTIALIAS)
        logo_image_width, logo_image_height = logo_image.size

        x = (self.columns - logo_image_width) / 2
        y = (self.rows - logo_image_height) / 2

        self.matrix.SetImage(logo_image.convert('RGB'), x, y)

    def countdown(self):
        for value in reversed(range(0, 10)):
            self.draw_text(self.matrix, (self.columns / 2), (self.rows / 2), str(value), 20)
            sleep(0.125)

        self.matrix.Clear()

    def run(self):
        self.draw_logo()
        sleep(2)
        self.countdown()

        pulse_data_producer = PulseDataProducer(self.draw_state,
                                                self.stop_event,
                                                self.pulse_events_url,
                                                self.target_fps,
                                                self.columns,
                                                self.rows
                                               )

        pulse_led_panel_output = PulseLedPanelOutput( self.draw_state,
                                                self.stop_event,
                                                self.matrix,
                                                self.target_fps,
                                                self.columns,
                                                self.rows
                                               )

        producer_thread = threading.Thread(name='data-producer-thread',
                                   target=pulse_data_producer.run)
        producer_thread.setDaemon(True)
        producer_thread.start()

        draw_thread = threading.Thread(name='data-draw-thread',
                                       target=pulse_led_panel_output.run,)
        draw_thread.setDaemon(True)
        draw_thread.start()

        producer_thread.join()
        draw_thread.join()
Example #26
0
 def __init__(self, canvas):
     if canvas is not None:
         self.matrix = canvas
     else:
         self.matrix = RGBMatrix(options=options)
Example #27
0
import cv2
import os, time
import numpy as np
import random
from PIL import Image
from rgbmatrix import RGBMatrix, RGBMatrixOptions

# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = 32
options.chain_length = 1
options.parallel = 1
options.hardware_mapping = 'adafruit-hat'  # If you have an Adafruit HAT: 'adafruit-hat'
options.gpio_slowdown = 4

matrix = RGBMatrix(options = options)


def overlay_transparent(background_img, img_to_overlay_t, x, y, overlay_size=None):
    """
    @brief      Overlays a transparant PNG onto another image using CV2

    @param      background_img    The background image
    @param      img_to_overlay_t  The transparent image to overlay (has alpha channel)
    @param      x                 x location to place the top-left corner of our overlay
    @param      y                 y location to place the top-left corner of our overlay
    @param      overlay_size      The size to scale our overlay to (tuple), no scaling if None

    @return     Background image with overlay on top
    """
Example #28
0
total_rows = matrix_rows * matrix_vertical
total_columns = matrix_columns * matrix_horizontal

options = RGBMatrixOptions()
options.rows = matrix_rows
options.cols = matrix_columns
options.chain_length = matrix_horizontal
options.parallel = matrix_vertical
#options.hardware_mapping = 'adafruit-hat-pwm'  # If you have an Adafruit HAT: 'adafruit-hat'
#options.hardware_mapping = 'adafruit-hat'  # If you have an Adafruit HAT: 'adafruit-hat'
options.hardware_mapping = 'regular'

#options.gpio_slowdown = 2

matrix = RGBMatrix(options=options)

###################################
# Main code
###################################
icon_size = 40

fnt = ImageFont.truetype("Arial_Bold.ttf", 14)

background = Image.open("andr_small.jpeg")
background.convert("RGBA")
background = background.resize((total_columns, total_rows))

icon_image = Image.open("tie-fighter-01.jpg")
icon_image = icon_image.convert("RGBA")
icon_image = icon_image.resize((icon_size, icon_size))
# http://effbot.org/imagingbook/imagedraw.htm

from PIL import Image
from PIL import ImageDraw
import time
from rgbmatrix import RGBMatrix, RGBMatrixOptions

# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = 16
options.chain_length = 1
options.parallel = 1
options.disable_hardware_pulsing = True
options.hardware_mapping = 'regular'  # If you have an Adafruit HAT: 'adafruit-hat'

matrix = RGBMatrix(options=options)

# RGB example w/graphics prims.
# Note, only "RGB" mode is supported currently.
image = Image.new("RGB", (16, 32))  # Can be larger than matrix if wanted!!
draw = ImageDraw.Draw(image)  # Declare Draw instance before prims
# Draw some shapes into image (no immediate effect on matrix)...
draw.rectangle((0, 0, 31, 31), fill=(0, 0, 0), outline=(0, 0, 255))
draw.line((0, 0, 15, 31), fill=(255, 0, 0))
draw.line((0, 15, 31, 0), fill=(0, 255, 0))

m = 0
# Then scroll image across matrix...
for n in range(-15, 15):  # Start off top-left, move off bottom-right
    m = n * 2
    matrix.Clear()
Example #30
0
image2 = Image.open("2.png")
image3 = Image.open("3.png")
image4 = Image.open("4.png")
image5 = Image.open("5.png")
image6 = Image.open("6.png")
image7 = Image.open("7.png")
image8 = Image.open("8.png")

# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = 32
options.chain_length = 5
options.parallel = 1
options.hardware_mapping = 'adafruit-hat'  # If you have an Adafruit HAT: 'adafruit-hat'

matrix = RGBMatrix(options=options)

# Make image fit our screen.
image1.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)
image2.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)
image3.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)
image4.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)
image5.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)
image6.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)
image7.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)
image8.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)

print("Press CTRL-C to stop.")
double_buffer = matrix.CreateFrameCanvas()
img_width, img_height = image1.size
xpos = 0
Example #31
0
"""
Mock-up to optimize image parsing in similar situation than actual one
"""

#Import module to handle led matrix display
from rgbmatrix import RGBMatrix

import time
import itertools
import random

#Init matrix display
rows = 16
chains = 3
parallel = 1
myMatrix = RGBMatrix(rows, chains, parallel)
myMatrix.pwmBits = 1
myMatrix.luminanceCorrect = False

#Create a buffer of the matrix display to hold new image before displaying
offscreen = myMatrix.CreateFrameCanvas()

#Speed test loop
for i in xrange(10):
    
    #Init random image
    image = [(random.randint(0, 255),random.randint(0, 255),random.randint(0, 255)) for i in xrange(myMatrix.width*myMatrix.height)]
    
    start = time.time()
    screen_width = offscreen.width
    screen_height = offscreen.height
Example #32
0
class Tank():

    ############################################
    # Init method
    ###############################################
    def __init__(self, panel_rows, panel_columns, num_horiz_panels,
                 num_vert_panels):

        self.total_rows = panel_rows * num_vert_panels
        self.total_columns = panel_columns * num_horiz_panels

        options = RGBMatrixOptions()
        options.rows = matrix_rows
        options.cols = matrix_columns
        options.chain_length = num_horiz_panels
        options.parallel = num_vert_panels
        options.hardware_mapping = 'regular'
        #options.gpio_slowdown = 2

        self.matrix = RGBMatrix(options=options)

        self.background = None
        self.icons = []

        self.screen = Image.new("RGBA", (self.total_columns, self.total_rows))

    ############################################
    # set_background
    ############################################
    def set_background(self, filename):
        self.background = Image.open(filename)
        self.background.convert("RGBA")
        self.background = self.background.resize(
            (self.total_columns, self.total_rows))

    ############################################
    # add_icon
    ###############################################
    def add_icon(self, icon):
        self.icons.append(icon)

    ############################################
    # show
    #   Displays the whole tank, and then moves any icon elements.
    ###############################################
    def show(self):

        #restore background
        self.screen.paste(self.background, (0, 0))

        # move and paste in our icons
        for icon in self.icons:
            icon.move()
            icon.show(self.screen)

        self.screen = self.screen.convert("RGB")
        screen_draw = ImageDraw.Draw(self.screen)

        # draw text on top
        currentDT = datetime.datetime.now()
        time_string = currentDT.strftime("%H:%M:%S")

        # do some math to center our time string
        fnt = ImageFont.truetype("Arial_Bold.ttf", 14)
        time_size = fnt.getsize(time_string)
        time_x = (self.total_columns - time_size[0]) / 2
        time_y = (self.total_rows - time_size[1]) / 2
        screen_draw.text((time_x, time_y),
                         time_string,
                         fill=(
                             255,
                             0,
                             0,
                         ),
                         font=fnt)

        self.matrix.SetImage(self.screen, 0, 0)
Example #33
0
total_rows = matrix_rows * matrix_vertical
total_columns = matrix_columns * matrix_horizontal

options = RGBMatrixOptions()
options.rows = matrix_rows
options.cols = matrix_columns
options.chain_length = matrix_horizontal
options.parallel = matrix_vertical

#options.hardware_mapping = 'adafruit-hat-pwm'
#options.hardware_mapping = 'adafruit-hat'  # If you have an Adafruit HAT: 'adafruit-hat'
options.hardware_mapping = 'regular'

options.gpio_slowdown = 2

matrix = RGBMatrix(options=options)

imageSize = 80
image = Image.open("./logos/flyingpig.jpg").convert('RGB')
#image = image.rotate(180)
image = image.resize((imageSize, imageSize))
xMaxRange = total_columns - imageSize
yMaxRange = total_rows - imageSize
imageX = random.randint(0, xMaxRange)
imageY = random.randint(0, yMaxRange)
dirX = random.randint(1, 3)
dirY = random.randint(1, 3)

start = time.time()
elapsed_time = 0
last_reset = 0
Example #34
0
def regenTropfen(topic, msg):
    global esRegnet
    v = int(msg.decode())
    if v >= 1:
        esRegnet.on()


if __name__ == "__main__":
    options = RGBMatrixOptions()
    options.rows = 64
    options.cols = 64
    options.hardware_mapping = "adafruit-hat-pwm"
    options.pwm_bits = 7
    options.drop_privileges = False
    matrix = RGBMatrix(options=options)

    ch5 = House()
    ch5.addFloor("2.OG", 2)
    ch5.addFloor("1.OG", 1)
    ch5.addFloor("EG", 0)
    ch5.addFloor("Keller", -1)
    ch5.addFloor("Aussen", -2)

    ch5.addRoom("Arbeitszimmer", "2.OG")
    ch5.addRoom("Bad2", "2.OG")
    ch5.addRoom("Loggia", "2.OG")
    ch5.addRoom("RaspiBox", "2.OG")
    ch5.addRoom("3DPrinter", "2.OG")
    ch5.addRoom("2OG-Loggia", "2.OG")
    ch5.addRoom("2OG-Flur", "2.OG")
Example #35
0
# how many matrixes stacked horizontally and vertically
matrix_horizontal = 1
matrix_vertical = 1

total_rows = matrix_rows * matrix_vertical
total_columns = matrix_columns * matrix_horizontal

options = RGBMatrixOptions()
options.rows = matrix_rows
options.cols = matrix_columns
options.chain_length = matrix_horizontal
options.parallel = matrix_vertical
options.hardware_mapping = 'regular'
options.gpio_slowdown = 3

matrix = RGBMatrix(options=options)

###################################
# Main code
###################################
icon_size = 40

icon_image = Image.open("ghost.jpg")
icon_image = icon_image.resize((icon_size, icon_size))

blank_image = Image.new("RGB", (icon_size, icon_size))

icon_x = total_columns
icon_y = random.randint(0, total_columns - icon_size)

try:
Example #36
0
from rgbmatrix import RGBMatrix
from rgbmatrix import graphics
from field import Field
from color import Color
from ant import Ant
import time


Matrix = RGBMatrix(32, 2, 1)
Matrix.pwmBits = 5
Matrix.brightness = 100

def colorize(foods, base, ants):
    for food in foods:
        Matrix.SetPixel(food[1], food[0], 0, 200, 0)
    for ant in ants:
        Matrix.SetPixel(ant.coordinates[1], ant.coordinates[0], 200, 0, 0)
	#base
    Matrix.SetPixel(base[1], base[0], 100, 255, 100)


field = Field("field.txt", (30, 40))

field.food.append((10, 10))
field.food.append((20, 20))

for i in range(1, 21):
    field.units.append(Ant(Color(0, 0, 100), 30, 40, i))
    field.add_occupied((30, 40))

offscreenCanvas = Matrix.CreateFrameCanvas()
Example #37
0
                #    horizontal_position = 0
                #    offscreen.Fill(0,0,0)
                r, g, b = pixl[(horizontal_position + x) % im_width + y * im_width]
                #r, g, b = (0, 255, 0)
                offscreen.SetPixel(x, y, r, g, b)
            print "Parse Image rate: ? Hz", 1/(time.time()-start)
            #print "Update screen"
            offscreen = self.myMatrix.SwapOnVSync(offscreen)
            horizontal_position += scroll_jumps
            if horizontal_position < 0:
                horizontal_position = im_width
            #time.sleep(scroll_ms / 1000)
    
    def stop(self):
        self.Terminated = 1
    
    def load(self, image):
        self.pix = list(image.getdata())
        #pp.pprint(list(image.getdata()))
        self.image_width, self.image_height = image.size
        self.new_image = True

if __name__ == '__main__':
    #Initiate led matrix screen size
    rows = 16
    chains = 3
    parallel = 1
    myMatrix = RGBMatrix(rows, chains, parallel)
    myMatrix.pwmBits = 11
    tweety_pi(myMatrix, sys.argv[1:])