MAX7219-7-seg.ino

diagram.json

// Wokwi Custom Chip - For information and examples see:
// https://link.wokwi.com/custom-chips-alpha
//
// SPDX-License-Identifier: MIT
// Copyright (C) 2022 Uri Shaked / wokwi.com

#include "wokwi-api.h"
#include <stdio.h>
#include <stdlib.h>

// Wokwi Custom Chip - For information and examples see:
// https://link.wokwi.com/custom-chips-alpha
//
// SPDX-License-Identifier: MIT
// Copyright (C) 2022 Sean D Johnston / wokwi.com

#include "wokwi-api.h"
#include <stdio.h>
#include <stdlib.h>

const int MS = 1000; // micros

uint8_t segments[][11] = {
  {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, // DP
  {0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00}, // G
  {0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // F
  {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00}, // E
  {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78}, // D
  {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x00}, // C
  {0x00, 0x04, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // B
  {0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}  // A
};

typedef struct {
  uint8_t r;
  uint8_t g;
  uint8_t b;
  uint8_t a;
} rgba_t;

static void chip_timer_event(void *user_data);

rgba_t black = { .r = 0x00, .g=0x00, .b=0x00, .a=0x00 };
rgba_t display_color = { .r = 0xff, .g=0xff, .b=0xff, .a=0xff };

// Index for SEG_X
#define SEG_A 7
#define SEG_B 6
#define SEG_C 5
#define SEG_D 4
#define SEG_E 3
#define SEG_F 2
#define SEG_G 1
#define SEG_DP 0

// Chip state
typedef struct {
  pin_t pin_seg[8];      // SEG_X pins
  pin_t pin_dig[8];      // DIG_X pins

  pin_t pin_load;        // LOAD pin
  pin_t pin_dout;        // DOUT pin

  pin_t digit_pin;       // Digit is currently being displayed

  uint8_t spi_buffer[2]; // 16 bit register for the command
  uint32_t spi;          // SPI handle

  uint8_t div;           // Division counter for intensity

  uint16_t decode_mode;  // Bits to for decoded digit 1=decode, 0 normal
  uint8_t scan_limit;    // Scan limit of the display
  uint8_t intensity;     // Intensitry of the display (Not implemented)
  uint8_t display_test;  // Test mode 0 = Normal, 1 = Test mode
  uint8_t shutdown_mode; // Shutown mode 0 = Normal, 1 = Shutdown mode

  uint8_t digits[8];     // Storage for all the values of the digits

  buffer_t framebuffer;
  uint32_t width;
  uint32_t height;
  uint32_t row;

} chip_state_t;

// Deoding for Code B font
uint8_t decode_digits[] = {
  0b11111100, // 0
  0b01100000, // 1
  0b11011010, // 2
  0b11110010, // 3
  0b01100110, // 4
  0b10110110, // 5
  0b10111110, // 6
  0b11100000, // 7
  0b11111110, // 8
  0b11110110, // 9
  0b00000010, // -
  0b10011110, // E
  0b01101110, // H
  0b00011100, // L
  0b11001110, // P
  0b00000000, // Blank
};

void draw_line(chip_state_t *chip, uint32_t row, int x_offset, rgba_t color, uint8_t dig, int len) {
  uint32_t offset = chip->width * 4 * row;
  int pos = 0;
  for (int x = 0; x < len; x++) {
    if (dig & 0x80) {
      buffer_write(chip->framebuffer, (x_offset *4) + offset + pos, (uint8_t*)&color, sizeof(color));
      buffer_write(chip->framebuffer, (x_offset *4) + offset + pos + 4, (uint8_t*)&color, sizeof(color));
      buffer_write(chip->framebuffer, (x_offset *4) + offset + pos + 8, (uint8_t*)&color, sizeof(color));
      buffer_write(chip->framebuffer, (x_offset *4) + offset + pos + 12, (uint8_t*)&color, sizeof(color));
    }
    else {
      buffer_write(chip->framebuffer, (x_offset *4) + offset + pos, (uint8_t*)&black, sizeof(color));
      buffer_write(chip->framebuffer, (x_offset *4) + offset + pos + 4, (uint8_t*)&black, sizeof(color));
      buffer_write(chip->framebuffer, (x_offset *4) + offset + pos + 8, (uint8_t*)&black, sizeof(color));
      buffer_write(chip->framebuffer, (x_offset *4) + offset + pos + 12, (uint8_t*)&black, sizeof(color));
    }

    dig = dig << 1;
    pos += 4 * 4;
  }
}

void print_digit(chip_state_t *chip, int digit, uint8_t *dig, rgba_t color) {
  int x_offset = (7-digit) * 35;
  int cnt = 0;
  int cnt2 = 0;
  while (cnt < 11) {
    //printf("%d - %i\n", cnt, dig[cnt]);
    draw_line(chip, cnt2, x_offset, color, dig[cnt], 8);
    cnt2++;
    draw_line(chip, cnt2, x_offset, color, dig[cnt], 8);
    cnt2++;
    draw_line(chip, cnt2, x_offset, color, dig[cnt], 8);
    cnt2++;
    draw_line(chip, cnt2, x_offset, color, dig[cnt], 8);
    cnt2++;
    cnt++;
    if (cnt > 20) break;
  }
}

void set_segment(chip_state_t *chip, uint8_t segment, int digit, rgba_t color, int do_segments) {

  if (digit > chip->scan_limit && !do_segments) {
    return;
  }
 //int x_offset = digit * 35;
  uint8_t temp_seg = segment;
  //if (!do_segments) {
  //  chip->digits[digit] = segment;
  //}
  printf("----%d\n", temp_seg);
  // a - top
  // b - top right
  // c - bottom right
  // d - bottom
  // e - bottom left
  // f - top left
  // g - center
  
  uint8_t s[11] = {0,0,0,0,0,0,0,0,0,0,0};

  uint8_t decode = chip->decode_mode >> digit;
  if (do_segments) decode = 0x00;

  if (chip->display_test) {
      temp_seg = 255; 
      decode = 0x00;
  }

  if (decode & 0xff) {
    uint8_t dp = temp_seg & 0x80;
    temp_seg = decode_digits[temp_seg & 0x0f];
    if (dp) {
      temp_seg = temp_seg | 0x01;
    }
  }
  for (int i = 0; i < 8; i++) {
    uint8_t *seg = segments[i];
    if (temp_seg & 0x01) {
      for (int j = 0; j < 11; j++) {
          s[j] = s[j] | seg[j];
      }
    }
    temp_seg = temp_seg >> 1;
  }
  print_digit(chip, digit, s, color);
}

void update_display(chip_state_t *chip) {

  display_color.a = (chip->intensity << 4) | 0x0f;

  if (chip->shutdown_mode == 0x00) {
    //  Turn off display
    for (int i = 0; i < 8; i++) {
      set_segment(chip, 0b00000000, i, display_color, 1);
    }
  }
  else {
    for (int i = 0; i < 8; i++) {
      if (i <= chip->scan_limit) {
        set_segment(chip, chip->digits[i], i, display_color, 0);
      }
      else {
        set_segment(chip, 0x00, i, display_color, 1);
      }
    }
  }
}

static void chip_pin_change(void *user_data, pin_t pin, uint32_t value);
static void chip_spi_done(void *user_data, uint8_t *buffer, uint32_t count);

/*
Initializes the chip
*/
void chip_init(void) {
  chip_state_t *chip = malloc(sizeof(chip_state_t));

  uint32_t led_color_handle = attr_init("led-color", 0xff0000ff); // Default to red
  uint32_t color = attr_read(led_color_handle);
  display_color.r = (color >> 24) & 0xff; // Red value
  display_color.g = (color >> 16) & 0xff; // Green value
  display_color.b = (color >>  8) & 0xff; // Blue value
  display_color.a = 0xff;                 // Full alpha

  // Initialize load and data out chip pins
  chip->pin_load = pin_init("LOAD"  , INPUT);
  chip->pin_dout = pin_init("DOUT"  , OUTPUT);

  // Setup watch for the load pin
  const pin_watch_config_t config = {
    .edge = BOTH,
    .pin_change = chip_pin_change,
    .user_data = chip,
  };
  pin_watch(chip->pin_load, &config);

  // Initialize the SPI interface
  const spi_config_t spi_config = {
    .sck = pin_init("CLK", INPUT),
    .miso = NO_PIN,
    .mosi = pin_init("DIN", INPUT),
    .done = chip_spi_done,
    .user_data = chip,
  };
  chip->spi = spi_init(&spi_config);

  // Set up other variables
  chip->decode_mode = 0xff;   // On
  chip->scan_limit = 0x07;    // All segments
  chip->intensity = 0x0f;     // Max
  chip->display_test = 0x00;  // Off
  chip->shutdown_mode = 0x01; // Normal Operation

  chip->digits[0] = chip->digits[1] = chip->digits[2] = chip->digits[3] =
  chip->digits[4] = chip->digits[5] = chip->digits[6] = chip->digits[7] = 0x0f;

  chip->row = 0;
  chip->framebuffer = framebuffer_init(&chip->width, &chip->height);
  printf("Framebuffer: width=%d, height=%d\n", chip->width, chip->height);

  for (int i = 0; i < 8; i++) {
    set_segment(chip, 0b00000000, i, display_color, 1);
  }
}

/*
Check for the change of the load pin, and turns on and off the SPI data
*/
static void chip_pin_change(void *user_data, pin_t pin, uint32_t value) {
  chip_state_t *chip = (chip_state_t*)user_data;

  // Handle the load pin
  if (pin == chip->pin_load) {
    if (value == LOW) {
      //printf("SPI chip selected\n");
      chip->spi_buffer[0] = 0x00;
      chip->spi_buffer[1] = 0x00;
      spi_start(chip->spi, chip->spi_buffer, sizeof(chip->spi_buffer));
    } else {
      //printf("SPI chip deselected\n");
      spi_stop(chip->spi);
    }
  }
}

/*
Process the command in the registry
*/
static void chip_spi_done(void *user_data, uint8_t *buffer, uint32_t count) {
  chip_state_t *chip = (chip_state_t*)user_data;

  // If count is not 2, incomplete data
  if (count < 2) {
    return;
  }

  //printf("Buffer Count: %d\n", count);
  //printf("%x %x\n", buffer[0],buffer[1]);

  // Get the address and data bytes
  uint16_t addr = buffer[0];
  uint16_t data = buffer[1];
  
  printf("addr: %d - data: %d\n", addr, data);
  uint8_t a;
  
  // Process the command, from the register
  switch(addr & 0b00001111) {
    case 0x00: // No-Op
      break;

    case 0x01: // Digit 0
    case 0x02: // Digit 1
    case 0x03: // Digit 2
    case 0x04: // Digit 3
    case 0x05: // Digit 4
    case 0x06: // Digit 5
    case 0x07: // Digit 6
    case 0x08: // Digit 7
      chip->digits[(addr & 0b00001111) - 1] = data;
      //set_segment(chip, data, (addr & 0b00001111) - 1, red, 1);
      break;

    case 0x09: // Dedode Mode
      chip->decode_mode = data & 0xff;
      break;

    case 0x0a: // Intensity
      chip->intensity = (data & 0x0f);
      break;

    case 0x0b: // Scan Limit
      chip->scan_limit = data & 0x0f;
      break;

    case 0x0c: // Shutdown
      chip->shutdown_mode = data &0x01;
      break;

    case 0x0f: // Display Test
      chip->display_test = data &0x01;
      break;
  };

  update_display(chip);

  // Get ready to read again
  if (pin_read(chip->pin_load) == LOW) {
    spi_start(chip->spi, chip->spi_buffer, sizeof(chip->spi_buffer));
  }
}


max7219-7-seg.chip.c

MAX7219 7 Segment

max7219-7-seg.chip.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

# Automatically added based on includes:
LiquidCrystal

LedControl
