from machine import Pin from micropython import const import framebuf import font import icon _DIGIT_0 = const(0x1) _DECODE_MODE = const(0x9) _NO_DECODE = const(0x0) _INTENSITY = const(0xA) _INTENSITY_MIN = const(0x0) _SCAN_LIMIT = const(0xB) _DISPLAY_ALL_DIGITS = const(0x7) _SHUTDOWN = const(0xC) _SHUTDOWN_MODE = const(0x0) _NORMAL_OPERATION = const(0x1) _DISPLAY_TEST = const(0xF) _DISPLAY_TEST_NORMAL_OPERATION = const(0x0) _MATRIX_SIZE = const(8) class Max7219(framebuf.FrameBuffer): """ Driver for MAX7219 8x8 LED matrices Example for ESP8266 with 2x4 matrices (one on top, one on bottom), so we have a 32x16 display area: >>> from machine import Pin, SPI >>> from max7219 import Max7219 >>> spi = SPI(1, baudrate=10000000) >>> screen = Max7219(32, 16, spi, Pin(15)) >>> screen.rect(0, 0, 32, 16, 1) # Draws a frame >>> screen.text('Hi!', 4, 4, 1) >>> screen.show() On some matrices, the display is inverted (rotated 180°), in this case you can use `rotate_180=True` in the class constructor. """ def __init__(self, width, height, spi, cs, rotate_180=False): # Pins setup self.spi = spi self.cs = cs self.cs.init(Pin.OUT, True) # Dimensions self.width = width self.height = height # Guess matrices disposition self.cols = width // _MATRIX_SIZE self.rows = height // _MATRIX_SIZE self.nb_matrices = self.cols * self.rows self.rotate_180 = rotate_180 # 1 bit per pixel (on / off) -> 8 bytes per matrix self.buffer = bytearray(width * height // 8) format = framebuf.MONO_HLSB if not self.rotate_180 else framebuf.MONO_HMSB super().__init__(self.buffer, width, height, format) # Init display self.init_display() def _write_command(self, command, data): """Write command on SPI""" cmd = bytearray([command, data]) self.cs(0) for matrix in range(self.nb_matrices): self.spi.write(cmd) self.cs(1) def init_display(self): """Init hardware""" for command, data in ( (_SHUTDOWN, _SHUTDOWN_MODE), # Prevent flash during init (_DECODE_MODE, _NO_DECODE), (_DISPLAY_TEST, _DISPLAY_TEST_NORMAL_OPERATION), (_INTENSITY, _INTENSITY_MIN), (_SCAN_LIMIT, _DISPLAY_ALL_DIGITS), (_SHUTDOWN, _NORMAL_OPERATION), # Let's go ): self._write_command(command, data) self.fill(0) self.show() def brightness(self, value): """Set display brightness (0 to 15)""" if not 0 <= value < 16: raise ValueError("Brightness must be between 0 and 15") self._write_command(_INTENSITY, value) def draw_chinese(self, text, x_axis, y_axis): """Display Chinese text on screen""" for char_index, char in enumerate(text): try: # Get UTF-8 encoding of the character utf8_bytes = char.encode('utf-8') # Convert UTF-8 bytes to integer as key if len(utf8_bytes) == 3: # Chinese characters are 3 bytes in UTF-8 word_code = (utf8_bytes[0] << 16) | (utf8_bytes[1] << 8) | utf8_bytes[2] else: continue # Skip non-Chinese characters # Get font data for the character char_data = font.font[word_code] # Draw each row of the character for y in range(16): # Get data for top and bottom part of the row top_part = char_data[y] bottom_part = char_data[y + 16] # Calculate actual position on screen screen_y = y_axis + y # Ensure we're within screen bounds if screen_y < 0 or screen_y >= self.height: continue # For each byte in the row (left and right parts of the character) for byte_index in range(2): byte_data = top_part if byte_index == 0 else bottom_part # Calculate screen x position for this byte screen_x = x_axis + char_index * 16 + byte_index * 8 # Set pixel data directly in the framebuffer for x in range(8): pixel_x = screen_x + x if pixel_x < 0 or pixel_x >= self.width: continue # Determine the bit position based on FrameBuffer format if not self.rotate_180: # MONO_HLSB format # In MONO_HLSB, the first bit is the leftmost pixel bit_pos = 7 - x else: # MONO_HMSB format # In MONO_HMSB, the first bit is the leftmost pixel bit_pos = 7 - x # Set the pixel value pixel_value = (byte_data >> bit_pos) & 1 self.pixel(pixel_x, screen_y, pixel_value) except KeyError as e: # Character not found in font dictionary print(f"Character not found in font: {char} (UTF-8 code: 0x{word_code:x})") pass def draw_icon(self, name, x_axis, y_axis, height, width): """Display icon on screen""" try: # Get icon data byte_data = icon.icon.get(name) if not byte_data: print(f"Icon not found: {name}") return # For 16x16 icons specifically, handle similar to Chinese characters if height == 16 and width == 16: # Draw each row of the icon for y in range(16): # Get data for left and right part of the row if y < len(byte_data) // 2: left_part = byte_data[y] right_part = byte_data[y + 16] if y + 16 < len(byte_data) else 0 else: left_part = 0 right_part = 0 # Calculate actual position on screen screen_y = y_axis + y # Ensure we're within screen bounds if screen_y < 0 or screen_y >= self.height: continue # Draw left part (first 8 pixels) screen_x_left = x_axis for x in range(8): pixel_x = screen_x_left + x if pixel_x < 0 or pixel_x >= self.width: continue # Determine the bit position based on FrameBuffer format if not self.rotate_180: # MONO_HLSB format bit_pos = 7 - x else: # MONO_HMSB format bit_pos = 7 - x # Set the pixel value pixel_value = (left_part >> bit_pos) & 1 self.pixel(pixel_x, screen_y, pixel_value) # Draw right part (next 8 pixels) screen_x_right = x_axis + 8 for x in range(8): pixel_x = screen_x_right + x if pixel_x < 0 or pixel_x >= self.width: continue # Determine the bit position based on FrameBuffer format if not self.rotate_180: # MONO_HLSB format bit_pos = 7 - x else: # MONO_HMSB format bit_pos = 7 - x # Set the pixel value pixel_value = (right_part >> bit_pos) & 1 self.pixel(pixel_x, screen_y, pixel_value) except Exception as e: # Error loading or drawing icon print(f"Error drawing icon: {e}") import sys import traceback traceback.print_exc() pass def show(self): """Update display""" # Write line per line on the matrices for line in range(8): self.cs(0) for matrix in range(self.nb_matrices): # Guess where the matrix is placed row, col = divmod(matrix, self.cols) # 反转行顺序，解决显示顺序颠倒问题 row = self.rows - 1 - row # Compute where the data starts if not self.rotate_180: offset = row * 8 * self.cols index = col + line * self.cols + offset # 对于非旋转模式，需要反转位顺序 data = self.buffer[index] reversed_data = 0 for i in range(8): reversed_data = (reversed_data << 1) | (data & 1) data = data >> 1 else: offset = 8 * self.cols - row * self.cols * 8 - 1 index = self.cols * (8 - line) - col + offset # 对于旋转模式，不需要反转位顺序，使用原始数据 reversed_data = self.buffer[index] self.spi.write(bytearray([_DIGIT_0 + line, reversed_data])) self.cs(1)