#define DIN 8
#define CLK 9
#define LOAD 10

void load_data(uint16_t address, uint16_t data) {
  uint16_t data_register = (address << 8) | data;
  digitalWrite(LOAD, LOW);
  //delay(1);
  for (int r = 0; r < 16; r++) {
    if (data_register & 0x01) {
      digitalWrite(DIN, HIGH);
    }
    else {
      digitalWrite(DIN, LOW);
    }
    data_register = data_register >> 1;
    //delay(1);
    digitalWrite(CLK, HIGH);
    //delay(1);
    digitalWrite(CLK, LOW);
  }
  //delay(2);
  digitalWrite(LOAD, HIGH);
}



void setup() {
  pinMode(DIN,  OUTPUT); // DIN
  pinMode(CLK,  OUTPUT); // CLK
  pinMode(LOAD, OUTPUT); // LOAD
  digitalWrite(LOAD, HIGH);
  digitalWrite(CLK, LOW);
}

void loop() {
  load_data(0b00001001,0b11111111);
  load_data(0b00000001,0);
  load_data(0b00000010,8);
  load_data(0b00000011,9);
  load_data(0b00000100,10);
  load_data(0b00000101,11);
  load_data(0b00000110,12);
  load_data(0b00000111,13);
  load_data(0b00001000,14);

  delay(1000);

  load_data(0b00001001,0x00);
  load_data(0b00000001,0b11111111);
  load_data(0b00000010,0b11111111);
  load_data(0b00000011,0b11111111);
  load_data(0b00000100,0b11111111);
  load_data(0b00000101,0b11111111);
  load_data(0b00000110,0b11111111);
  load_data(0b00000111,0b11111111);
  load_data(0b00001000,0b11111111);

  load_data(0b00001010,0x0f); // Intensity
  delay(1000);
  load_data(0b00001011,4);
  delay(1000);
  load_data(0b00001011,7);
  delay(1000);
}


MAX7219.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>

const int MS = 1000; // micros

uint8_t segments[][11] = {
  {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
  {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}  // DP
};

uint8_t decode_digits[] = {
  0b01111110, // 0
  0b00110000, // 1
  0b01101101, // 2
  0b01111001, // 3
  0b00110011, // 4
  0b01011011, // 5
  0b01011111, // 6
  0b01110000, // 7
  0b01111111, // 8
  0b01111011, // 9
  0b00000001, // -
  0b01001111, // E
  0b00110111, // H
  0b00001110, // L
  0b01100111, // P
  0b00000000, // Blank
};

uint8_t digits[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

typedef struct {
  uint8_t r;
  uint8_t g;
  uint8_t b;
  uint8_t a;
} rgba_t;

typedef struct {
  buffer_t framebuffer;
  uint32_t width;
  uint32_t height;
  uint32_t row;
  pin_t pin_din;
  pin_t pin_clk;
  pin_t pin_load;
  pin_t pin_dout;
} chip_state_t;

uint16_t data_register = 0b0000000000000000;

static void chip_timer_event(void *user_data);

rgba_t black = { .r = 0x00, .g=0x00, .b=0x00, .a=0x00 };
rgba_t purple = { .r = 0xff, .g=0x00, .b=0xff, .a=0xff };
rgba_t red = { .r = 0xff, .g=0x00, .b=0x00, .a=0xff };

rgba_t display_color = { .r = 0xff, .g=0x00, .b=0x00, .a=0xff };

uint16_t decode_mode = 0x00;
uint8_t scan_limit = 0x07;


#define UINT16_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c"
#define UINT16_TO_BINARY(uint16)  \
  (uint16 & 0x8000 ? '1' : '0'), \
  (uint16 & 0x4000 ? '1' : '0'), \
  (uint16 & 0x2000 ? '1' : '0'), \
  (uint16 & 0x1000 ? '1' : '0'), \
  (uint16 & 0x0800 ? '1' : '0'), \
  (uint16 & 0x0400 ? '1' : '0'), \
  (uint16 & 0x0200 ? '1' : '0'), \
  (uint16 & 0x0100 ? '1' : '0'), \
  (uint16 & 0x0080 ? '1' : '0'), \
  (uint16 & 0x0040 ? '1' : '0'), \
  (uint16 & 0x0020 ? '1' : '0'), \
  (uint16 & 0x0010 ? '1' : '0'), \
  (uint16 & 0x0008 ? '1' : '0'), \
  (uint16 & 0x0004 ? '1' : '0'), \
  (uint16 & 0x0002 ? '1' : '0'), \
  (uint16 & 0x0001 ? '1' : '0') 

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 = 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 > scan_limit && !do_segments) {
    return;
  }
 //int x_offset = digit * 35;
  uint8_t temp_seg = segment;
  if (!do_segments) {
    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 = decode_mode >> digit;
  if (do_segments) decode = 0x00;

  if (decode & 0xff) {
    temp_seg = decode_digits[temp_seg];
  }
  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);
}


static void chip_pin_change(void *user_data, pin_t pin, uint32_t value) {
  chip_state_t *chip = (chip_state_t*)user_data;

  int clk = pin_read(chip->pin_clk);
  int din = pin_read(chip->pin_din);
  int load = pin_read(chip->pin_load);

  printf("CLK: %s DIN: %s LOAD: %s\n", 
    clk?"HIGH":"LOW", 
    din?"HIGH":"LOW", 
    load?"HIGH":"LOW"
  );

  if (pin == chip->pin_clk && clk == HIGH && load == LOW) {
    if (data_register & 0x0001) {
      pin_write(chip->pin_dout, HIGH);
    }
    else {
      pin_write(chip->pin_dout, LOW);
    }
    data_register = data_register >> 1;
    if (din == HIGH) data_register = data_register | 0x8000;
    printf("Shift %c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n", UINT16_TO_BINARY(data_register));
  }

  if (pin == chip->pin_load && clk == LOW && load == HIGH) {
    uint16_t addr = (data_register & 0b0000111100000000) >> 8;
    uint16_t data = (data_register & 0b0000000011111111);
    printf("addr: %d - data: %d\n", addr, data);
    uint8_t a;
    
    switch(addr & 0b00001111) {
      case 0x00: // No-Op
        break;
      case 0x01: // Digit 0
        set_segment(chip, data, 0, display_color, 0);
        break;
      case 0x02: // Digit 1
        set_segment(chip, data, 1, display_color, 0);
        break;
      case 0x03: // Digit 2
        set_segment(chip, data, 2, display_color, 0);
        break;
      case 0x04: // Digit 3
        set_segment(chip, data, 3, display_color, 0);
        break;
      case 0x05: // Digit 4
        set_segment(chip, data, 4, display_color, 0);
        break;
      case 0x06: // Digit 5
        set_segment(chip, data, 5, display_color, 0);
        break;
      case 0x07: // Digit 6
        set_segment(chip, data, 6, display_color, 0);
        break;
      case 0x08: // Digit 7
        set_segment(chip, data, 7, display_color, 0);
        break;
      case 0x09: // Dedode Mode
        decode_mode = data & 0xff;
        break;
      case 0x0a: // Intensity
        a = ((data & 0x0f) << 4) | 0x0f;
        display_color.a = a;
        for (int i = 0; i < 8; i++) {
          set_segment(chip, digits[i], i, display_color,0);
        }
        break;
      case 0x0b: // Scan Limit
        scan_limit = data & 0x0f;
        for (int i = 0; i < 8; i++) {
          if (i <= scan_limit) {
            set_segment(chip, digits[i], i, display_color, 0);
          }
          else {
            set_segment(chip, 0b00000000, i, display_color,1);
          }
        }

        break;
      case 0x0c: // Shutdown
        switch(data & 0x01) {
          case 0x00: // Shutdown Mode
            break;
          case 0x01: // Normal Operation
            break;
        }
        break;
      case 0x0f: // Display Test
        switch(data & 0x01) {
          case 0x00: // Normal Operation
            break;
          case 0x01: // Display Test Mode
            break;
        }
        break;
    };
  } 
}

void chip_init(void) {
  chip_state_t *chip = malloc(sizeof(chip_state_t));

  chip->pin_din = pin_init("DIN", INPUT);
  chip->pin_clk = pin_init("CLK", INPUT);
  chip->pin_load = pin_init("LOAD", INPUT);
  chip->pin_dout = pin_init("DOUT", OUTPUT);

  chip->row = 0;
  chip->framebuffer = framebuffer_init(&chip->width, &chip->height);
  printf("Framebuffer: width=%d, height=%d\n", chip->width, chip->height);

  /*const timer_config_t timer_config = {
    .callback = chip_timer_event,
    .user_data = chip,
  };
  timer_t timer = timer_init(&timer_config);
  timer_start(timer, 10 * MS, true);
*/
  rgba_t color = red;
  uint8_t s[11] = {0,0,0,0,0,0,0,0,0,0,0};
  for (int i = 0; i < 8; i++) {
    print_digit(chip, i, s, color);
  }

  /*
  set_segment(chip, 1, 0, color);
  set_segment(chip, 2 + 1, 1, color);
  set_segment(chip, 4 + 2 + 1, 2, color);
  set_segment(chip, 8 + 4 + 2 + 1, 3, color);
  set_segment(chip, 16 + 8 + 4 + 2 + 1, 4, color);
  set_segment(chip, 32 + 16 + 8 + 4 + 2 + 1, 5, color);
  set_segment(chip, 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1, 6, color);
  set_segment(chip, 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1, 7, color);
  */

  const pin_watch_config_t config = {
    .edge = BOTH,
    .pin_change = chip_pin_change,
    .user_data = chip,
  };

  //pin_watch(chip->pin_din, &config);
  pin_watch(chip->pin_clk, &config);
  pin_watch(chip->pin_load, &config);
}

//void chip_timer_event(void *user_data) {
//  chip_state_t *chip = (chip_state_t*)user_data;
//  rgba_t deep_green = { .g=0x30, .a = 0xff };
//  draw_line(chip, chip->row, deep_green);
//
//  chip->row = (chip->row + 1) % chip->height;
//  rgba_t purple = { .r = 0xff, .g=0x00, .b=0xff, .a=0xff };
//  draw_line(chip, chip->row, purple);
//}
