Cleaning project and using Paradero class to get bus data

GenPoster/app.py

@@ -5,6 +5,7 @@ import numpy as np
 from datetime import datetime, timedelta
 from import_data import export_data
 from PIL import Image
+from getData import Paradero
 
 def reescalar_imagen(input_path, output_path, nuevo_ancho, nuevo_alto):
     try:
@@ -87,9 +88,9 @@ def obtain_min_max_time(remaining_time):
 # 'letter_background_color': 'green', Color del fondo para la letra
 
 def main():
-    # Carga los datos
-    #data = load_data()
-    data = export_data()
+    bus_stop = Paradero()
+
+    data = bus_stop.get_data()
     data1 = data[0]
     data2 = data[1]
 

GenPoster/getData.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 
 import requests
-import json
+from datetime import datetime, timedelta
 
 
 class Paradero:
@@ -21,6 +21,7 @@ class Paradero:
         # URL de la API para obtener los datos de los recorridos
         self.url_getinfodevice = 'https://transporte.hz.kursor.cl/api/dispositivos/getInfoDevice/'
         self.data = None
+        self.bus_list = []
 
 
     def __get_token(self):
@@ -59,14 +60,32 @@ class Paradero:
             self.data = self.__serialize_data(response)
             return self.data
 
+    def __generate_bus_list(self, info):
+        data_main = []
+        hora_actual = datetime.now().time()
+
+        for i in range(len(info["GetInfoDeviceResponse"]["DetalleLineas"])):
+
+            data = info["GetInfoDeviceResponse"]["DetalleLineas"][i]
+
+            bus_info = {}
+            bus_info["distance"] = data["Llegadas"][0]["DistanciaGPS"] if data["Llegadas"][0]["DistanciaGPS"] is not None else "-"
+            bus_info["timeLabel"] = data["Llegadas"][0]["EstimadaGPS"] if data["Llegadas"][0]["EstimadaGPS"] is not None else "-"
+            bus_info["route"] = data["Descripcion"][:-1] if data["Descripcion"] is not None else "-"
+            bus_info["direction"] = data["Descripcion"][-1] if data["Descripcion"] is not None else "-"
+            bus_info["number_background_color"] = data["colorFondo"]
+            bus_info["letter_background_color"] = data["colorTexto"]
+            bus_info["patente"] = data["Llegadas"][0]["patente"]
+            diff = timedelta(hours = datetime.strptime(bus_info["timeLabel"], "%H:%M:%S").time().hour - hora_actual.hour,minutes = datetime.strptime(bus_info["timeLabel"], "%H:%M:%S").time().minute - hora_actual.minute,seconds=datetime.strptime(bus_info["timeLabel"], "%H:%M:%S").time().second - hora_actual.second)
+            bus_info["timeRemaining"] = int(abs(diff.total_seconds() // 60))
+            data_main.append(bus_info)
+
+        data_main = sorted(data_main, key=lambda x: x['timeRemaining'])
+        self.bus_list = data_main
+
     def __serialize_data(self, response):
         data = response.json()
-        data = data["GetInfoDeviceResponse"]["DetalleLineas"][0]
+        self.__generate_bus_list(data)
+        data = self.bus_list[:2]
 
-        bus_info = {}
-        bus_info["distance"] = data["Llegadas"][0]["DistanciaGPS"] if data["Llegadas"][0]["DistanciaGPS"] is not None else "-"
-        bus_info["timeLabel"] = data["Llegadas"][0]["EstimadaGPS"][:-3] if data["Llegadas"][0]["EstimadaGPS"] is not None else "-"
-        bus_info["route"] = data["Descripcion"][:-1] if data["Descripcion"] is not None else "-"
-        bus_info["direction"] = data["Descripcion"][-1] if data["Descripcion"] is not None else "-"
-
-        return bus_info
+        return data

ModuloLED/Makefile

@@ -1,92 +0,0 @@
-# TODO: This contains a lot of {c|p}ython build boilerplate, this needs cleanup.
-PYTHON     ?= python
-SETUP      := setup.py
-BUILD_ARGS := build --build-lib .
-INST_ARGS  := install
-ifdef DESTDIR
-INST_ARGS  += --root=$(DESTDIR)
-endif
-CLEAN_ARGS := clean --all
-
-MANPAGES := $(patsubst %.txt,%,$(wildcard *.txt))
-TXTTOMAN := a2x -f manpage
-
-# Where our library resides. It is split between includes and the binary
-# library in lib
-RGB_LIBDIR=../../lib
-RGB_LIBRARY_NAME=rgbmatrix
-RGB_LIBRARY=$(RGB_LIBDIR)/lib$(RGB_LIBRARY_NAME).a
-
-ifneq "$(wildcard debian/changelog)" ""
-PKGNAME := $(shell dpkg-parsechangelog | sed -n 's/^Source: //p')
-VERSION := $(shell dpkg-parsechangelog | sed -n 's/^Version: \([^-]*\).*/\1/p')
-UPSDIST := $(PKGNAME)-$(VERSION).tar.gz
-DEBDIST := $(PKGNAME)_$(VERSION).orig.tar.gz
-endif
-
-all: build
-build: build-python
-install: install-python
-clean: clean-python
-	find ./rgbmatrix -type f -name \*.so -delete
-	find . -type f -name \*.pyc -delete
-	$(RM) build-* install-* test-*
-
-$(RGB_LIBRARY): FORCE
-	$(MAKE) -C $(RGB_LIBDIR)
-
-test: test-python
-test-python:
-ifneq "$(wildcard tests/*.py)" ""
-	nosetests -v -w tests
-else
-	$(info Test suite is not implemented...)
-endif
-
-ifneq "$(wildcard debian/control)" ""
-PYVERS := $(shell pyversions -r -v debian/control)
-PYEXEC := $(shell pyversions -d)
-BUILD_ARGS += --executable=/usr/bin/$(PYEXEC)
-INST_ARGS  += --no-compile -O0
-
-build-python: $(PYVERS:%=build-python-%)
-build-python-%: $(RGB_LIBRARY)
-	$(info * Doing build for $(PYTHON)$* ...)
-	$(PYTHON)$* $(SETUP) $(BUILD_ARGS)
-
-install-python: $(PYVERS:%=install-python-%)
-install-python-%:
-	$(info * Doing install for $(PYTHON)$* ...)
-	$(PYTHON)$* $(SETUP) $(INST_ARGS)
-
-clean-python: $(PYVERS:%=clean-python-%)
-clean-python-%:
-	$(PYTHON)$* $(SETUP) $(CLEAN_ARGS)
-else
-build-python: $(RGB_LIBRARY)
-	$(PYTHON) $(SETUP) $(BUILD_ARGS)
-
-install-python:
-	$(PYTHON) $(SETUP) $(INST_ARGS)
-
-clean-python:
-	$(PYTHON) $(SETUP) $(CLEAN_ARGS)
-endif
-
-distclean: clean
-dist: distclean
-	$(info * Creating ../$(UPSDIST) and ../$(DEBDIST))
-	@tar --exclude='.svn' \
-	    --exclude='*.swp' \
-	    --exclude='debian' \
-	    -czvf ../$(UPSDIST) \
-	    -C ../ $(notdir $(CURDIR))
-	@cp ../$(UPSDIST) ../$(DEBDIST)
-	@if test -d ../tarballs; then \
-		mv -v ../$(DEBDIST) ../tarballs; \
-	fi
-
-FORCE:
-.PHONY: FORCE
-.PHONY: build install test clean dist distclean
-.PHONY: build-python install-python clean-python

ModuloLED/MenuPantalla.sh

@@ -1,23 +0,0 @@
-#!/bin/bash
-
-cd samples
-echo "Este es un Menú para controlar Módulos LED"
-echo "¿Que acción desea realizar?:"
-echo "1. Editar código base"
-echo "2. Desplegar Imagen"
-read N
-
-if [ $N -eq 1 ]
-then
-
-nano image-viewer.py
-
-else
-
-ls
-echo "Ingrese el nombre del archivo que desea desplegar:"
-read filename
-
-sudo python3 image-viewer.py $filename
-
-fi

ModuloLED/README.md

@@ -1,58 +0,0 @@
-# Guía de configuración para Modulo LED 
-
-## Materiales Necesarios
-
-- Raspberry Pi, versión 3 o superior.
-- Hat de conexión HUB75
-- Paneles LED P4 con I/O HUB75
-- Fuente de alimentación con salida 5V/3A
-- Cables de Alimentación 4-pin 5V/3A
-- Cables de datos con conexión HUB75
-
-## Configuración inicial
-
-### Conexionado
-
-Para las conexiones de datos, se utilizan cables hembra HUB75 de 16-pines, estos se conectan en un extremo al HAT HUB75 para Raspberry PI. En caso de tener un HAT con multiples conexiones de HUB75, siempre utilizar la salida TOP para la primera fila del conjunto de paneles, y usar el resto de las salidas para las filas inferiores. El extremo opuesto del cable de datos debe conectarse en el "input" del panel, estos modulos tienen etiquetada su entrada y salida en la parte posterior. Ver las imagenes mostradas como referencia visual. 
-
-Para la conexión electrica, cada uno de los paneles LED tiene una entrada de cuatro pines para cables de alimentación. Es necesario tener una fuente de poder con salida de 5V y un minimo de 3A, para cumplir con los criterios de alimentación en los modulos LED.
-
-![HUB75 conector](https://github.com/diegoalrv/pantallas-led/assets/148826389/5c03ffe1-eca1-42b8-bd50-4efc3d170ed7) ![HUB75 input](https://github.com/diegoalrv/pantallas-led/assets/148826389/f153e6ce-ce5e-4b19-8e2d-45ffa2d77037) ![Raspi HAT](https://github.com/diegoalrv/pantallas-led/assets/148826389/8b40b730-42ae-4416-929d-cd32de8903ee)
-
-
-A continuación, se presenta un diagrama de conexiones, tanto para los datos como para la alimentación. Notar que la referencia (0,0) corresponde a la orientación superior izquierda de las gráficas que se deseen desplegar en el módulo, también se señala la orientación de las entradas y salidas de cada panel en la configuración.
-
-![conexionModLED](https://github.com/diegoalrv/pantallas-led/assets/148826389/782bac34-8173-4207-a9f7-df2b5422b9ca.png)
-
-### Configuración de Raspberry Pi
-
-Luego de haber descargado los datos almancenados en este reposotorio. En el directorio ModuloLED, encontrará un script llamado `MenuPantalla.sh`, en este menú se puede hacer dos acciones en concreto:
-
-- Configurar parámetros de la implementación, modificando variables del codigo base.
-- Desplegar una imagen a partir de un archivo imagen jpg o png almacenada en el sistema.
-
-  #### Configuración de Parámetros
-
-  Entre las opciones de configuración en el codigo base para el funcionamiento del panel se muestran en la siguiente tabla:
-
-  | Parámetro | Variable código base | Rango de valores |
-  | ------------ | ------------ | ------------ |
-  | N° de filas de pixeles en un panel. | `options.rows` | PANEL |
-  | N° de columnas de pixeles en un panel. | `options.col` | PANEL |
-  | N° de filas de paneles montados | `options.parallel` | 1 - 3 |
-  | N° de columnas de paneles montados | `options.chain_length` | 1 - 3 |
-  | Brillo | `options.brightness` | 0 - 100 |
-  | Mapeo GPIO para HAT | `options.hardware_mapping` | `regular`, ver otras opciones [aquí](https://github.com/hzeller/rpi-rgb-led-matrix/blob/master/wiring.md#alternative-hardware-mappings) |
-  | Multiplexación | `options.multiplexing` | 1 (por defecto) - 17 |
-  | Retardo GPIO | `options.gpio_slowdown` | 1 - 5 |
-  | Max. frecuencia de frames [Hz] | `options.limit_refresh_hz` | 30* - 240 (por defecto) |
-  | Bits Resolución PWM | `options.pwm_bits` | 1 - 11 (por defecto) |
-  
-
-  **PANEL: Dado por el fabricante del panel comprado.**
-  
-  *Se pueden usar valores inferiores a 30 FPS, pero no se recomienda en términos de visibilidad
-
-  #### Despliegue de imagenes
-
-  Al seleccionar esta opción, se mostrarán todos los archivos de imagen guardados en el sistema de la Raspberry Pi. Se recomienda utilizar imagenes con la mimsa relacion de aspecto que la resolución de la pantalla montada para el despliegue. De lo contrario, la pantalla tendrá espacios en negro. 

ModuloLED/build/lib.linux-aarch64-3.9/rgbmatrix/__init__.py

@@ -1,7 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import
-
-__version__ = "0.0.1"
-__author__ = "Christoph Friedrich <christoph.friedrich@vonaffenfels.de>"
-
-from .core import RGBMatrix, FrameCanvas, RGBMatrixOptions

ModuloLED/rgbmatrix/Makefile

@@ -1,15 +0,0 @@
-# The *.cpp files are included in the distribution; this is only needed when
-# working on the pyx files.
-#
-# Please check in modified *.cpp files with distribution to not require cython
-# to be installed on the users' machine.
-# for python3: make PYTHON=$(which python3) CYTHON=$(which cython3)
-CYTHON ?= cython
-
-all : core.cpp graphics.cpp
-
-%.cpp : %.pyx
-	$(CYTHON) --cplus -o $@ $^
-
-clean:
-	rm -rf core.cpp graphics.cpp

ModuloLED/rgbmatrix/__init__.py

@@ -1,7 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import
-
-__version__ = "0.0.1"
-__author__ = "Christoph Friedrich <christoph.friedrich@vonaffenfels.de>"
-
-from .core import RGBMatrix, FrameCanvas, RGBMatrixOptions

ModuloLED/rgbmatrix/core.pxd

@@ -1,24 +0,0 @@
-cimport cppinc
-
-cdef class Canvas:
-    cdef cppinc.Canvas *__getCanvas(self) except +
-
-cdef class FrameCanvas(Canvas):
-    cdef cppinc.FrameCanvas *__canvas
-
-cdef class RGBMatrix(Canvas):
-    cdef cppinc.RGBMatrix *__matrix
-
-cdef class RGBMatrixOptions:
-    cdef cppinc.Options __options
-    cdef cppinc.RuntimeOptions __runtime_options
-    # Must keep a reference to the encoded bytes for the strings,
-    # otherwise, when the Options struct is used, it will be garbage collected
-    cdef bytes __py_encoded_hardware_mapping
-    cdef bytes __py_encoded_led_rgb_sequence
-    cdef bytes __py_encoded_pixel_mapper_config
-    cdef bytes __py_encoded_panel_type
-
-# Local Variables:
-# mode: python
-# End:

ModuloLED/rgbmatrix/core.pyx

@@ -1,272 +0,0 @@
-# distutils: language = c++
-
-from libcpp cimport bool
-from libc.stdint cimport uint8_t, uint32_t, uintptr_t
-from PIL import Image
-import cython
-
-cdef class Canvas:
-    cdef cppinc.Canvas* __getCanvas(self) except +:
-        raise Exception("Not implemented")
-
-    def SetImage(self, image, int offset_x = 0, int offset_y = 0, unsafe=True):
-        if (image.mode != "RGB"):
-            raise Exception("Currently, only RGB mode is supported for SetImage(). Please create images with mode 'RGB' or convert first with image = image.convert('RGB'). Pull requests to support more modes natively are also welcome :)")
-
-        if unsafe:
-            #In unsafe mode we directly access the underlying PIL image array
-            #in cython, which is considered unsafe pointer accecss,
-            #however it's super fast and seems to work fine
-            #https://groups.google.com/forum/#!topic/cython-users/Dc1ft5W6KM4
-            img_width, img_height = image.size
-            self.SetPixelsPillow(offset_x, offset_y, img_width, img_height, image)
-        else:
-            # First implementation of a SetImage(). OPTIMIZE_ME: A more native
-            # implementation that directly reads the buffer and calls the underlying
-            # C functions can certainly be faster.
-            img_width, img_height = image.size
-            pixels = image.load()
-            for x in range(max(0, -offset_x), min(img_width, self.width - offset_x)):
-                for y in range(max(0, -offset_y), min(img_height, self.height - offset_y)):
-                    (r, g, b) = pixels[x, y]
-                    self.SetPixel(x + offset_x, y + offset_y, r, g, b)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    def SetPixelsPillow(self, int xstart, int ystart, int width, int height, image):
-        cdef cppinc.FrameCanvas* my_canvas = <cppinc.FrameCanvas*>self.__getCanvas()
-        cdef int frame_width = my_canvas.width()
-        cdef int frame_height = my_canvas.height()
-        cdef int row, col
-        cdef uint8_t r, g, b
-        cdef uint32_t **image_ptr
-        cdef uint32_t pixel
-        image.load()
-        ptr_tmp = dict(image.im.unsafe_ptrs)['image32']
-        image_ptr = (<uint32_t **>(<uintptr_t>ptr_tmp))
-
-        for col in range(max(0, -xstart), min(width, frame_width - xstart)):
-            for row in range(max(0, -ystart), min(height, frame_height - ystart)):
-                pixel = image_ptr[row][col]
-                r = (pixel ) & 0xFF
-                g = (pixel >> 8) & 0xFF
-                b = (pixel >> 16) & 0xFF
-                my_canvas.SetPixel(xstart+col, ystart+row, r, g, b)
-
-cdef class FrameCanvas(Canvas):
-    def __dealloc__(self):
-        if <void*>self.__canvas != NULL:
-            self.__canvas = NULL
-
-    cdef cppinc.Canvas* __getCanvas(self) except *:
-        if <void*>self.__canvas != NULL:
-            return self.__canvas
-        raise Exception("Canvas was destroyed or not initialized, you cannot use this object anymore")
-
-    def Fill(self, uint8_t red, uint8_t green, uint8_t blue):
-        (<cppinc.FrameCanvas*>self.__getCanvas()).Fill(red, green, blue)
-
-    def Clear(self):
-        (<cppinc.FrameCanvas*>self.__getCanvas()).Clear()
-
-    def SetPixel(self, int x, int y, uint8_t red, uint8_t green, uint8_t blue):
-        (<cppinc.FrameCanvas*>self.__getCanvas()).SetPixel(x, y, red, green, blue)
-
-
-    property width:
-        def __get__(self): return (<cppinc.FrameCanvas*>self.__getCanvas()).width()
-
-    property height:
-        def __get__(self): return (<cppinc.FrameCanvas*>self.__getCanvas()).height()
-
-    property pwmBits:
-        def __get__(self): return (<cppinc.FrameCanvas*>self.__getCanvas()).pwmbits()
-        def __set__(self, pwmBits): (<cppinc.FrameCanvas*>self.__getCanvas()).SetPWMBits(pwmBits)
-
-    property brightness:
-        def __get__(self): return (<cppinc.FrameCanvas*>self.__getCanvas()).brightness()
-        def __set__(self, val): (<cppinc.FrameCanvas*>self.__getCanvas()).SetBrightness(val)
-
-
-cdef class RGBMatrixOptions:
-    def __cinit__(self):
-        self.__options = cppinc.Options()
-        self.__runtime_options = cppinc.RuntimeOptions()
-
-    # RGBMatrix::Options properties
-    property hardware_mapping:
-        def __get__(self): return self.__options.hardware_mapping
-        def __set__(self, value):
-            self.__py_encoded_hardware_mapping = value.encode('utf-8')
-            self.__options.hardware_mapping = self.__py_encoded_hardware_mapping
-
-    property rows:
-        def __get__(self): return self.__options.rows
-        def __set__(self, uint8_t value): self.__options.rows = value
-
-    property cols:
-        def __get__(self): return self.__options.cols
-        def __set__(self, uint32_t value): self.__options.cols = value
-
-    property chain_length:
-        def __get__(self): return self.__options.chain_length
-        def __set__(self, uint8_t value): self.__options.chain_length = value
-
-    property parallel:
-        def __get__(self): return self.__options.parallel
-        def __set__(self, uint8_t value): self.__options.parallel = value
-
-    property pwm_bits:
-        def __get__(self): return self.__options.pwm_bits
-        def __set__(self, uint8_t value): self.__options.pwm_bits = value
-
-    property pwm_lsb_nanoseconds:
-        def __get__(self): return self.__options.pwm_lsb_nanoseconds
-        def __set__(self, uint32_t value): self.__options.pwm_lsb_nanoseconds = value
-
-    property brightness:
-        def __get__(self): return self.__options.brightness
-        def __set__(self, uint8_t value): self.__options.brightness = value
-
-    property scan_mode:
-        def __get__(self): return self.__options.scan_mode
-        def __set__(self, uint8_t value): self.__options.scan_mode = value
-
-    property multiplexing:
-        def __get__(self): return self.__options.multiplexing
-        def __set__(self, uint8_t value): self.__options.multiplexing = value
-
-    property row_address_type:
-        def __get__(self): return self.__options.row_address_type
-        def __set__(self, uint8_t value): self.__options.row_address_type = value
-
-    property disable_hardware_pulsing:
-        def __get__(self): return self.__options.disable_hardware_pulsing
-        def __set__(self, value): self.__options.disable_hardware_pulsing = value
-
-    property show_refresh_rate:
-        def __get__(self): return self.__options.show_refresh_rate
-        def __set__(self, value): self.__options.show_refresh_rate = value
-
-    property inverse_colors:
-        def __get__(self): return self.__options.inverse_colors
-        def __set__(self, value): self.__options.inverse_colors = value
-
-    property led_rgb_sequence:
-        def __get__(self): return self.__options.led_rgb_sequence
-        def __set__(self, value):
-            self.__py_encoded_led_rgb_sequence = value.encode('utf-8')
-            self.__options.led_rgb_sequence = self.__py_encoded_led_rgb_sequence
-
-    property pixel_mapper_config:
-        def __get__(self): return self.__options.pixel_mapper_config
-        def __set__(self, value):
-            self.__py_encoded_pixel_mapper_config = value.encode('utf-8')
-            self.__options.pixel_mapper_config = self.__py_encoded_pixel_mapper_config
-
-    property panel_type:
-        def __get__(self): return self.__options.panel_type
-        def __set__(self, value):
-            self.__py_encoded_panel_type = value.encode('utf-8')
-            self.__options.panel_type = self.__py_encoded_panel_type
-
-    property pwm_dither_bits:
-        def __get__(self): return self.__options.pwm_dither_bits
-        def __set__(self, uint8_t value): self.__options.pwm_dither_bits = value
-
-    property limit_refresh_rate_hz:
-        def __get__(self): return self.__options.limit_refresh_rate_hz
-        def __set__(self, value): self.__options.limit_refresh_rate_hz = value
-
-
-    # RuntimeOptions properties
-
-    property gpio_slowdown:
-        def __get__(self): return self.__runtime_options.gpio_slowdown
-        def __set__(self, uint8_t value): self.__runtime_options.gpio_slowdown = value
-
-    property daemon:
-        def __get__(self): return self.__runtime_options.daemon
-        def __set__(self, uint8_t value): self.__runtime_options.daemon = value
-
-    property drop_privileges:
-        def __get__(self): return self.__runtime_options.drop_privileges
-        def __set__(self, uint8_t value): self.__runtime_options.drop_privileges = value
-
-cdef class RGBMatrix(Canvas):
-    def __cinit__(self, int rows = 0, int chains = 0, int parallel = 0,
-        RGBMatrixOptions options = None):
-
-        # If RGBMatrixOptions not provided, create defaults and set any optional
-        # parameters supplied
-        if options == None:
-            options = RGBMatrixOptions()
-
-        if rows > 0:
-            options.rows = rows
-        if chains > 0:
-            options.chain_length = chains
-        if parallel > 0:
-            options.parallel = parallel
-
-        self.__matrix = cppinc.CreateMatrixFromOptions(options.__options,
-            options.__runtime_options)
-
-    def __dealloc__(self):
-        self.__matrix.Clear()
-        del self.__matrix
-
-    cdef cppinc.Canvas* __getCanvas(self) except *:
-        if <void*>self.__matrix != NULL:
-            return self.__matrix
-        raise Exception("Canvas was destroyed or not initialized, you cannot use this object anymore")
-
-    def Fill(self, uint8_t red, uint8_t green, uint8_t blue):
-        self.__matrix.Fill(red, green, blue)
-
-    def SetPixel(self, int x, int y, uint8_t red, uint8_t green, uint8_t blue):
-        self.__matrix.SetPixel(x, y, red, green, blue)
-
-    def Clear(self):
-        self.__matrix.Clear()
-
-    def CreateFrameCanvas(self):
-        return __createFrameCanvas(self.__matrix.CreateFrameCanvas())
-
-    # The optional "framerate_fraction" parameter allows to choose which
-    # multiple of the global frame-count to use. So it slows down your animation
-    # to an exact integer fraction of the refresh rate.
-    # Default is 1, so immediately next available frame.
-    # (Say you have 140Hz refresh rate, then a value of 5 would give you an
-    # 28Hz animation, nicely locked to the refresh-rate).
-    # If you combine this with RGBMatrixOptions.limit_refresh_rate_hz you can create
-    # time-correct animations.
-    def SwapOnVSync(self, FrameCanvas newFrame, uint8_t framerate_fraction = 1):
-        return __createFrameCanvas(self.__matrix.SwapOnVSync(newFrame.__canvas, framerate_fraction))
-
-    property luminanceCorrect:
-        def __get__(self): return self.__matrix.luminance_correct()
-        def __set__(self, luminanceCorrect): self.__matrix.set_luminance_correct(luminanceCorrect)
-
-    property pwmBits:
-        def __get__(self): return self.__matrix.pwmbits()
-        def __set__(self, pwmBits): self.__matrix.SetPWMBits(pwmBits)
-
-    property brightness:
-        def __get__(self): return self.__matrix.brightness()
-        def __set__(self, brightness): self.__matrix.SetBrightness(brightness)
-
-    property height:
-        def __get__(self): return self.__matrix.height()
-
-    property width:
-        def __get__(self): return self.__matrix.width()
-
-cdef __createFrameCanvas(cppinc.FrameCanvas* newCanvas):
-    canvas = FrameCanvas()
-    canvas.__canvas = newCanvas
-    return canvas
-
-# Local Variables:
-# mode: python
-# End:

ModuloLED/rgbmatrix/cppinc.pxd

@@ -1,88 +0,0 @@
-from libcpp cimport bool
-from libc.stdint cimport uint8_t, uint32_t
-
-########################
-### External classes ###
-########################
-
-cdef extern from "canvas.h" namespace "rgb_matrix":
-    cdef cppclass Canvas:
-        int width()
-        int height()
-        void SetPixel(int, int, uint8_t, uint8_t, uint8_t) nogil
-        void Clear() nogil
-        void Fill(uint8_t, uint8_t, uint8_t) nogil
-
-cdef extern from "led-matrix.h" namespace "rgb_matrix":
-    cdef cppclass RGBMatrix(Canvas):
-        bool SetPWMBits(uint8_t)
-        uint8_t pwmbits()
-        void set_luminance_correct(bool)
-        bool luminance_correct()
-        void SetBrightness(uint8_t)
-        uint8_t brightness()
-        FrameCanvas *CreateFrameCanvas()
-        FrameCanvas *SwapOnVSync(FrameCanvas*, uint8_t)
-
-    cdef cppclass FrameCanvas(Canvas):
-        bool SetPWMBits(uint8_t)
-        uint8_t pwmbits()
-        void SetBrightness(uint8_t)
-        uint8_t brightness()
-
-    struct RuntimeOptions:
-      RuntimeOptions() except +
-      int gpio_slowdown
-      int daemon
-      int drop_privileges
-
-
-    RGBMatrix *CreateMatrixFromOptions(Options &options, RuntimeOptions runtime_options)
-
-
-
-cdef extern from "led-matrix.h" namespace "rgb_matrix::RGBMatrix":
-    cdef struct Options:
-        Options() except +
-
-        const char *hardware_mapping
-
-        int rows
-        int cols
-        int chain_length
-        int parallel
-        int pwm_bits
-        int pwm_lsb_nanoseconds
-        int brightness
-        int scan_mode
-        int row_address_type
-        int multiplexing
-        int pwm_dither_bits
-        int limit_refresh_rate_hz
-
-        bool disable_hardware_pulsing
-        bool show_refresh_rate
-        bool inverse_colors
-
-        const char *led_rgb_sequence
-        const char *pixel_mapper_config
-        const char *panel_type
-
-cdef extern from "graphics.h" namespace "rgb_matrix":
-    cdef struct Color:
-        Color(uint8_t, uint8_t, uint8_t) except +
-        uint8_t r
-        uint8_t g
-        uint8_t b
-
-    cdef cppclass Font:
-        Font() except +
-        bool LoadFont(const char*)
-        int height()
-        int baseline()
-        int CharacterWidth(uint32_t)
-        int DrawGlyph(Canvas*, int, int, const Color, uint32_t);
-
-    cdef int DrawText(Canvas*, const Font, int, int, const Color, const char*)
-    cdef void DrawCircle(Canvas*, int, int, int, const Color)
-    cdef void DrawLine(Canvas*, int, int, int, int, const Color)

ModuloLED/rgbmatrix/graphics.pxd

@@ -1,11 +0,0 @@
-cimport cppinc
-
-cdef class Color:
-    cdef cppinc.Color __color
-
-cdef class Font:
-    cdef cppinc.Font __font
-
-# Local Variables:
-# mode: python
-# End:

ModuloLED/rgbmatrix/graphics.pyx

@@ -1,54 +0,0 @@
-# distutils: language = c++
-
-from libcpp cimport bool
-from libc.stdint cimport uint8_t, uint32_t
-
-cimport core
-
-cdef class Color:
-    def __init__(self, uint8_t red = 0, uint8_t green = 0, uint8_t blue = 0):
-        self.__color.r = red
-        self.__color.g = green
-        self.__color.b = blue
-
-    property red:
-        def __get__(self): return self.__color.r
-        def __set__(self, uint8_t value): self.__color.r = value
-
-    property green:
-        def __get__(self): return self.__color.g
-        def __set__(self, uint8_t value): self.__color.g = value
-
-    property blue:
-        def __get__(self): return self.__color.b
-        def __set__(self, uint8_t value): self.__color.b = value
-
-cdef class Font:
-    def CharacterWidth(self, uint32_t char):
-        return self.__font.CharacterWidth(char)
-
-    def LoadFont(self, file):
-        if (not self.__font.LoadFont(file.encode('utf-8'))):
-            raise Exception("Couldn't load font " + file)
-
-    def DrawGlyph(self, core.Canvas c, int x, int y, Color color, uint32_t char):
-        return self.__font.DrawGlyph(c.__getCanvas(), x, y, color.__color, char)
-
-    property height:
-        def __get__(self): return self.__font.height()
-
-    property baseline:
-        def __get__(self): return self.__font.baseline()
-
-def DrawText(core.Canvas c, Font f, int x, int y, Color color, text):
-    return cppinc.DrawText(c.__getCanvas(), f.__font, x, y, color.__color, text.encode('utf-8'))
-
-def DrawCircle(core.Canvas c, int x, int y, int r, Color color):
-    cppinc.DrawCircle(c.__getCanvas(), x, y, r, color.__color)
-
-def DrawLine(core.Canvas c, int x1, int y1, int x2, int y2, Color color):
-    cppinc.DrawLine(c.__getCanvas(), x1, y1, x2, y2, color.__color)
-
-# Local Variables:
-# mode: python
-# End:

ModuloLED/samples/gif-viewer.py

@@ -1,62 +0,0 @@
-#!/usr/bin/env python
-import time
-import sys
-
-from rgbmatrix import RGBMatrix, RGBMatrixOptions
-from PIL import Image
-
-
-if len(sys.argv) < 2:
-    sys.exit("Require a gif argument")
-else:
-    image_file = sys.argv[1]
-
-gif = Image.open(image_file)
-
-try:
-    num_frames = gif.n_frames
-except Exception:
-    sys.exit("provided image is not a gif")
-
-
-# Configuration for the matrix
-options = RGBMatrixOptions()
-options.rows = 40
-options.cols = 80
-options.chain_length = 3
-options.parallel = 3
-options.hardware_mapping = 'regular'  # If you have an Adafruit HAT: 'adafruit-hat'
-options.multiplexing = 1
-options.brightness = 10
-
-matrix = RGBMatrix(options = options)
-
-# Preprocess the gifs frames into canvases to improve playback performance
-canvases = []
-print("Preprocessing gif, this may take a moment depending on the size of the gif...")
-for frame_index in range(0, num_frames):
-    gif.seek(frame_index)
-    # must copy the frame out of the gif, since thumbnail() modifies the image in-place
-    frame = gif.copy()
-    frame.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)
-    canvas = matrix.CreateFrameCanvas()
-    canvas.SetImage(frame.convert("RGB"))
-    canvases.append(canvas)
-# Close the gif file to save memory now that we have copied out all of the frames
-gif.close()
-
-print("Completed Preprocessing, displaying gif")
-
-try:
-    print("Press CTRL-C to stop.")
-
-    # Infinitely loop through the gif
-    cur_frame = 0
-    while(True):
-        matrix.SwapOnVSync(canvases[cur_frame], framerate_fraction=30)
-        if cur_frame == num_frames - 1:
-            cur_frame = 0
-        else:
-            cur_frame += 1
-except KeyboardInterrupt:
-    sys.exit(0)

ModuloLED/samples/graphics.py

@@ -1,32 +0,0 @@
-#!/usr/bin/env python
-from samplebase import SampleBase
-from rgbmatrix import graphics
-import time
-
-
-class GraphicsTest(SampleBase):
-    def __init__(self, *args, **kwargs):
-        super(GraphicsTest, self).__init__(*args, **kwargs)
-
-    def run(self):
-        canvas = self.matrix
-        font = graphics.Font()
-        font.LoadFont("../../../fonts/7x13.bdf")
-
-        red = graphics.Color(255, 0, 0)
-        graphics.DrawLine(canvas, 5, 5, 22, 13, red)
-
-        green = graphics.Color(0, 255, 0)
-        graphics.DrawCircle(canvas, 15, 15, 10, green)
-
-        blue = graphics.Color(0, 0, 255)
-        graphics.DrawText(canvas, font, 2, 10, blue, "Text")
-
-        time.sleep(10)   # show display for 10 seconds before exit
-
-
-# Main function
-if __name__ == "__main__":
-    graphics_test = GraphicsTest()
-    if (not graphics_test.process()):
-        graphics_test.print_help()

ModuloLED/samples/grayscale-block.py

@@ -1,39 +0,0 @@
-#!/usr/bin/env python
-from samplebase import SampleBase
-import time
-
-
-class GrayscaleBlock(SampleBase):
-    def __init__(self, *args, **kwargs):
-        super(GrayscaleBlock, self).__init__(*args, **kwargs)
-
-    def run(self):
-        sub_blocks = 16
-        width = self.matrix.width
-        height = self.matrix.height
-        x_step = max(1, width / sub_blocks)
-        y_step = max(1, height / sub_blocks)
-        count = 0
-
-        while True:
-            for y in range(0, height):
-                for x in range(0, width):
-                    c = sub_blocks * int(y / y_step) + int(x / x_step)
-                    if count % 4 == 0:
-                        self.matrix.SetPixel(x, y, c, c, c)
-                    elif count % 4 == 1:
-                        self.matrix.SetPixel(x, y, c, 0, 0)
-                    elif count % 4 == 2:
-                        self.matrix.SetPixel(x, y, 0, c, 0)
-                    elif count % 4 == 3:
-                        self.matrix.SetPixel(x, y, 0, 0, c)
-
-            count += 1
-            time.sleep(2)
-
-
-# Main function
-if __name__ == "__main__":
-    grayscale_block = GrayscaleBlock()
-    if (not grayscale_block.process()):
-        grayscale_block.print_help()

ModuloLED/samples/image-draw.py

@@ -1,48 +0,0 @@
-#!/usr/bin/env python
-
-# (This is an example similar to an example from the Adafruit fork
-#  to show the similarities. Most important difference currently is, that
-#  this library wants RGB mode.)
-#
-# A more complex RGBMatrix example works with the Python Imaging Library,
-# demonstrating a few graphics primitives and image loading.
-# Note that PIL graphics do not have an immediate effect on the display --
-# image is drawn into a separate buffer, which is then copied to the matrix
-# using the SetImage() function (see examples below).
-# Requires rgbmatrix.so present in the same directory.
-
-# PIL Image module (create or load images) is explained here:
-# http://effbot.org/imagingbook/image.htm
-# PIL ImageDraw module (draw shapes to images) explained here:
-# 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 = 32
-options.chain_length = 1
-options.parallel = 1
-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", (32, 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, 31, 31), fill=(255, 0, 0))
-draw.line((0, 31, 31, 0), fill=(0, 255, 0))
-
-# Then scroll image across matrix...
-for n in range(-32, 33):  # Start off top-left, move off bottom-right
-    matrix.Clear()
-    matrix.SetImage(image, n, n)
-    time.sleep(0.05)
-
-matrix.Clear()

ModuloLED/samples/image-scroller.py

@@ -1,40 +0,0 @@
-#!/usr/bin/env python
-import time
-from samplebase import SampleBase
-from PIL import Image
-
-
-class ImageScroller(SampleBase):
-    def __init__(self, *args, **kwargs):
-        super(ImageScroller, self).__init__(*args, **kwargs)
-        self.parser.add_argument("-i", "--image", help="The image to display", default="../../../examples-api-use/runtext.ppm")
-
-    def run(self):
-        if not 'image' in self.__dict__:
-            self.image = Image.open(self.args.image).convert('RGB')
-        self.image.resize((self.matrix.width, self.matrix.height), Image.ANTIALIAS)
-
-        double_buffer = self.matrix.CreateFrameCanvas()
-        img_width, img_height = self.image.size
-
-        # let's scroll
-        xpos = 0
-        while True:
-            xpos += 1
-            if (xpos > img_width):
-                xpos = 0
-
-            double_buffer.SetImage(self.image, -xpos)
-            double_buffer.SetImage(self.image, -xpos + img_width)
-
-            double_buffer = self.matrix.SwapOnVSync(double_buffer)
-            time.sleep(0.01)
-
-# Main function
-# e.g. call with
-#  sudo ./image-scroller.py --chain=4
-# if you have a chain of four
-if __name__ == "__main__":
-    image_scroller = ImageScroller()
-    if (not image_scroller.process()):
-        image_scroller.print_help()

ModuloLED/samples/image-viewer.py

@@ -1,43 +0,0 @@
-#!/usr/bin/env python
-import time
-import sys
-
-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 = 40
-options.cols = 80
-options.chain_length = 2
-options.parallel = 1
-options.gpio_slowdown = 4
-#options.row_address_type = 0
-
-options.hardware_mapping = 'regular'  # If you have an Adafruit HAT: 'adafruit-hat'
-options.multiplexing = 1
-options.brightness = 20
-#options.pwm_lsb_nanoseconds = 300
-#options.pwm_bits = 11
-
-
-matrix = RGBMatrix(options = options)
-
-# Make image fit our screen.
-image.thumbnail((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)

ModuloLED/samples/img_processed/image-viewer.py

@@ -1,56 +0,0 @@
-#!/usr/bin/env python
-import time
-import sys
-
-from rgbmatrix import RGBMatrix, RGBMatrixOptions
-from PIL import Image
-
-import os
-
-def resize_image(input_path, output_path):
-    try:
-        # Abrir la imagen de entrada
-        image = Image.open(input_path)
-        # Obtener el tamaño original de la imagen
-        original_width, original_height = image.size
-        # Calcular el nuevo alto (mitad del ancho)
-        new_height = original_width // 2
-        # Redimensionar la imagen
-        resized_image = image.resize((original_width, new_height))
-        # Guardar la imagen redimensionada en la carpeta img_processed
-        resized_image.save(output_path)
-        print("Imagen redimensionada y guardada correctamente.")
-        return resized_image
-    except Exception as e:
-        print("Error:", e)
-
-if len(sys.argv) < 2:
-    sys.exit("Require an image argument")
-else:
-    image_file = sys.argv[1]
-    image = resize_image(image_file, image_file.replace(".jpeg","_r.jpeg"))
-
-
-# Configuration for the matrix
-options = RGBMatrixOptions()
-options.rows = 40
-options.cols = 80
-options.chain_length = 3
-options.parallel = 3
-options.hardware_mapping = 'regular'  # If you have an Adafruit HAT: 'adafruit-hat'
-options.multiplexing = 1
-options.brightness = 30
-
-matrix = RGBMatrix(options = options)
-
-# Make image fit our screen.
-image.thumbnail((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)

ModuloLED/samples/pulsing-brightness.py

@@ -1,36 +0,0 @@
-#!/usr/bin/env python
-from samplebase import SampleBase
-
-
-class GrayscaleBlock(SampleBase):
-    def __init__(self, *args, **kwargs):
-        super(GrayscaleBlock, self).__init__(*args, **kwargs)
-
-    def run(self):
-        max_brightness = self.matrix.brightness
-        count = 0
-        c = 255
-
-        while (True):
-            if self.matrix.brightness < 1:
-                self.matrix.brightness = max_brightness
-                count += 1
-            else:
-                self.matrix.brightness -= 1
-
-            if count % 4 == 0:
-                self.matrix.Fill(c, 0, 0)
-            elif count % 4 == 1:
-                self.matrix.Fill(0, c, 0)
-            elif count % 4 == 2:
-                self.matrix.Fill(0, 0, c)
-            elif count % 4 == 3:
-                self.matrix.Fill(c, c, c)
-
-            self.usleep(20 * 1000)
-
-# Main function
-if __name__ == "__main__":
-    grayscale_block = GrayscaleBlock()
-    if (not grayscale_block.process()):
-        grayscale_block.print_help()

ModuloLED/samples/pulsing-colors.py

@@ -1,42 +0,0 @@
-#!/usr/bin/env python
-from samplebase import SampleBase
-
-
-class PulsingColors(SampleBase):
-    def __init__(self, *args, **kwargs):
-        super(PulsingColors, self).__init__(*args, **kwargs)
-
-    def run(self):
-        self.offscreen_canvas = self.matrix.CreateFrameCanvas()
-        continuum = 0
-
-        while True:
-            self.usleep(5 * 1000)
-            continuum += 1
-            continuum %= 3 * 255
-
-            red = 0
-            green = 0
-            blue = 0
-
-            if continuum <= 255:
-                c = continuum
-                blue = 255 - c
-                red = c
-            elif continuum > 255 and continuum <= 511:
-                c = continuum - 256
-                red = 255 - c
-                green = c
-            else:
-                c = continuum - 512
-                green = 255 - c
-                blue = c
-
-            self.offscreen_canvas.Fill(red, green, blue)
-            self.offscreen_canvas = self.matrix.SwapOnVSync(self.offscreen_canvas)
-
-# Main function
-if __name__ == "__main__":
-    pulsing_colors = PulsingColors()
-    if (not pulsing_colors.process()):
-        pulsing_colors.print_help()

ModuloLED/samples/rotating-block-generator.py

@@ -1,72 +0,0 @@
-#!/usr/bin/env python
-from samplebase import SampleBase
-import math
-
-
-def scale_col(val, lo, hi):
-    if val < lo:
-        return 0
-    if val > hi:
-        return 255
-    return 255 * (val - lo) / (hi - lo)
-
-
-def rotate(x, y, sin, cos):
-    return x * cos - y * sin, x * sin + y * cos
-
-
-class RotatingBlockGenerator(SampleBase):
-    def __init__(self, *args, **kwargs):
-        super(RotatingBlockGenerator, self).__init__(*args, **kwargs)
-
-    def run(self):
-        cent_x = self.matrix.width / 2
-        cent_y = self.matrix.height / 2
-
-        rotate_square = min(self.matrix.width, self.matrix.height) * 1.41
-        min_rotate = cent_x - rotate_square / 2
-        max_rotate = cent_x + rotate_square / 2
-
-        display_square = min(self.matrix.width, self.matrix.height) * 0.7
-        min_display = cent_x - display_square / 2
-        max_display = cent_x + display_square / 2
-
-        deg_to_rad = 2 * 3.14159265 / 360
-        rotation = 0
-
-        # Pre calculate colors
-        col_table = []
-        for x in range(int(min_rotate), int(max_rotate)):
-            col_table.insert(x, scale_col(x, min_display, max_display))
-
-        offset_canvas = self.matrix.CreateFrameCanvas()
-
-        while True:
-            rotation += 1
-            rotation %= 360
-
-            # calculate sin and cos once for each frame
-            angle = rotation * deg_to_rad
-            sin = math.sin(angle)
-            cos = math.cos(angle)
-
-            for x in range(int(min_rotate), int(max_rotate)):
-                for y in range(int(min_rotate), int(max_rotate)):
-                    # Our rotate center is always offset by cent_x
-                    rot_x, rot_y = rotate(x - cent_x, y - cent_x, sin, cos)
-
-                    if x >= min_display and x < max_display and y >= min_display and y < max_display:
-                        x_col = col_table[x]
-                        y_col = col_table[y]
-                        offset_canvas.SetPixel(rot_x + cent_x, rot_y + cent_y, x_col, 255 - y_col, y_col)
-                    else:
-                        offset_canvas.SetPixel(rot_x + cent_x, rot_y + cent_y, 0, 0, 0)
-
-            offset_canvas = self.matrix.SwapOnVSync(offset_canvas)
-
-
-# Main function
-if __name__ == "__main__":
-    rotating_block_generator = RotatingBlockGenerator()
-    if (not rotating_block_generator.process()):
-        rotating_block_generator.print_help()

ModuloLED/samples/runtext.py

@@ -1,36 +0,0 @@
-#!/usr/bin/env python
-# Display a runtext with double-buffering.
-from samplebase import SampleBase
-from rgbmatrix import graphics
-import time
-
-
-class RunText(SampleBase):
-    def __init__(self, *args, **kwargs):
-        super(RunText, self).__init__(*args, **kwargs)
-        self.parser.add_argument("-t", "--text", help="The text to scroll on the RGB LED panel", default="Hello world!")
-
-    def run(self):
-        offscreen_canvas = self.matrix.CreateFrameCanvas()
-        font = graphics.Font()
-        font.LoadFont("../../../fonts/7x13.bdf")
-        textColor = graphics.Color(255, 255, 255)
-        pos = offscreen_canvas.width
-        my_text = self.args.text
-
-        while True:
-            offscreen_canvas.Clear()
-            len = graphics.DrawText(offscreen_canvas, font, pos, 10, textColor, my_text)
-            pos -= 1
-            if (pos + len < 0):
-                pos = offscreen_canvas.width
-
-            time.sleep(0.05)
-            offscreen_canvas = self.matrix.SwapOnVSync(offscreen_canvas)
-
-
-# Main function
-if __name__ == "__main__":
-    run_text = RunText()
-    if (not run_text.process()):
-        run_text.print_help()

ModuloLED/samples/samplebase.py

@@ -1,81 +0,0 @@
-import argparse
-import time
-import sys
-import os
-
-sys.path.append(os.path.abspath(os.path.dirname(__file__) + '/..'))
-from rgbmatrix import RGBMatrix, RGBMatrixOptions
-
-
-class SampleBase(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("--led-cols", action="store", help="Panel columns. Typically 32 or 64. (Default: 32)", default=32, type=int)
-        self.parser.add_argument("-c", "--led-chain", action="store", help="Daisy-chained boards. Default: 1.", default=1, 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" , choices=['regular', 'regular-pi1', 'adafruit-hat', 'adafruit-hat-pwm'], 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: 0..4. Default: 1", default=1, 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("--led-pixel-mapper", action="store", help="Apply pixel mappers. e.g \"Rotate:90\"", default="", type=str)
-        self.parser.add_argument("--led-row-addr-type", action="store", help="0 = default; 1=AB-addressed panels; 2=row direct; 3=ABC-addressed panels; 4 = ABC Shift + DE direct", default=0, type=int, choices=[0,1,2,3,4])
-        self.parser.add_argument("--led-multiplexing", action="store", help="Multiplexing type: 0=direct; 1=strip; 2=checker; 3=spiral; 4=ZStripe; 5=ZnMirrorZStripe; 6=coreman; 7=Kaler2Scan; 8=ZStripeUneven... (Default: 0)", default=0, type=int)
-        self.parser.add_argument("--led-panel-type", action="store", help="Needed to initialize special panels. Supported: 'FM6126A'", default="", type=str)
-        self.parser.add_argument("--led-no-drop-privs", dest="drop_privileges", help="Don't drop privileges from 'root' after initializing the hardware.", action='store_false')
-        self.parser.set_defaults(drop_privileges=True)
-
-    def usleep(self, value):
-        time.sleep(value / 1000000.0)
-
-    def run(self):
-        print("Running")
-
-    def process(self):
-        self.args = self.parser.parse_args()
-
-        options = RGBMatrixOptions()
-
-        if self.args.led_gpio_mapping != None:
-          options.hardware_mapping = self.args.led_gpio_mapping
-        options.rows = self.args.led_rows
-        options.cols = self.args.led_cols
-        options.chain_length = self.args.led_chain
-        options.parallel = self.args.led_parallel
-        options.row_address_type = self.args.led_row_addr_type
-        options.multiplexing = self.args.led_multiplexing
-        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
-        options.pixel_mapper_config = self.args.led_pixel_mapper
-        options.panel_type = self.args.led_panel_type
-
-
-        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
-        if not self.args.drop_privileges:
-          options.drop_privileges=False
-
-        self.matrix = RGBMatrix(options = options)
-
-        try:
-            # Start loop
-            print("Press CTRL-C to stop sample")
-            self.run()
-        except KeyboardInterrupt:
-            print("Exiting\n")
-            sys.exit(0)
-
-        return True

ModuloLED/samples/simple-square.py

@@ -1,30 +0,0 @@
-#!/usr/bin/env python
-from samplebase import SampleBase
-
-
-class SimpleSquare(SampleBase):
-    def __init__(self, *args, **kwargs):
-        super(SimpleSquare, self).__init__(*args, **kwargs)
-
-    def run(self):
-        offset_canvas = self.matrix.CreateFrameCanvas()
-        while True:
-            for x in range(0, self.matrix.width):
-                offset_canvas.SetPixel(x, x, 255, 255, 255)
-                offset_canvas.SetPixel(offset_canvas.height - 1 - x, x, 255, 0, 255)
-
-            for x in range(0, offset_canvas.width):
-                offset_canvas.SetPixel(x, 0, 255, 0, 0)
-                offset_canvas.SetPixel(x, offset_canvas.height - 1, 255, 255, 0)
-
-            for y in range(0, offset_canvas.height):
-                offset_canvas.SetPixel(0, y, 0, 0, 255)
-                offset_canvas.SetPixel(offset_canvas.width - 1, y, 0, 255, 0)
-            offset_canvas = self.matrix.SwapOnVSync(offset_canvas)
-
-
-# Main function
-if __name__ == "__main__":
-    simple_square = SimpleSquare()
-    if (not simple_square.process()):
-        simple_square.print_help()

ModuloLED/setup.py

@@ -1,33 +0,0 @@
-#!/usr/bin/python
-from distutils.core import setup, Extension
-
-core_ext = Extension(
-    name                = 'core',
-    sources             = ['rgbmatrix/core.cpp'],
-    include_dirs        = ['../../include'],
-    library_dirs        = ['../../lib'],
-    libraries           = ['rgbmatrix'],
-    extra_compile_args  = ["-O3", "-Wall"],
-    language            = 'c++'
-)
-
-graphics_ext = Extension(
-    name                = 'graphics',
-    sources             = ['rgbmatrix/graphics.cpp'],
-    include_dirs        = ['../../include'],
-    library_dirs        = ['../../lib'],
-    libraries           = ['rgbmatrix'],
-    extra_compile_args  = ["-O3", "-Wall"],
-    language            = 'c++'
-)
-
-setup(
-    name                = 'rgbmatrix',
-    version             = '0.0.1',
-    author              = 'Christoph Friedrich',
-    author_email        = 'christoph.friedrich@vonaffenfels.de',
-    classifiers         = ['Development Status :: 3 - Alpha'],
-    ext_package         = 'rgbmatrix',
-    ext_modules         = [core_ext, graphics_ext],
-    packages            = ['rgbmatrix']
-)

autorun.sh

@@ -1,12 +1,13 @@
 #!/bin/bash
 
+IMAGE=$HOME/pantallas-led/GenPoster/example/poster.png
 
 #sudo python3 testapi_full.py
 cd pantallas-led/GenPoster
 #docker build -t bus_poster .
 ./run_container.sh
-cd example
-sleep 4
-feh poster.png
 
+cd rpi-rgb-led-matrix/bindings/python/samples/
+
+python3 image-viewer.py $IMAGE
 

testapi_full.py

@@ -98,6 +98,8 @@ else:
 info = response_getinfodevice.json()
 #print(json.dumps(info, indent=4, ensure_ascii=False, sort_keys=True))
 
+print(info)
+
 print("----------------------------------------------------------")
 print("Cantidad de buses con llegada registrada en este paradero:", len(info["GetInfoDeviceResponse"]["DetalleLineas"]))
 print("----------------------------------------------------------")