uint8_t *data[] = {9,8,7,6,5,4,3,2}; // Data pins
uint8_t pin_e   = 10;                // Enable pin
uint8_t pin_rw  = 11;                // Read/write pin
uint8_t pin_rs  = 12;                // Command select pin

char *message = "Hello world!";

#define RS 0x01 // Command select
#define RW 0X02 // Read/write
#define E 0X04  // Enable

/*
Set the control pins
*/
void set_control(uint8_t ctrl) {
  digitalWrite(pin_rs, (ctrl & RS)?HIGH:LOW);
  digitalWrite(pin_rw, (ctrl & RW)?HIGH:LOW);
  digitalWrite(pin_e, (ctrl & E)?HIGH:LOW);
}

/*
Set the data buss
*/
void set_data(uint8_t data_bits) {
  for (int i = 0; i < 8; i++) {
    digitalWrite(data[i], data_bits & 0x01);
    data_bits = data_bits >> 1;
  }
}

/*
Set data buss to output
*/
void set_data_output() {
  for (int i = 0; i < 8; i++) {
    pinMode(data[i], OUTPUT);
  }
}

/*
Set the data buss to input
*/
void set_data_input() {
  for (int i = 0; i < 8; i++) {
    pinMode(data[i], INPUT);
  }
}

/*
Wait for lcd to be ready
*/
void lcd_wait() {
lcd_wait:
  set_data_input();

  do {
  set_control(RW);
  set_control(RW|E);
  } while (digitalRead(data[7]) == HIGH);
  
  set_control(RW);
  set_data_output();
}

/*
Send and instruction
*/
void lcd_instruction(uint8_t inst) {
  lcd_wait();
  set_data(inst);
  set_control(9);  // Clear RS/RW/E bits
  set_control(E);  // Set E bit to send instruction
  set_control(9);  // Clear RS/RW/E bits
}

/*
Send a character
*/
void print_char(uint8_t chr) {
print_char:
  lcd_wait();
  set_data(chr);
  set_control(RS);   // Set RS; Clear RW/E bits
  set_control(RS|E); // Set E bit to send 
  set_control(RS);   // Clear E bits
}

/*
Start the program
*/
void start() {

  lcd_instruction(0b00111000); // Set 8-bit mode; 2-line display; 5x8 font
  lcd_instruction(0b00001110); // Display on; cursor on; blink off
  lcd_instruction(0b00000110); // Increment and shift cursor; don't shift display
  lcd_instruction(0b00000001); // Clear display

  // Send message
  char *msg_ptr = message;
  while (*msg_ptr != 0) {
    print_char(*msg_ptr);
    msg_ptr++;
  }
}

void setup() {
  set_data_output(); // Set the data buss to output
  pinMode(pin_e, OUTPUT);  // Set enable to output
  pinMode(pin_rw, OUTPUT); // Set read/write to output
  pinMode(pin_rs, OUTPUT); // Set command select to output

  start();
}

void loop() {
  delay(10);
}


sketch.ino

diagram.json

6502.chip.c

6502

6502.chip.json

// 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>

// Interval to call the timer in microseconds
const int INTERVAL = 50;

// Chip state
typedef struct {
  pin_t clk;
  int8_t state;
} chip_state_t;

static void chip_pin_change(void *user_data, pin_t pin, uint32_t value);
static void chip_timer_event(void *user_data);

/*
Initializes the chip
*/
void chip_init(void) {
  chip_state_t *chip = malloc(sizeof(chip_state_t));

  // Clock output pin
  chip->clk = pin_init("CLK" , OUTPUT);

  // Start with high
  chip->state = HIGH;

  // Setup timer
  const timer_config_t timer_config = {
    .callback = chip_timer_event,
    .user_data = chip,
  };

  timer_t timer = timer_init(&timer_config);
  timer_start(timer, INTERVAL, true);

}


/*
On every call of the timer, the state is toggled
*/
static void chip_timer_event(void *user_data) {
  chip_state_t *chip = (chip_state_t*)user_data;
  chip->state = (chip->state == HIGH)?LOW:HIGH;
  pin_write(chip->clk, chip->state);  
}


clock.chip.c

{
  "name": "Clock",
  "author": "Sean Johnston",
  "pins": [
"CLK",
"",
"VCC",
"GND"
]
}

clock.chip.json

// 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>

//#include<sys/types.h>
#include<sys/stat.h>
#include <fcntl.h>  

// Chip state
typedef struct {
  pin_t pin_a[11]; // Address pins
  pin_t pin_d[8];  // Data pins
  pin_t pin_cs;    // Chip select
  pin_t pin_oe;    // Output Enable
  pin_t pin_we;    // Write enable
  uint8_t buffer[2096]; // Buffer to contain eprom data (2K)
} chip_state_t;

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);
static void chip_timer_event(void *user_data);

/*
Initializes the chip
*/
void chip_init(void) {
  chip_state_t *chip = malloc(sizeof(chip_state_t));

  char pin_name[10];

  // Initialize address pins
  for (int i = 0; i < 11; i++) {
    sprintf(pin_name, "A%d", i);
    chip->pin_a[i] = pin_init(pin_name, INPUT);
  }

  // Initialize data pins
  for (int i = 0; i < 8; i++) {
    sprintf(pin_name, "D%d", i);
    chip->pin_d[i] = pin_init(pin_name, INPUT);
    //pin_write(chip->pin_d[i],HIGH);    
  }

  // Initialize chip select
  chip->pin_cs  = pin_init("CS-"  , INPUT);
  chip->pin_oe  = pin_init("OE-"  , INPUT);
  chip->pin_we  = pin_init("WE-"  , INPUT);

  // Setup watch the chip select
  const pin_watch_config_t config = {
    .edge = BOTH,
    .pin_change = chip_pin_change,
    .user_data = chip,
  };

  // Watch for the chip select, output enable and
  // write enable
  pin_watch(chip->pin_cs, &config);
  pin_watch(chip->pin_oe, &config);
  pin_watch(chip->pin_we, &config);

  // Watch for the address pins
  for (int i = 0; i < 11; i++) {
    pin_watch(chip->pin_a[i], &config);
  }
}

/*
Read the address pins, and return the address
*/
uint16_t get_address(chip_state_t *chip) {
    uint16_t address = 0;
    for (int i = 0; i < 11; i++) {
      if (pin_read(chip->pin_a[i]) == HIGH) {
        address = (address >> 1) | 0b0000010000000000;
      }
      else {
        address = (address >> 1);
      }
    }
  return address;
}

/*
Check for the change of the chip select pin
*/
static void chip_pin_change(void *user_data, pin_t pin, uint32_t value) {
  chip_state_t *chip = (chip_state_t*)user_data;
  char pin_name[10];

  // If chip select goes low, read or write the chip
  if (pin_read(chip->pin_cs) == LOW) {

    // If output enable is low and write enable is high, read the chip
    if (pin_read(chip->pin_oe) == LOW && pin_read(chip->pin_we) == HIGH) {

      for (int i = 0; i < 8; i++) {
        pin_mode(chip->pin_d[i], INPUT);
      }

      // Get the address
      uint16_t address = get_address(chip);

      // Set the pin mode to output for data lines
      for (int i = 0; i < 8; i++) {
        pin_mode(chip->pin_d[i], OUTPUT);
      }

      // Get the data value from the buffer, and output it
      uint8_t byte = chip->buffer[address];

      //printf("Get address: 0x%04x byte: 0x%02x\n", address, byte);

      // Set the data lines
      for (int i = 0; i < 8; i++) {
        pin_write(chip->pin_d[i],byte & 0X01?HIGH:LOW);
        byte = byte >> 1;
      }
    }

    // If output enable is high, and write enable is low, write tothe chip
    if (pin_read(chip->pin_oe) == HIGH && pin_read(chip->pin_we) == LOW) {

      // Set the pin mode to input for data lines
      for (int i = 0; i < 8; i++) {
        pin_mode(chip->pin_d[i], INPUT);
      }

      // Get the address
      uint16_t address = get_address(chip);

      // Get the data from the data pins and store it in the buffer
      uint8_t byte = 0;
      for (int i = 0; i < 8; i++) {
        if (pin_read(chip->pin_d[i]) == HIGH) {
          byte = (byte >> 1) | 0x80;
        }
        else {
          byte = (byte >> 1);
        }
      }
      //printf("Set address: 0x%04x byte: 0x%02x\n", address, byte);

      chip->buffer[address] = byte;
    }
  } 
  else {
    // If chip is not selected, put it in high impredents mode
    // Note: We need to put the chip in high impedence mode,
    // so that it doesn't interfer with the data lines of other
    // chips. There no pin mode for this, but it seems that we
    // can put it in imput mode, and it accomplishes the same
    // thing.
    for (int i = 0; i < 8; i++) {
      pin_mode(chip->pin_d[i], INPUT);
    }
  }
}



6116.chip.c

6116 2K RAM

6116.chip.json

// 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>

//#include<sys/types.h>
#include<sys/stat.h>
#include <fcntl.h>  

// Chip state
typedef struct {
  pin_t pin_a[11]; // Address pins
  pin_t pin_q[8];  // Data pins
  pin_t pin_g;    // Chip select
  uint8_t buffer[2096]; // Buffer to contain eprom data (2K)
} chip_state_t;

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);
static void chip_timer_event(void *user_data);

/*
Translate the string nibble to a value
*/
int translate_char(char nibble) {
  // Deal with the number
  if (nibble >= '0' && nibble <= '9') {
    return nibble - '0';
  }
  // Deel with uppercase hex
  else if (nibble >= 'A' && nibble <= 'F') {
    return nibble - 'A' + 10;
  }
  // Deal with lowercase hex
  else if (nibble >= 'a' && nibble <= 'f') {
      return nibble - 'a' + 10;
  }
  // Could not tranlate, make 0
  return -1;
}

/*
Get the next valid character from the line, and 
and tranlate it to a nibble. This function takes the
line pointer, and returns the moved line pointer.
*/
char *get_nibbles(int *nibble, char *line_ptr) {
  // Find the next valid character, in the line, or exit;
  while (*line_ptr != 0 && (*nibble = translate_char(*line_ptr)) == -1) {
    line_ptr++;
  }

  // If we didn't get a file character, exit with a zero
  if (*line_ptr == 0) {
    *nibble = 0; 
  }
  // Move to the next character
  else {
    line_ptr++;
  }
  return line_ptr;
}

/*
Reads the data for the chip
*/
void read_chip_data(chip_state_t *chip) {

  // Allocate the buffer for initial size
  long buffer_size = 129;
  char *buffer = malloc(buffer_size);

  int cnt = 0;       // Data line that we are processing
  int bytes = 0;     // Number of bytes processed
  char data_key[20]; // Key of the data line

  int done = 0;
  while (!done) {

    // Get the string data handle
    sprintf(data_key,"data_%03x", cnt);
    string_t handle = attr_string_init(data_key);
    if (handle == 0) {
      // The we do not have any more data
      done = 1;
    }
    else {
      // Get the length of the data
      uint32_t len = string_get_length(handle);

      // Resize the buffer, if it is too small
      if (buffer_size < len + 1) {
        free(buffer);
        buffer_size = len + 1;
        buffer = malloc(buffer_size);
      }

      // Read the string into the buffer
      string_read(handle, buffer, buffer_size);

      uint8_t byte;
      int high_nibble;
      int low_nibble;
      
      // Translate the line, and store the bytes in the 
      // chip buffer
      char *line_ptr = buffer;
      while(bytes < sizeof(chip->buffer) && *line_ptr != 0) {
        line_ptr = get_nibbles(&high_nibble, line_ptr);
        line_ptr = get_nibbles(&low_nibble, line_ptr);
        byte = (high_nibble << 4) + low_nibble;
        chip->buffer[bytes] = byte;
        bytes++;
      }

      // If we have exceeded the chip buffer, stop
      if (bytes >= sizeof(chip->buffer)) {
        done = 1;
      }

      // Next data line
      cnt++;
    }
    // Free the string data buffer
    free(buffer);
  }

  // Fill up the rest of the buffer with zeros
  while(bytes < sizeof(buffer)) {
    chip->buffer[bytes] = 0;
  }

  printf("Bytes: %d\n", bytes);
}

/*
Initializes the chip
*/
void chip_init(void) {
  chip_state_t *chip = malloc(sizeof(chip_state_t));

  // Read the chip data into the chip buffer
  read_chip_data(chip);

  char pin_name[10];

  // Initialize address pins
  for (int i = 0; i < 11; i++) {
    sprintf(pin_name, "A%d", i);
    chip->pin_a[i] = pin_init(pin_name, INPUT);
  }

  // Initialize data pins
  for (int i = 0; i < 8; i++) {
    sprintf(pin_name, "Q%d", i);
    chip->pin_q[i] = pin_init(pin_name, INPUT);
    //pin_write(chip->pin_q[i],HIGH);    
  }

  // Initialize chip select
  chip->pin_g  = pin_init("G-"  , INPUT);

  // Setup watch the chip select
  const pin_watch_config_t config = {
    .edge = BOTH,
    .pin_change = chip_pin_change,
    .user_data = chip,
  };
  pin_watch(chip->pin_g, &config);
  for (int i = 0; i < 11; i++) {
    pin_watch(chip->pin_a[i], &config);
  }
}

/*
Check for the change of the chip select pin
*/
static void chip_pin_change(void *user_data, pin_t pin, uint32_t value) {
  chip_state_t *chip = (chip_state_t*)user_data;
  char pin_name[10];

  if (pin_read(chip->pin_g) == LOW) {
    // If chip select goes low, get the addess
    uint16_t address = 0;
    for (int i = 0; i < 11; i++) {
      if (pin_read(chip->pin_a[i]) == HIGH) {
        address = (address >> 1) | 0b0000010000000000;
      }
      else {
        address = (address >> 1);
      }
    }


    // Get the data value from the buffer, and output it
    uint8_t byte = chip->buffer[address];
    //printf("Get Memory: 0x%04x - 0x%02x\n", address, byte);

    for (int i = 0; i < 8; i++) {
      sprintf(pin_name, "Q%d", i);
      pin_mode(chip->pin_q[i], OUTPUT);
    }

    for (int i = 0; i < 8; i++) {
      pin_write(chip->pin_q[i],byte & 0X01?HIGH:LOW);
      byte = byte >> 1;
    }
  } else {

    // If chip is not selected, put it in high impredents mode
    // Note: We need to put the chip in high impedence mode,
    // so that it doesn't interfer with the data lines of other
    // chips. There no pin mode for this, but it seems that we
    // can put it in imput mode, and it accomplishes the same
    // thing.
    for (int i = 0; i < 8; i++) {
      //sprintf(pin_name, "Q%d", i);
      pin_mode(chip->pin_q[i], INPUT);
      //pin_write(chip->pin_q[i],HIGH);    
    }
  }
}



2716.chip.c

2716 2K EPROM

2716.chip.json

// 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

// Chip state
typedef struct {
  pin_t pins_a[7];  // Address pins
  pin_t pins_db[8]; // Data pins
  pin_t pins_pa[8]; // Parallel port a
  pin_t pins_pb[8]; // Parallel port b
  pin_t pin_res;    // Reset pin
  pin_t pin_rw;     // Read/Write pin
  pin_t pin_rs;     // RAM select
  pin_t pin_cs1;    // Chip select 1
  pin_t pin_cs2;    // Chip select 2
  pin_t pin_irq;    // Interupt request
  pin_t pin_phi2;   // Clock

  uint8_t pa;       // Parallel port a register
  uint8_t ddra;     // Parallel port a direction
  uint8_t pb;       // Parallel port b register
  uint8_t ddrb;     // Parallel port b direction
} chip_state_t;

static void chip_pin_change(void *user_data, pin_t pin, uint32_t value);
static void chip_timer_event(void *user_data);

/*
Set the parallel port a registor
*/
void set_pa(chip_state_t *chip, uint8_t byte) {
    chip->pa = byte;
    uint8_t byte2 = chip->ddra;
     
    for (int i = 0; i < 8; i++) {
      if (byte2 & 0x01) {
        pin_write(chip->pins_pa[i], byte & 0x01?HIGH:LOW);
      }
      byte = byte >> 1;
      byte2 = byte2 >> 1;
    }
}

/*
Get the parallel port a register
*/
uint8_t get_pa(chip_state_t *chip) {
    uint8_t byte = 0;
    uint8_t byte2 = chip->ddra;
     
    for (int i = 0; i < 8; i++) {
      byte = byte >> 1;
      if ((byte2 & 0x01) == 0x00) {
        byte |= (pin_read(chip->pins_pa[i])?0x80:0x00);
        //printf("INPUT 0x%02x %i\n", byte, pin_read(chip->pins_pa[i]));
      }
      else {
        //printf("OUTPUT 0x%02x\n", byte);
      }
      byte2 = byte2 >> 1;
    }
    return byte;
}

/*
Set the parallel port b registor
*/
void set_pb(chip_state_t *chip, uint8_t byte) {
    chip->pb = byte;
    uint8_t byte2 = chip->ddrb;
     
    for (int i = 0; i < 8; i++) {
      if (byte2 & 0x01) {
        pin_write(chip->pins_pb[i], byte & 0x01?HIGH:LOW);
      }
      byte = byte >> 1;
      byte2 = byte2 >> 1;
    }
}

/*
Get the parallel port b register
*/
uint8_t get_pb(chip_state_t *chip) {
    uint8_t byte = 0;
    uint8_t byte2 = chip->ddrb;
     
    for (int i = 0; i < 8; i++) {
      byte = byte >> 1;
      if (byte2 & 0x01) {
        byte |= (pin_read(chip->pins_pb[i])?0x80:0x00);
      }
      byte2 = byte2 >> 1;
    }
    return byte;
}

/*
Set parallel port a direction
*/
void set_pa_dir(chip_state_t *chip, uint8_t byte) {
    chip->ddra = byte;
    for (int i = 0; i < 8; i++) {
      pin_mode(chip->pins_pa[i], byte & 0x01?OUTPUT:INPUT);
      byte = byte >> 1;
    }
    set_pa(chip, chip->pa);
}

/*
Set parallel port b direction
*/
void set_pb_dir(chip_state_t *chip, uint8_t byte) {
    for (int i = 0; i < 8; i++) {
      pin_mode(chip->pins_pb[i], byte & 0x01?OUTPUT:INPUT);
    }
    chip->ddrb = byte;
    set_pb(chip, chip->pb);
}


/*
Initializes the chip
*/
void chip_init(void) {
  chip_state_t *chip = malloc(sizeof(chip_state_t));

  char pin_name[10];

  // Initialize address pins
  for (int i = 0; i < 7; i++) {
    sprintf(pin_name, "A%d", i);
    chip->pins_a[i] = pin_init(pin_name, INPUT);
  }

  // Initialize data pins
  for (int i = 0; i < 8; i++) {
    sprintf(pin_name, "DB%d", i);
    chip->pins_db[i] = pin_init(pin_name, INPUT);
  }

  // Initialize other chip pins
  chip->pin_res  = pin_init("RES-"  , INPUT);
  chip->pin_rw  = pin_init("RW"     , INPUT);
  chip->pin_rs  = pin_init("RS-"    , INPUT);
  chip->pin_cs1  = pin_init("CS1"   , INPUT);
  chip->pin_cs2  = pin_init("CS2-"  , INPUT);
  chip->pin_irq  = pin_init("IRQ-" , OUTPUT_HIGH);
  chip->pin_phi2  = pin_init("PHI2" , INPUT);

  // Initialize parallel port a pins
  for (int i = 0; i < 8; i++) {
    sprintf(pin_name, "PA%d", i);
    chip->pins_pa[i] = pin_init(pin_name, OUTPUT);
  }

  // Initialize parallel port b pins
  for (int i = 0; i < 8; i++) {
    sprintf(pin_name, "PB%d", i);
    chip->pins_pb[i] = pin_init(pin_name, OUTPUT);
  }

  // Set parallel port a direction to output, and off
  set_pa_dir(chip, 0xff);
  set_pa(chip, 0x00);

  // Set parallel port b direction to output, and off
  set_pb_dir(chip, 0xff);
  set_pb(chip, 0x00);

  // Setup watch the chip select
  const pin_watch_config_t config = {
    .edge = BOTH,
    .pin_change = chip_pin_change,
    .user_data = chip,
  };

  // Watch contol pins
  pin_watch(chip->pin_res, &config);
  pin_watch(chip->pin_rw, &config);
  pin_watch(chip->pin_rs, &config);
  pin_watch(chip->pin_cs1, &config);
  pin_watch(chip->pin_cs2, &config);
  pin_watch(chip->pin_phi2, &config);
}

/*
Check for the change of the chip select and clock
*/
static void chip_pin_change(void *user_data, pin_t pin, uint32_t value) {
  chip_state_t *chip = (chip_state_t*)user_data;

  // If chip select is low and clock is low  
  if (pin_read(chip->pin_cs2) == LOW && pin_read(chip->pin_phi2) == LOW) {

    // Read the address
    uint16_t address = 0;
    for (int i = 0; i < 8; i++) {
      if (pin_read(chip->pins_a[i]) == HIGH) {
        address = (address >> 1) | 0x80;
      }
      else {
        address = (address >> 1);
      }
    }

    // Only care about the first 15 address location
    address = address & 0x0f;

    // If read/write pin is low, read the data buss
    if (pin_read(chip->pin_rw) == LOW) {
      uint8_t byte = 0;
      for (int i = 0; i < 8; i++) {
        uint8_t bit = pin_read(chip->pins_db[i]);
        if (bit == HIGH) {
          byte = (byte >> 1) | 0x80;
        }
        else {
          byte = byte >> 1;
        }
      }

      //printf("Set address: 0x%04x byte: 0x%02x\n", address, byte);

      if (pin_read(chip->pin_rs == LOW)) {
        //printf("RIOT RAM\n");
      }
      else {
        //printf("RIOT IO\n");
        switch(address) {
          case 0x00:
            set_pa(chip, byte);
            break;
          case 0x01:
            set_pa_dir(chip, byte);
            break;
          case 0x02:
            set_pb(chip, byte);
            break;
          case 0x03:
            set_pb_dir(chip, byte);
            break;
        }
      }

    }

    // If read/write line is high, set the data buss
    if (pin_read(chip->pin_rw) == HIGH) {

      uint8_t byte = 0x00;
      if (pin_read(chip->pin_rs == LOW)) {
        //printf("RIOT RAM\n");
      }
      else {
        //printf("RIOT IO\n");
        switch(address) {
          case 0x00:
            byte = get_pa(chip);
            break;
          case 0x01:
            byte = chip->ddra;
            break;
          case 0x02:
            byte = get_pb(chip);
            break;
          case 0x03:
            byte = chip->ddrb;
            break;
        };

        //printf("Get address: 0x%04x byte: 0x%02x\n", address, byte);

        for (int i = 0; i < 8; i++) {
          pin_mode(chip->pins_db[i], OUTPUT);
        }

        for (int i = 0; i < 8; i++) {
          pin_write(chip->pins_db[i], byte & 0x01?HIGH:LOW);
          byte = byte >> 1;
        }
      }
    }
  }
  else {
    // If chip is not selected, set the data buss to 
    // high impedance state
    for (int i = 0; i < 8; i++) {
      pin_mode(chip->pins_db[i], INPUT);
    }
  }
}

/*
Will evenually be used for the timers.
*/
static void chip_timer_event(void *user_data) {
  chip_state_t *chip = (chip_state_t*)user_data;
}


6532-RIOT.chip.c

6532 RIOT

6532-RIOT.chip.json

// For information and examples see:
// https://docs.wokwi.com/chips-api/getting-started

// 74HC138/74HC238

#include "wokwi-api.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
  pin_t pin_e1;
  pin_t pin_e2;
  pin_t pin_e3;
  
  pin_t pin_a0;
  pin_t pin_a1;
  pin_t pin_a2;

  pin_t pin_y0;
  pin_t pin_y1;
  pin_t pin_y2;
  pin_t pin_y3;
  pin_t pin_y4;
  pin_t pin_y5;
  pin_t pin_y6;
  pin_t pin_y7;

  uint32_t chip_type;

  char **truth_table;
} chip_state_t;

char *truth_table_138[] = {
  //"HXXXXX-LLLLLLLL",
  //"XHXXXX-LLLLLLLL",
  //"XXLXXX-LLLLLLLL",

  "LLHLLL-LHHHHHHH",
  "LLHHLL-HLHHHHHH",
  "LLHLHL-HHLHHHHH",
  "LLHHHL-HHHLHHHH",
  "LLHLLH-HHHHLHHH",
  "LLHHLH-HHHHHLHH",
  "LLHLHH-HHHHHHLH",
  "LLHHHH-HHHHHHHL",
  NULL
};

char *truth_table_238[] = {
  //"HXXXXX-LLLLLLLL",
  //"XHXXXX-LLLLLLLL",
  //"XXLXXX-LLLLLLLL",

  "LLHLLL-HLLLLLLL",
  "LLHHLL-LHLLLLLL",
  "LLHLHL-LLHLLLLL",
  "LLHHHL-LLLHLLLL",
  "LLHLLH-LLLLHLLL",
  "LLHHLH-LLLLLHLL",
  "LLHLHH-LLLLLLHL",
  "LLHHHH-LLLLLLLH",
  NULL
};

enum p {E1 = 0, E2, E3, A0, A1, A2, Y0, Y1, Y2, Y3, Y4, Y5, Y6, Y7};

static void chip_pin_change(void *user_data, pin_t pin, uint32_t value) {
  chip_state_t *chip = (chip_state_t*)user_data;
  // e1, e2, e3, a1, a2, a3
  //printf("pin: %i - value: %i\n", pin, value);
  if (pin >= 0 && pin <= 5) {
    char bits[7];
    int n = 0;
    for (; n < 6; n++) {
      bits[n] = pin_read(n)==LOW?'L':'H';
    }
    bits[n] = 0;
    //printf("Bits: %s\n", bits);

    int cnt = 0;
    while (chip->truth_table[cnt] != NULL) {
      if (strncmp(bits,chip->truth_table[cnt],6) == 0) {
        break;
      }
      cnt++;
    }
    if (chip->truth_table[cnt] == NULL) {
      for (int n = 6; n < 14; n++) {
        if (chip->chip_type == 138) {
          pin_write(n, HIGH);
        }
        else {
          pin_write(n, LOW);
        }
      }
    }
    else {
      //printf("Found: %d %d %s\n", pin, value, chip->truth_table[cnt]);
      for (int n = 6; n < 14; n++) {
        if (chip->truth_table[cnt][n+1] == 'H') {
          if (pin_read(n) == LOW) pin_write(n, HIGH);
        }
        else {
          if (pin_read(n) == HIGH) pin_write(n, LOW);
        }
      }
    }
  }
}

void chip_init(void) {
  chip_state_t *chip = malloc(sizeof(chip_state_t));

  uint32_t chip_type_handle = attr_init("chip-type", 138); // Default to red
  chip->chip_type = attr_read(chip_type_handle);
  if (chip->chip_type == 138) {
    chip->truth_table = truth_table_138;
  }
  else {
    chip->truth_table = truth_table_238;
  }

  chip->pin_e1 = pin_init("E1-", INPUT);
  chip->pin_e2 = pin_init("E2-", INPUT);
  chip->pin_e3 = pin_init("E3", INPUT);
  chip->pin_a0 = pin_init("A0", INPUT);
  chip->pin_a1 = pin_init("A1", INPUT);
  chip->pin_a2 = pin_init("A2", INPUT);

  chip->pin_y0 = pin_init("Y0", OUTPUT);
  chip->pin_y1 = pin_init("Y1", OUTPUT);
  chip->pin_y2 = pin_init("Y2", OUTPUT);
  chip->pin_y3 = pin_init("Y3", OUTPUT);
  chip->pin_y4 = pin_init("Y4", OUTPUT);
  chip->pin_y5 = pin_init("Y5", OUTPUT);
  chip->pin_y6 = pin_init("Y6", OUTPUT);
  chip->pin_y7 = pin_init("Y7", OUTPUT);

  const pin_watch_config_t config = {
    .edge = BOTH,
    .pin_change = chip_pin_change,
    .user_data = chip,
  };

  chip_pin_change(chip, 0, 0);

  pin_watch(chip->pin_e1, &config);
  pin_watch(chip->pin_e2, &config);
  pin_watch(chip->pin_e3, &config);

  pin_watch(chip->pin_a0, &config);
  pin_watch(chip->pin_a1, &config);
  pin_watch(chip->pin_a2, &config);

  //printf("Done init\n");

}


74hc138-238.chip.c

74HC138/74HC238

74hc138-238.chip.json

I implemented a circuit, to run a 6502 processer. The program in
ROM sends Hello world! to the LCD display, via the RIOT chip.

The circuit includes the following chips, and other devices:
* Clock          - This is the clock that the processor uses to 
                   run. It is not running at the 1MHZ, that the
                   processor would normally use, because it 
                   saturates the pin logic. The clock speed can
                   be change, by changing the timer value in the
                   chip. Currently, it is running about 100 times
                   slower. The clock pulse, changes state on each
                   interval of the timer.

* 6502 Processor - This is the processor that runs the program in 
                   ROM. it is a fully functioning 6502 processor 
                   empulation, except for the SO line, and BCD.  
                   I have some lines connected to the not 
                   connected lines, for debugging purposes. 
                   Normally, these would not be connected. It 
                   still needs to go through some testing.

* 6532 RIOT      - This is an I/O chip. Currently, I only have
                   the I/O implemented. The memory and timer are
                   not implemented.

* 6116 RAM       - This is 2K of static RAM. It is used for the 
                   zero page and stack. The memory can be used
                   to store informtion.

* 2716 EPROM     - This contains the code to use the LCD display.
                   This is at the bottom of the memory. There is
                   a vector table at the top of the memory.

* 74HC138        - This is a 3 bit to 8 line decoder. It is used
                   for address decoding.

* Reset button   - The red button is the reset. When you press
                   this button, it will reset the processor, and
                   execute the code pointed to by the RESET
                   vector.

* IRQ button     - The yellow button is the interupt request. 
                   When this button is pressed, it will interupt
                   what the processor is doing, if the interupt, 
                   disable flag is not set,  and run to code at 
                   the IRQ vector. Currently, it just returns 
                   from the interupt.

* NMI button       The blue button is the non-maskable interupt.
                   When this button is pressed, it will interupt
                   what the processor is doing, and regardless
                   if the interupt disable flags is set. 
                   Currently, it just returns from the interupt.

* Step button    - This is connected to the NC2 pin. It will step
                   through the code, each time the button is 
                   pressed. You need to set the step member in
                   the chip state, to 1, to have it step.

The following is the memory map for the circuit. The chips are
mirrors, because I don't have full decoding, of the address buss. 

The ram must be at the bottom of the memory map, because we 
need it for the zero page ($0000-$00FF) and stack ($0100-$01ff).

The rom most exist at the top of the memory map, because of the 
NMI ($FFFA-$FFFB), RESET ($FFFC-$FFFD), and IRQ ($FFFE-$FFFF) 
vectors.

The RIOT (RAM/Input/Output/Timer) chip follows the ram.

0x0000-0x07ff - RAM
0x0800-0x0fff - RIOT 
0x1000-0x37ff - Empty
0x3800-0x3fff - ROM

0x4000-0x47ff - RAM (Mirrored)
0x4800-0x4fff - RIOT (Mirrored)
0x5000-0x77ff - Empty
0x7800-0x7fff - ROM (Mirrored)

0x8000-0x87ff - RAM (Mirrored)
0x8800-0x8fff - RIOT (Mirrored)
0x9000-0xb7ff - Empty
0xb800-0xbfff - ROM (Mirrored)

0xc000-0xc7ff - RAM (Mirrored)
0xc800-0xcfff - RIOT (Mirrored)
0xd000-0xf7ff - Empty
0xf800-0xffff - ROM (Mirrored)

To start the processor, press the Reset button. This will
start executing the code. Eventually, I will change the code
to do the reset on power up. It is currently not doing it,
because the chips take some time, to initialize, and may not
be ready, when the processor is starting.

The Arduino is only there for power. I connected it up to an
LCD and have it output Hello World!. The program on the Arduino 
sketch, is the same thing, that the 6502 is doing, but in C.


readme.txt

pass 1

LINE  LOC          LABEL     PICT

   1                         PORTA = $0800
   2                         DDRA = $0801
   3                         PORTB = $0802
   4                         DDRB = $0803
   6                         E = %10000000
   7                         RW = %01000000
   8                         RS = %00100000
  10  F800                   .ORG $F800
  12  F800         RESET     
  13  F800                   LDX #$FF
  14  F802                   TXS
  16  F803                   LDA #%11111111 ; Set all pins on port B to output
  17  F805                   STA DDRB
  18  F808                   LDA #%11100000 ; Set top 3 pins on port A to output
  19  F80A                   STA DDRA
  21  F80D                   LDA #%00111000 ; Set 8-bit mode; 2-line display; 5x8 font
  22  F80F                   JSR LCD_INST
  23  F812                   LDA #%00001110 ; Display on; cursor on; blink off
  24  F814                   JSR LCD_INST
  25  F817                   LDA #%00000110 ; Increment and shift cursor; don't shift display
  26  F819                   JSR LCD_INST
  27  F81C                   LDA #$00000001 ; Clear display
  28  F81E                   JSR LCD_INST
  30  F821                   LDX #0
  31  F823         PRINT     
  32  F823                   LDA MESSAGE,X
  33  F826                   BEQ LOOP
  34  F828                   JSR PRINT_CH
  35  F82B                   INX
  36  F82C                   JMP PRINT
  38  F82F         LOOP      
  39  F82F                   JMP LOOP
  41  F832         MESSAGE   
  42  F832                   .ASCII "Hello, world!"
  43  F83F                   .BYTE $00
  46  F840         LCD_WAIT  
  47  F840                   PHA
  48  F841                   LDA #%00000000 ; Port B is input
  49  F843                   STA DDRB
  50  F846         LCDBUSY   
  51  F846                   LDA #RW
  52  F848                   STA PORTA
  53  F84B                   LDA #RW
  54  F84D                   ORA #E
  55  F84F                   STA PORTA
  56  F852                   LDA PORTB
  57  F855                   AND #%10000000
  58  F857                   BNE LCDBUSY
  60  F859                   LDA #RW
  61  F85B                   STA PORTA
  62  F85E                   LDA #%11111111 ; Port B is output
  63  F860                   STA DDRB
  64  F863                   PLA
  65  F864                   RTS
  67  F865         LCD_INST  
  68  F865                   JSR LCD_WAIT
  69  F868                   STA PORTB
  70  F86B                   LDA #0 ; Clear RS/RW/E bits
  71  F86D                   STA PORTA
  72  F870                   LDA #E ; Set E bit to send instruction
  73  F872                   STA PORTA
  74  F875                   LDA #0 ; Clear RS/RW/E bits
  75  F877                   STA PORTA
  76  F87A                   RTS
  78  F87B         PRINT_CH  
  79  F87B                   JSR LCD_WAIT
  80  F87E                   STA PORTB
  81  F881                   LDA #RS ; Set RS; Clear RW/E bits
  82  F883                   STA PORTA
  83  F886                   LDA #RS ; Set E bit to send 
  84  F888                   ORA #E
  85  F88A         INSTRUCT  
  86  F88A                   STA PORTA
  87  F88D                   LDA #RS ; Clear E bits
  88  F88F                   STA PORTA
  89  F892                   RTS
  90  F893         IRQ       
  91  F893                   RTI
  92  F894         NMI       
  93  F894                   RTI
  95  FFFA                   .ORG $FFFA
  96  FFFA                   .WORD NMI
  97  FFFC                   .WORD RESET
  98  FFFE                   .WORD IRQ

symbols
 DDRA       $0801
 DDRB       $0803
 E            $80
 INSTRUCT   $F88A
 IRQ        $F893
 LCDBUSY    $F846
 LCD_INST   $F865
 LCD_WAIT   $F840
 LOOP       $F82F
 MESSAGE    $F832
 NMI        $F894
 PORTA      $0800
 PORTB      $0802
 PRINT      $F823
 PRINT_CH   $F87B
 RESET      $F800
 RS           $20
 RW           $40

pass 2

LOC   CODE         LABEL     INSTRUCTION

                             PORTA = $0800
                             DDRA = $0801
                             PORTB = $0802
                             DDRB = $0803
                             E = $80
                             RW = $40
                             RS = $20
F800                         * = $F800
F800               RESET     
F800  A2 FF                  LDX #$FF
F802  9A                     TXS
F803  A9 FF                  LDA #$FF ; Set all pins on port B to output
F805  8D 03 08               STA $0803
F808  A9 E0                  LDA #$E0 ; Set top 3 pins on port A to output
F80A  8D 01 08               STA $0801
F80D  A9 38                  LDA #$38 ; Set 8-bit mode; 2-line display; 5x8 font
F80F  20 65 F8               JSR $F865
F812  A9 0E                  LDA #$0E ; Display on; cursor on; blink off
F814  20 65 F8               JSR $F865
F817  A9 06                  LDA #$06 ; Increment and shift cursor; don't shift display
F819  20 65 F8               JSR $F865
F81C  A9 01                  LDA #$01 ; Clear display
F81E  20 65 F8               JSR $F865
F821  A2 00                  LDX #$00
F823               PRINT     
F823  BD 32 F8               LDA $F832,X
F826  F0 07                  BEQ $F82F
F828  20 7B F8               JSR $F87B
F82B  E8                     INX
F82C  4C 23 F8               JMP $F823
F82F               LOOP      
F82F  4C 2F F8               JMP $F82F
F832               MESSAGE   
F832  48 65 6C               .ASCII "Hel
F834  6C 6F 2C               .ASCII "lo,
F837  20 77 6F               .ASCII " wo
F83A  72 6C 64               .ASCII "rld
F83D  21                     .ASCII "!"
F83F  00                     .BYTE $00
F840               LCD_WAIT  
F840  48                     PHA
F841  A9 00                  LDA #$00 ; Port B is input
F843  8D 03 08               STA $0803
F846               LCDBUSY   
F846  A9 40                  LDA #$40
F848  8D 00 08               STA $0800
F84B  A9 40                  LDA #$40
F84D  09 80                  ORA #$80
F84F  8D 00 08               STA $0800
F852  AD 02 08               LDA $0802
F855  29 80                  AND #$80
F857  D0 ED                  BNE $F846
F859  A9 40                  LDA #$40
F85B  8D 00 08               STA $0800
F85E  A9 FF                  LDA #$FF ; Port B is output
F860  8D 03 08               STA $0803
F863  68                     PLA
F864  60                     RTS
F865               LCD_INST  
F865  20 40 F8               JSR $F840
F868  8D 02 08               STA $0802
F86B  A9 00                  LDA #$00 ; Clear RS/RW/E bits
F86D  8D 00 08               STA $0800
F870  A9 80                  LDA #$80 ; Set E bit to send instruction
F872  8D 00 08               STA $0800
F875  A9 00                  LDA #$00 ; Clear RS/RW/E bits
F877  8D 00 08               STA $0800
F87A  60                     RTS
F87B               PRINT_CH  
F87B  20 40 F8               JSR $F840
F87E  8D 02 08               STA $0802
F881  A9 20                  LDA #$20 ; Set RS; Clear RW/E bits
F883  8D 00 08               STA $0800
F886  A9 20                  LDA #$20 ; Set E bit to send 
F888  09 80                  ORA #$80
F88A               INSTRUCT  
F88A  8D 00 08               STA $0800
F88D  A9 20                  LDA #$20 ; Clear E bits
F88F  8D 00 08               STA $0800
F892  60                     RTS
F893               IRQ       
F893  40                     RTI
F894               NMI       
F894  40                     RTI
FFFA                         * = $FFFA
FFFA  94 F8                  .EQUW $F894
FFFC  00 F8                  .EQUW $F800
FFFE  93 F8                  .EQUW $F893

done (code: F800..FFFF).

eprom-code.txt

PORTA = $0800
DDRA  = $0801
PORTB = $0802
DDRB  = $0803

E  = %10000000
RW = %01000000
RS = %00100000

  .org $f800

reset:
  ldx #$ff
  txs

  lda #%11111111 ; Set all pins on port B to output
  sta DDRB
  lda #%11100000 ; Set top 3 pins on port A to output
  sta DDRA

  lda #%00111000 ; Set 8-bit mode; 2-line display; 5x8 font
  jsr lcd_instruction
  lda #%00001110 ; Display on; cursor on; blink off
  jsr lcd_instruction
  lda #%00000110 ; Increment and shift cursor; don't shift display
  jsr lcd_instruction
  lda #$00000001 ; Clear display
  jsr lcd_instruction

  ldx #0
print:
  lda message,x
  beq loop
  jsr print_char
  inx
  jmp print

loop:
  jmp loop

message: 
.ascii "Hello, world!"
.byte $00


lcd_wait:
  pha
  lda #%00000000  ; Port B is input
  sta DDRB
lcdbusy:
  lda #RW
  sta PORTA
  lda #RW
  ora #E
  sta PORTA
  lda PORTB
  and #%10000000
  bne lcdbusy

  lda #RW
  sta PORTA
  lda #%11111111  ; Port B is output
  sta DDRB
  pla
  rts

lcd_instruction:
  jsr lcd_wait
  sta PORTB
  lda #0         ; Clear RS/RW/E bits
  sta PORTA
  lda #E         ; Set E bit to send instruction
  sta PORTA
  lda #0         ; Clear RS/RW/E bits
  sta PORTA
  rts

print_char:
  jsr lcd_wait
  sta PORTB
  lda #RS         ; Set RS; Clear RW/E bits
  sta PORTA
  lda #RS   ; Set E bit to send 
  ora #E
instruction
  sta PORTA
  lda #RS         ; Clear E bits
  sta PORTA
  rts
irq
  rti
nmi 
  rti

  ;.org $fffa
  ;.word nmi
  ;.word reset
  ;.word irq