// custom IC TANK SIMULATOR tank-simulator // inputs: motor control signals // mode 0 // old inputs A and B -> MI0, MI1 think back-to-back diodes // A && !B "empties", !A && B "fills"; the other combinations are meaningless here // mode 1 // old inputs /ENB, DIR -> MI0, MI1 run the motor to fill or empty the tank // outputs UL LL are active high limit switches at the extreme tank [? need ideas here] // UI: prints current tank level if changed, diagnostics // UI: fat bar in framebuffer // diagram.json // reverse for DIR sense correction // invert for active low UL, LL /* { "type": "chip-tank-simulator", "id": "chip6", "top": -795.78, "left": -321.6, "attrs": { "reverse": "1", "invert": "1"} }, */ # include "wokwi-api.h" # include # include typedef struct { uint8_t r; uint8_t g; uint8_t b; uint8_t a; } rgba_t; const rgba_t red = { .r = 0xff, .g=0xf, .a = 0xff }; const rgba_t green = { .r = 0x0, .g=0xff, .a = 0xff }; const rgba_t yellow = { .r = 0xff, .g=0xff, .b=0x0, .a=0xff }; const rgba_t white = { .r = 0xff, .g=0xff, .b=0xff, .a=0xff }; const rgba_t black = { .r = 0x0, .g=0x0, .b=0x0, .a=0xff }; const rgba_t myColors[] = {black, red, green, yellow, white}; enum {BLACK, RED, GREEN, YELLOW, WHITE}; const unsigned long tick = 75; // milliseconds const int MS = 1000; // micros const unsigned char N = 100; // LEDs on a strip or slots on a raster void chip_timer_event(void *); /* "pins": [ "MI0", "MI1", "", "MODE", "GND", "VCC", "LL", "UL" ], */ typedef struct { // framebuffer API buffer_t framebuffer; uint32_t width; uint32_t height; uint32_t row; time_t gTimer; // loop service timer int counter; // count the loops during development int level; int lastLevel; // print guard // example attribute // uint32_t myTest_attr; // uint32_t myTest; // attributes // "reverse":"1" the motor direction 0 default // "invert":"1" the limit switch outputs 0 default // "spare" uint32_t reverse_attr; uint32_t reverse; uint32_t invert_attr; uint32_t invert; uint32_t spare_attr; uint32_t spare; pin_t pin_mi0; pin_t pin_mi1; pin_t pin_mode; pin_t pin_ul; pin_t pin_ll; pin_t pin_vcc; pin_t pin_gnd; } chip_state_t; // printf("level %3d run %s dir %s \n", chip->level, running ? "YES" : "NO ", direction ? "LEFT " : "RIGHT "); static void update_outputs(chip_state_t *chip) { bool mi0 = pin_read(chip->pin_mi0); bool mi1 = pin_read(chip->pin_mi1); bool hbMode = pin_read(chip->pin_mode); bool running = false; // derived from motor monitor inputs bool direction = false; // derived from motor monitor inputs if (hbMode) { // mi0 is /ENB, mi1 is DIR running = !mi0; // active low enable direction = mi1; } else { // mi0 is MOTOR A, mi1 is MOTOR B B <--/(M))/--> A running = mi0 ^ mi1; direction = mi0 & !mi1; } if (chip->reverse) direction = !direction; // at this point mi0 and mi1 are -> running and dir if (running) { if (direction) chip->level -= 2; // tuning, working it from both ends else chip->level += 2; } // one way around signed <> unsigned comparisons const int maxLevel = chip->height - 1; if (chip->level > maxLevel) chip->level = maxLevel; if (chip->level < 0) chip->level = 0; // printf("constrained level %d\n", chip->level); // bumped level -2, constrained level 127 bool upperLimit = (chip->level >= chip->height - 1 - 14) ^ chip->invert; bool loweLimit = (chip->level <= 14) ^ chip->invert; /* if (upperLimit) { pinMode(chip->pin_ul, ) ... open collector-ize this with pin mode tricks? */ pin_write(chip->pin_ul, upperLimit); pin_write(chip->pin_ll, loweLimit); if (0) if (chip->lastLevel != chip->level) { printf("level %d\n", chip->level); chip->lastLevel = chip->level; } } void chip_init(void) { chip_state_t *chip = calloc(1, sizeof(chip_state_t)); // initially 0s // chip->counter = 0; chip->level = 64; chip->lastLevel = -1; // chip->myTest_attr = attr_init("test", 42); // chip->myTest = attr_read(chip->myTest_attr); chip->reverse_attr = attr_init("reverse", 0); chip->reverse = attr_read(chip->reverse_attr); chip->invert_attr = attr_init("invert", 0); chip->invert = attr_read(chip->invert_attr); chip->spare_attr = attr_init("spare", 0); chip->spare = attr_read(chip->spare_attr); printf("reverse:%d invert:%d spare:%d\n", chip->reverse, chip->invert, chip->spare); chip->row = 0; chip->framebuffer = framebuffer_init(&chip->width, &chip->height); // printf("Framebuffer: width=%d, height=%d\n", chip->width, chip->height); chip->pin_mi0 = pin_init("MI0", INPUT); chip->pin_mi1 = pin_init("MI1", INPUT); chip->pin_mode = pin_init("MODE", INPUT); printf("motor monitor %s\n", pin_read(chip->pin_mode) ? "/ENB, DIR" : "A, B"); chip->pin_ul = pin_init("UL", OUTPUT); chip->pin_ll = pin_init("LL", OUTPUT); update_outputs(chip); // watch pins if you need the callback, see below const timer_config_t timer_config = { .callback = chip_timer_event, .user_data = chip, }; chip->gTimer = timer_init(&timer_config); timer_start(chip->gTimer, tick * MS, true); } void draw_line(chip_state_t *chip, uint32_t row, int color) { uint32_t offset = chip->width * 4 * row; // we may have been scribbling outside the frame buffer if (row >= chip->height) return; rgba_t drawColor = myColors[color]; for (int x = 0; x < chip->width * 4; x += 4) { buffer_write(chip->framebuffer, offset + x, &drawColor, sizeof(drawColor)); } } # define FAT 2 void draw_fat(chip_state_t *chip, uint32_t centerPos, int baseColor) { for (int offset = -INDICATOR_HALF; offset <= INDICATOR_HALF; offset++) { int linePos = centerPos + offset; if (linePos < 0 || linePos >= (int)chip->displaySize) continue; int lineColor; if (baseColor == BLACK) { // Erase mode: just draw black everywhere lineColor = BLACK; } else { // Normal drawing: apply zone logic if (centerPos == 0 || centerPos == chip->displaySize - 1) { lineColor = RED; } else if (linePos < (int)chip->margin || linePos > (int)(chip->displaySize - 1 - chip->margin)) { lineColor = YELLOW; } else { lineColor = GREEN; } } draw_line_at_position(chip, linePos, lineColor); } } void chip_timer_event(void *user_data) { chip_state_t *chip = (chip_state_t *)user_data; if (!(chip->counter % 16)) ; // printf("%d. tick\n", chip->counter); // chip level informs bar y coordinate uint32_t rowDisplay; // rowDisplay = chip->height - 1 - chip->level; rowDisplay = chip->level; draw_fat(chip, rowDisplay, BLACK); chip->counter++; update_outputs(chip); // rowDisplay = chip->height - 1 - chip->level; rowDisplay = chip->level; draw_fat(chip, rowDisplay, GREEN); // chip->row = chip->level; // sorry Mom. maths later } // watch pins if you need the callback /* const pin_watch_config_t config = { .edge = BOTH, .pin_change = chip_pin_change, .user_data = chip, }; pin_watch(chip->pin_mi0, &config); pin_watch(chip->pin_mi1, &config); pin_watch(chip->pin_mode, &config); // and supply static void chip_pin_change(void *user_data, pin_t pin, uint32_t value) { (void)pin; (void)value; chip_state_t *chip = (chip_state_t *)user_data; // update_outputs(chip); } */