# Blank project

This is a blank Wokwi project. Please edit this README file and add a description of your project.

## Usage

1. Add parts by clicking the blue "+" button in the diagram editor
2. Connect parts by dragging wires between them
3. Click the green play button to start the simulation


README.md

diagram.json

clk-generator

clk-generator.chip.json

// Wokwi Custom Chip - For docs and examples see:
// https://docs.wokwi.com/chips-api/getting-started
//
// SPDX-License-Identifier: MIT
// Copyright 2023 philippe Gauthier

#include "wokwi-api.h"
#include <stdio.h>
#include <stdlib.h>

typedef struct {
  pin_t clk0;
  pin_t clk1;
  pin_t clk2;
  uint8_t state0;
  uint8_t state1;
  uint8_t state2;
} chip_state_t;

static void chip_timer_event0(void *user_data);
static void chip_timer_event1(void *user_data);
static void chip_timer_event2(void *user_data);

void chip_init() {
  chip_state_t *chip = malloc(sizeof(chip_state_t));

  chip->clk0 = pin_init("clk0", OUTPUT_LOW);
  chip->clk1 = pin_init("clk1", OUTPUT_LOW);
  chip->clk2 = pin_init("clk2", OUTPUT_LOW);

  chip->state0 = 0;
  chip->state1 = 0;
  chip->state2 = 0;

  const timer_config_t timer_config0 = {
    .callback = chip_timer_event0,
    .user_data = chip,
  };
  timer_t timer0 = timer_init(&timer_config0);

  const timer_config_t timer_config1 = {
    .callback = chip_timer_event1,
    .user_data = chip,
  };
  timer_t timer1 = timer_init(&timer_config1);

  const timer_config_t timer_config2 = {
    .callback = chip_timer_event2,
    .user_data = chip,
  };
  timer_t timer2 = timer_init(&timer_config2);

  timer_start(timer0, 5128, true);
  timer_start(timer1, 6614, true);
  timer_start(timer2, 96451, true);
}

void chip_timer_event0(void *user_data) {
  chip_state_t *chip = (chip_state_t*)user_data;
  chip->state0 = ~chip->state0;
  pin_write(chip->clk0, chip->state0);
}

void chip_timer_event1(void *user_data) {
  chip_state_t *chip = (chip_state_t*)user_data;
  chip->state1 = ~chip->state1;
  pin_write(chip->clk1, chip->state1);
}

void chip_timer_event2(void *user_data) {
  chip_state_t *chip = (chip_state_t*)user_data;
  chip->state2 = ~chip->state2;
  pin_write(chip->clk2, chip->state2);
}


clk-generator.chip.c

fake-dual-port-ram

fake-dual-port-ram.chip.json

// Wokwi Custom Chip - For docs and examples see:
// https://docs.wokwi.com/chips-api/getting-started
//
// SPDX-License-Identifier: MIT
// Copyright 2023 philippe Gauthier

#include "wokwi-api.h"
#include <stdio.h>
#include <stdlib.h>

#define STATE_IDLE 0
#define STATE_WRITING 1
#define STATE_READING 2

typedef struct {
  pin_t pin;
  uint8_t state;
} pin_state_t;

typedef struct {
  pin_t clk;
  pin_state_t write;
  pin_state_t read;
  pin_t busy;
  pin_t write_done;
  pin_t read_done;

  uint8_t state;
} chip_state_t;

static void chip_pin_changew(void *user_data, pin_t pin, uint32_t value) {
  chip_state_t *chip = (chip_state_t*)user_data;
  chip->write.state = HIGH;
}

static void chip_pin_changer(void *user_data, pin_t pin, uint32_t value) {
  chip_state_t *chip = (chip_state_t*)user_data;
  chip->read.state = HIGH;
}

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->state == STATE_WRITING) {
    //done writing
    pin_write(chip->write_done, HIGH);
    pin_write(chip->read_done, LOW);
  }
  else if (chip->state == STATE_READING) {
    //done reading
    pin_write(chip->write_done, LOW);
    pin_write(chip->read_done, HIGH);
  }
  else {
    //idle
    pin_write(chip->write_done, LOW);
    pin_write(chip->read_done, LOW);
  }

  if (chip->write.state == HIGH) {
    //change to write
    chip->state = STATE_WRITING;
    pin_write(chip->busy, HIGH);
    chip->write.state = LOW;
  }
  else if (chip->read.state == HIGH) {
    //change to read
    chip->state = STATE_READING;
    pin_write(chip->busy, HIGH);
    chip->read.state = LOW;
  }
  else {
    //change to idle
    chip->state = STATE_IDLE;
    pin_write(chip->busy, LOW);
  }
}

void chip_init() {
  chip_state_t *chip = malloc(sizeof(chip_state_t));

  chip->clk = pin_init("p_clk", INPUT);
  chip->write.pin = pin_init("p_write", INPUT);
  chip->read.pin = pin_init("p_read", INPUT);

  chip->busy = pin_init("p_busy", OUTPUT_LOW);
  chip->write_done = pin_init("p_write_done", OUTPUT_LOW);
  chip->read_done = pin_init("p_read_done", OUTPUT_LOW);

  chip->write.state = LOW;
  chip->read.state = LOW;
  chip->state = STATE_IDLE;

  const pin_watch_config_t config = {
    .edge = RISING,
    .pin_change = chip_pin_change,
    .user_data = chip,
  };
  pin_watch(chip->clk, &config);

  const pin_watch_config_t configw = {
    .edge = RISING,
    .pin_change = chip_pin_changew,
    .user_data = chip,
  };
  pin_watch(chip->write.pin, &configw);

  const pin_watch_config_t configr = {
    .edge = RISING,
    .pin_change = chip_pin_changer,
    .user_data = chip,
  };
  pin_watch(chip->read.pin, &configr);
}
