# 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

dvi-generator

dvi-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 Ludicrous Speed

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

const uint32_t clk_freq = 252;

typedef struct {
  uint32_t visibleArea;
  uint32_t frontPorch;
  uint32_t syncPulse;
  uint32_t backPorch;
} sync_data_t;

const sync_data_t horizontal = {
  .visibleArea = 640, .frontPorch = 656, 
  .syncPulse = 752, .backPorch = 800
};

const sync_data_t vertical = {
  .visibleArea = 480, .frontPorch = 490, 
  .syncPulse = 492, .backPorch = 525
};

typedef struct {
  uint8_t value;
  bool C0;
  bool C1;
  bool DE;
  uint16_t stream;
  int8_t error;
} coder_data_t;

typedef struct {
  buffer_t frameBuffer;
  uint32_t width;
  uint32_t height;
  uint32_t horizontalCounter;
  uint32_t verticalCounter;
  uint32_t pixelCounter;
  pin_t pin[8];
  pin_t clk_pin;
  coder_data_t channels[3];
} chip_state_t;

static void chip_timer_event(void *user_data);
static void set_port(void *user_data, int id, bool level);
static void code_data(void *code);
static int N1(uint16_t value);
static int N0(uint16_t value);
static void chip_clk_change(void *user_data, pin_t pin, uint32_t value);

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

  chip->frameBuffer = framebuffer_init(&chip->width, &chip->height);
  chip->horizontalCounter = horizontal.backPorch - 1;
  chip->verticalCounter = vertical.backPorch - 1;
  chip->pixelCounter = 9;

  for (int i = 0; i < 3; i++) {
    chip->channels[i].DE = false;
    chip->channels[i].C0 = false;
    chip->channels[i].C1 = false;
    chip->channels[i].value = 0;
    chip->channels[i].stream = 0;
    chip->channels[i].error = 0;
  }

  const char* names[8] = { 
    "CLK+", "CLK-", "C2+", "C2-", "C1+", "C1-", "C0+", "C0-"
  };

  for (int i = 0; i < 8; i++) {
    chip->pin[i] = pin_init(names[i], OUTPUT);

    if (i & 0x1)
      pin_write(chip->pin[i], HIGH);
    else
      pin_write(chip->pin[i], LOW);
  }

  chip->clk_pin = pin_init("CLK", INPUT_PULLDOWN);
  const pin_watch_config_t watch_config = {
    .edge = RISING,
    .pin_change = chip_clk_change,
    .user_data = chip,
  };
  pin_watch(chip->clk_pin, &watch_config);

  chip_clk_change(chip, chip->clk_pin, HIGH);

  const timer_config_t timer_config =  {
    .callback = chip_timer_event, 
    .user_data = chip
  };
  timer_t timer = timer_init(&timer_config);
  timer_start_ns(timer, 10000 / clk_freq, true);
}

void chip_clk_change(void *user_data, pin_t pin, uint32_t value) {
  chip_state_t *chip = (chip_state_t*)user_data;

  for (int y = 0; y < chip->height; y++) {
    for (int x = 0; x < chip->width; x++) {
      uint32_t color = (uint32_t)rand() | 0xFF000000;
      buffer_write(chip->frameBuffer, (y * chip->width + x) * 4, &color, sizeof(color));
    }
  }
}

const int PIN_CLK = 0;
const int PIN_C0 = 6;
const int PIN_C1 = 4;
const int PIN_C2 = 2;

void set_port(void *user_data, int id, bool level) {
  chip_state_t *chip = (chip_state_t*)user_data;
  pin_t pinP = chip->pin[id];
  pin_t pinN = chip->pin[id + 1];

  pin_write(pinP, level ? HIGH : LOW);
  pin_write(pinN, level ? LOW : HIGH);
}

int N1(uint16_t value) {
  int ret = 0;

  for (int i = 0; i < 8; i++) {
    if (value & 0x1)
      ret++;
    value >>= 1;
  }

  return ret;
}

int N0(uint16_t value) {
  int ret = 0;

  for (int i = 0; i < 8; i++) {
    if (!(value & 0x1))
      ret++;
    value >>= 1;
  }

  return ret;
}

uint16_t set_bit(uint16_t value, uint16_t bit, int pos) {
  uint16_t s = 1 << pos;

  if (bit > 0)
    return value | s;
  return value & ~s;
}

uint16_t get_bit(uint16_t value, int pos) {
  return (value >> pos) & 1;
}

void code_data(void *code) {
  coder_data_t *data = (coder_data_t*)code;
  if (!data->DE) {
    data->error = 0;
    if (!data->C1) {
      if (!data->C0)
        data->stream = 0x00AB;
      else
        data->stream = 0x0354;
    }
    else {
      if (!data->C0)
        data->stream = 0x00AA;
      else
        data->stream = 0x0355;
    }
    return;
  }

  int N1d = N1(data->value);
  data->stream = data->value & 0x1;
  if (N1d > 4 || (N1d == 4 && !(data->value && 0x1))) {
    for (int i = 1; i < 8; i++) {
      uint16_t v = (get_bit(data->stream, i-1) ^ get_bit(data->value, i)) & 1;
      data->stream = set_bit(data->stream, v, i);
    }
    data->stream = set_bit(data->stream, 1, 8);
  }
  else {
    for (int i = 1; i < 8; i++) {
      uint16_t v = ~(get_bit(data->stream, i-1) ^ get_bit(data->value, i)) & 1;
      data->stream = set_bit(data->stream, v, i);
    }
    data->stream = set_bit(data->stream, 1, 8);
  }
  int N1m = N1(data->stream);
  int N0m = N0(data->stream);
  uint16_t v = get_bit(data->stream, 8);
  if (data->error == 0 || N1m == N0m) {
    data->stream = set_bit(data->stream, (~v) & 1, 9);
    if (v) {
      for (int i = 0; i < 8; i++) {
        uint16_t b = get_bit(data->stream, i);
        data->stream = set_bit(data->stream, (~b) & 1, i);
      }

      data->error += (N0m - N1m);
    }
    else {
      data->error += (N1m - N0m);
    }
  }
  else {
    if ((data->error > 0 && N1m > N0m) || (data->error < 0 && N0m > N1m)) {
      data->stream = set_bit(data->stream, 1, 9);
      data->error += 2*v + N0m - N1m;
    }
    else {
      data->stream = set_bit(data->stream, 0, 9);
      data->error += -2*((~v) & 1) + N1m - N0m;
    }
  }
}

void chip_timer_event(void *user_data) {
  chip_state_t *chip = (chip_state_t*)user_data;

  if (chip->pixelCounter == 0) {
    chip->horizontalCounter = (chip->horizontalCounter + 1) % horizontal.backPorch;
    if (chip->horizontalCounter == 0)
      chip->verticalCounter = (chip->verticalCounter + 1) % vertical.backPorch;
    
    if (chip->horizontalCounter < horizontal.visibleArea && chip->verticalCounter < vertical.visibleArea) {
      for (int i = 0; i < 3; i++) {
        chip->channels[i].DE = true;
        int offset = 4 * ((chip->verticalCounter >> 2) * chip->width + (chip->horizontalCounter >> 2));
        buffer_read(chip->frameBuffer, offset + i, &chip->channels[i].value, 1);
        code_data(&chip->channels[i]);
      }
    }
    else {
      int h = chip->horizontalCounter;
      int v = chip->verticalCounter;
      chip->channels[0].C0 = h >= horizontal.frontPorch && h < horizontal.syncPulse;
      chip->channels[0].C1 = v >= vertical.frontPorch && v < vertical.syncPulse;
      
      for (int i = 0; i < 3; i++) {
        chip->channels[i].DE = false;
        code_data(&chip->channels[i]);
      }
    }
  }

  set_port(chip, PIN_CLK, chip->pixelCounter < 5);
  set_port(chip, PIN_C2, get_bit(chip->channels[0].stream, chip->pixelCounter));
  set_port(chip, PIN_C1, get_bit(chip->channels[1].stream, chip->pixelCounter));
  set_port(chip, PIN_C0, get_bit(chip->channels[2].stream, chip->pixelCounter));

  chip->pixelCounter = (chip->pixelCounter + 1) % 10;
}


dvi-generator.chip.c

clk-60hz

clk-60hz.chip.json

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

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

typedef struct {
  bool state;
  pin_t clk;
} chip_state_t;

static void chip_timer_event(void *user_data);

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

  chip->state = false;
  chip->clk = pin_init("OUT", OUTPUT_LOW);

  const timer_config_t timer_config =  {
    .callback = chip_timer_event, 
    .user_data = chip
  };
  timer_t timer = timer_init(&timer_config);
  timer_start(timer, 1000000 / 120, true);
}

void chip_timer_event(void *user_data) {
  chip_state_t *chip = (chip_state_t*)user_data;
  
  if (chip->state == false) {
    pin_write(chip->clk, HIGH);
    chip->state = true;
  }
  else {
    pin_write(chip->clk, LOW);
    chip->state = false;
  }
}
