Cool_Tools/exa-io
1
0
Fork 0
mirror of https://github.com/exA-Arcadia/exa-io.git synced 2024-11-15 02:27:35 +01:00
Code Issues Activity
72acf0c254
exa-io/firmware/td-io.c
Thomas Daede 72acf0c254 Add chaining support
2021-03-03 18:29:28 -08:00

474 lines
18 KiB
C
Raw Blame History

#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/adc.h"
#include <string.h>
const uint PIN_JVS_RE = 2;
const uint PIN_JVS_DE = 3;
const uint PIN_JVS_SENSE_2_5V = 14;
const uint PIN_JVS_SENSE_0V = 13;
const uint PIN_JVS_TERMINATION = 15;
const uint PIN_JVS_SENSE_IN = 26;
const uint PIN_SR_DATA = 6;
const uint PIN_SR_CLK = 5;
const uint PIN_SR_SH = 4;
const uint PIN_METER1 = 7;
const uint PIN_METER2 = 8;
const uint PIN_LOCKOUT1 = 9;
const uint PIN_LOCKOUT2 = 10;
const uint16_t JVS_TERMINATION_THRESHOLD = (uint16_t)(3.75/2.0/3.3*4096);
const uint16_t JVS_0V_THRESHOLD = (uint16_t)(1.25/2.0/3.3*4096);
const uint8_t JVS_STATUS_GOOD = 1;
const uint8_t JVS_STATUS_UNKNOWN_COMMAND = 2;
const uint8_t JVS_STATUS_CHECKSUM_ERROR = 3;
const uint8_t JVS_STATUS_OVERFLOW = 4;
const uint8_t JVS_REPORT_GOOD = 1;
const uint8_t JVS_REPORT_PARAMETER_INVALID = 3;
const uint8_t JVS_MAX_LEN = 253; // minus two for status and checksum
// global state
uint8_t our_address = 0;
// signed for underflow checks
int16_t coin_count_p1 = 0;
int16_t coin_count_p2 = 0;
uint8_t prev_coin_p1 = 0;
uint8_t prev_coin_p2 = 0;
#define SR_P1_3 7
#define SR_P2_3 6
#define SR_P1_4 5
#define SR_P2_4 4
#define SR_P1_5 3
#define SR_P2_5 2
#define SR_P1_6 1
#define SR_P2_6 0
#define SR_P1_LEFT 15
#define SR_P2_LEFT 14
#define SR_P1_RIGHT 13
#define SR_P2_RIGHT 12
#define SR_P1_1 11
#define SR_P2_1 10
#define SR_P1_2 9
#define SR_P2_2 8
#define SR_C1 23
#define SR_C2 22
#define SR_P1_START 21
#define SR_P2_START 20
#define SR_P1_UP 19
#define SR_P2_UP 18
#define SR_P1_DOWN 17
#define SR_P2_DOWN 16
#define SR_SERVICE 31
#define SR_TEST 30
#define SR_TILT 29
const char id_str[] = "TD;TD-IO;v1.0;https://github.com/tdaede/td-io";
const uint8_t input_desc[] = {
0x01, 2, 12, 0,
0x02, 2, 0, 0,
0x00
};
void jvs_sync() {
uart_putc(uart0, 0xe0);
}
uint8_t jvs_getc() {
uint8_t c = uart_getc(uart0);
if (c == 0xd0) {
c = uart_getc(uart0);
return c + 1;
} else {
return c;
}
}
void jvs_putc(uint8_t c) {
if (c == 0xe0) {
uart_putc(uart0, 0xd0);
uart_putc(uart0, 0xdf);
} else if (c == 0xd0) {
uart_putc(uart0, 0xd0);
uart_putc(uart0, 0xcf);
} else {
uart_putc(uart0, c);
}
}
void start_transmit() {
gpio_put(PIN_JVS_RE, 1); // disable receive
gpio_put(PIN_JVS_DE, 1); // enable transmitter
}
void stop_transmit() {
uart_tx_wait_blocking(uart0);
gpio_put(PIN_JVS_DE, 0); // disable transmitter
gpio_put(PIN_JVS_RE, 0); // enable receiver
}
void send_message(uint8_t status, uint8_t* m, uint8_t msg_len) {
start_transmit();
jvs_sync();
uint8_t checksum = 0;
jvs_putc(0);
checksum += 0;
jvs_putc(msg_len + 2);
checksum += msg_len + 2;
jvs_putc(status);
checksum += status;
for (int i = 0; i < msg_len; i++) {
jvs_putc(m[i]);
checksum += m[i];
}
jvs_putc(checksum);
stop_transmit();
}
uint32_t read_switches() {
uint32_t r;
gpio_put(PIN_SR_SH, 1);
busy_wait_us(1);
for (int i = 0; i < 32; i++) {
r >>= 1;
r |= (gpio_get(PIN_SR_DATA) ? 1 : 0) << 31;
gpio_put(PIN_SR_CLK, 1);
busy_wait_us(1);
gpio_put(PIN_SR_CLK, 0);
busy_wait_us(1);
}
gpio_put(PIN_SR_SH, 0);
return ~r;
}
void update_termination() {
uint16_t v = adc_read();
if (v >= JVS_TERMINATION_THRESHOLD) {
gpio_put(PIN_JVS_TERMINATION, 0);
} else {
gpio_put(PIN_JVS_TERMINATION, 1);
}
}
// call periodically with switch read to check level changes of coin input
void process_coin(uint32_t switches) {
if ((switches >> SR_C1 & 1) && !prev_coin_p1) {
coin_count_p1++;
if (coin_count_p1 > 16383) {
coin_count_p1 = 16383;
}
}
if ((switches >> SR_C2 & 1) && !prev_coin_p2) {
coin_count_p2++;
if (coin_count_p2 > 16383) {
coin_count_p2 = 16383;
}
}
prev_coin_p1 = switches >> SR_C1 & 1;
prev_coin_p2 = switches >> SR_C2 & 1;
gpio_put(PIN_METER1, prev_coin_p1);
gpio_put(PIN_METER2, prev_coin_p2);
gpio_put(PIN_LOCKOUT1, coin_count_p1 >= 16383);
gpio_put(PIN_LOCKOUT2, coin_count_p2 >= 16383);
}
int main() {
stdio_init_all();
uart_init(uart0, 115200);
uart_set_translate_crlf(uart0, false);
gpio_set_function(0, GPIO_FUNC_UART);
gpio_set_function(1, GPIO_FUNC_UART);
gpio_init(PIN_JVS_RE);
gpio_put(PIN_JVS_RE, 0); // enable receiver
gpio_set_dir(PIN_JVS_RE, GPIO_OUT);
gpio_init(PIN_JVS_DE);
gpio_put(PIN_JVS_DE, 0); //disable transmitter
gpio_set_dir(PIN_JVS_DE, GPIO_OUT);
gpio_init(PIN_JVS_SENSE_2_5V);
gpio_put(PIN_JVS_SENSE_2_5V, 1); // always appear present
gpio_set_dir(PIN_JVS_SENSE_2_5V, GPIO_OUT);
gpio_init(PIN_JVS_SENSE_0V);
gpio_put(PIN_JVS_SENSE_0V, 0);
gpio_set_dir(PIN_JVS_SENSE_0V, GPIO_OUT);
gpio_init(PIN_JVS_TERMINATION);
gpio_put(PIN_JVS_TERMINATION, 1); // disable termination by default
gpio_set_dir(PIN_JVS_TERMINATION, GPIO_OUT);
adc_init();
adc_gpio_init(PIN_JVS_SENSE_IN);
adc_select_input(0);
// sr
gpio_init(PIN_SR_DATA);
gpio_set_dir(PIN_SR_DATA, GPIO_IN);
gpio_init(PIN_SR_CLK);
gpio_put(PIN_SR_CLK, 0);
gpio_set_dir(PIN_SR_CLK, GPIO_OUT);
gpio_init(PIN_SR_SH);
gpio_put(PIN_SR_SH, 0);
gpio_set_dir(PIN_SR_SH, GPIO_OUT);
// coin/lockout drivers
gpio_init(PIN_METER1);
gpio_put(PIN_METER1, 0);
gpio_set_dir(PIN_METER1, GPIO_OUT);
gpio_init(PIN_METER2);
gpio_put(PIN_METER2, 0);
gpio_set_dir(PIN_METER2, GPIO_OUT);
gpio_init(PIN_LOCKOUT1);
gpio_put(PIN_LOCKOUT1, 0);
gpio_set_dir(PIN_LOCKOUT1, GPIO_OUT);
gpio_init(PIN_LOCKOUT2);
gpio_put(PIN_LOCKOUT2, 0);
gpio_set_dir(PIN_LOCKOUT2, GPIO_OUT);
update_termination();
while (true) {
uint8_t sync = uart_getc(uart0);
if (sync == 0xe0) {
uint8_t our_checksum = 0;
uint8_t node_num = jvs_getc();
if (!((node_num == 0xff) || ((our_address == node_num) && (our_address != 0)))) {
continue;
}
our_checksum += node_num;
uint8_t length = jvs_getc();
our_checksum += length;
uint8_t msg_length = length - 1;
uint8_t message[256];
for (int i = 0; i < msg_length; i++) {
uint8_t c = jvs_getc();
our_checksum += c;
message[i] = c;
}
uint8_t msg_send[256*2]; // a few bytes to spare for easier overflow checking
int o = 0;
uint8_t status = JVS_STATUS_GOOD;
uint8_t their_checksum = jvs_getc();
if (our_checksum == their_checksum) {
int i = 0;
while (i < msg_length) {
if ((msg_length - i) >= 2 && message[i] == 0xf0 && message[i+1] == 0xd9) {
printf("N: %02x Reset\n", node_num);
our_address = 0;
gpio_put(PIN_JVS_SENSE_0V, 0);
i += 2;
} else if ((msg_length - i) >= 2 && message[i] == 0xf1) {
uint8_t node_id = message[i+1];
i += 2;
printf("Assign node id N: %02x\n", node_id);
uint16_t v = adc_read();
printf("Reading ADC: %d\n", v);
v = 4095; // FIXME: adc circuit is bad
if ((v >= JVS_TERMINATION_THRESHOLD) || (v < JVS_0V_THRESHOLD)) {
printf("Assigning our address\n");
our_address = node_id;
msg_send[o] = JVS_REPORT_GOOD;
o++;
gpio_put(PIN_JVS_SENSE_0V, 1);
} else {
printf("We are not currently last in the chain, skipping assignment\n");
}
} else if ((msg_length - i) >= 1 && message[i] == 0x10) {
i++;
printf("Got ID code request\n");
msg_send[o] = JVS_REPORT_GOOD;
o++;
strcpy((char*)&msg_send[o], id_str);
o += strlen(id_str) + 1;
} else if ((msg_length - i) >= 1 && message[i] == 0x11) {
i++;
printf("Got revision request\n");
msg_send[o] = JVS_REPORT_GOOD;
o++;
msg_send[o] = 0x13;
o++;
} else if ((msg_length - i) >= 1 && message[i] == 0x12) {
i++;
printf("Got video revision request\n");
msg_send[o] = JVS_REPORT_GOOD;
o++;
msg_send[o] = 0x30;
o++;
} else if ((msg_length - i) >= 1 && message[i] == 0x13) {
i++;
printf("Got io revision request\n");
msg_send[o] = JVS_REPORT_GOOD;
o++;
msg_send[o] = 0x10;
o++;
} else if ((msg_length - i) >= 1 && message[i] == 0x14) {
i++;
printf("Got input descriptor request\n");
msg_send[o] = JVS_REPORT_GOOD;
o++;
memcpy(&msg_send[o], input_desc, sizeof(input_desc));
o += sizeof(input_desc);
} else if ((msg_length - i) >= 3 && message[i] == 0x20) {
int num_players = message[i+1];
int bytes_per_player = message[i+2];
i += 3;
if (o + num_players*bytes_per_player >= JVS_MAX_LEN) {
printf("JVS response overflow!\n");
status = JVS_STATUS_OVERFLOW;
break;
}
msg_send[o] = JVS_REPORT_GOOD;
o++;
uint32_t switches = read_switches();
process_coin(switches);
msg_send[o] = ((switches >> SR_TEST) & 1) << 7
| ((switches >> SR_TILT) & 1) << 7;
o++;
//printf("Got coin slot request for %02x slots\n", slots);
for (int player = 0; player < num_players; player++) {
for (int byte = 0; byte < bytes_per_player; byte++) {
uint8_t b = 0;
if ((player == 0) && (byte == 0)) {
b = ((switches >> SR_P1_2) & 1) << 0
| ((switches >> SR_P1_1) & 1) << 1
| ((switches >> SR_P1_RIGHT) & 1) << 2
| ((switches >> SR_P1_LEFT) & 1) << 3
| ((switches >> SR_P1_DOWN) & 1) << 4
| ((switches >> SR_P1_UP) & 1) << 5
| ((switches >> SR_SERVICE) & 1) << 6
| ((switches >> SR_P1_START) & 1) << 7;
} else if ((player == 0) && (byte == 1)) {
b = ((switches >> SR_P1_6) & 1) << 4
| ((switches >> SR_P1_5) & 1) << 5
| ((switches >> SR_P1_4) & 1) << 6
| ((switches >> SR_P1_3) & 1) << 7;
} else if ((player == 1) && (byte == 0)) {
b = ((switches >> SR_P2_2) & 1) << 0
| ((switches >> SR_P2_1) & 1) << 1
| ((switches >> SR_P2_RIGHT) & 1) << 2
| ((switches >> SR_P2_LEFT) & 1) << 3
| ((switches >> SR_P2_DOWN) & 1) << 4
| ((switches >> SR_P2_UP) & 1) << 5
| ((switches >> SR_P2_START) & 1) << 7;
} else if ((player == 1) && (byte == 1)) {
b = ((switches >> SR_P2_6) & 1) << 4
| ((switches >> SR_P2_5) & 1) << 5
| ((switches >> SR_P2_4) & 1) << 6
| ((switches >> SR_P2_3) & 1) << 7;
}
msg_send[o] = b;
o++;
}
}
} else if ((msg_length - i) >= 2 && message[i] == 0x21) {
int slots = message[i+1];
i += 2;
if (o + slots*2 >= JVS_MAX_LEN) {
printf("JVS response overflow!\n");
status = JVS_STATUS_OVERFLOW;
break;
}
msg_send[o] = JVS_REPORT_GOOD;
o++;
//printf("Got coin slot request for %02x slots\n", slots);
for (int slot = 0; slot < slots; slot++) {
if (slot == 0) {
msg_send[o] = coin_count_p1 >> 8;
msg_send[o+1] = coin_count_p1 & 0xFF;
} else if (slot == 1) {
msg_send[o] = coin_count_p2 >> 8;
msg_send[o+1] = coin_count_p2 & 0xFF;
} else {
msg_send[o] = 0x80;
msg_send[o+1] = 0x00;
}
o += 2;
}
} else if ((msg_length - i) >= 4 && message[i] == 0x30) {
uint8_t slot = message[i+1];
uint16_t amount = (message[i+2] << 8) + message[i+3];
i += 4;
printf("Decrement coin counter %d by %d\n", (int)slot, (int)amount);
if (amount > 16383) {
amount = 16383;
printf("Capped to 16383\n");
}
if (slot == 1) {
msg_send[o] = JVS_REPORT_GOOD;
coin_count_p1 -= amount;
if (coin_count_p1 < 0) {
coin_count_p1 = 0;
}
} else if (slot == 2) {
msg_send[o] = JVS_REPORT_GOOD;
coin_count_p2 -= amount;
if (coin_count_p2 < 0) {
coin_count_p2 = 0;
}
} else {
printf("Invalid coin counter slot\n");
msg_send[o] = JVS_REPORT_PARAMETER_INVALID;
}
o++;
} else if ((msg_length - i) >= 4 && message[i] == 0x35) {
uint8_t slot = message[i+1];
uint16_t amount = (message[i+2] << 8) + message[i+3];
i += 4;
printf("Increment coin counter %d by %d\n", (int)slot, (int)amount);
if (amount > 16383) {
amount = 16383;
printf("Capped to 16383\n");
}
if (slot == 1) {
msg_send[o] = JVS_REPORT_GOOD;
coin_count_p1 += amount;
if (coin_count_p1 > 16383) {
coin_count_p1 = 16383;
}
} else if (slot == 2) {
msg_send[o] = JVS_REPORT_GOOD;
coin_count_p2 += amount;
if (coin_count_p2 > 16383) {
coin_count_p2 = 16383;
}
} else {
printf("Invalid coin counter slot\n");
msg_send[o] = JVS_REPORT_PARAMETER_INVALID;
}
o++;
} else {
printf("Unsupported message: N: %02x L: %02x M: ", node_num, msg_length);
for (int j = 0; j < msg_length; j++) {
printf("%02x", message[j]);
}
printf("\n");
status = JVS_STATUS_UNKNOWN_COMMAND;
break;
}
if (o >= JVS_MAX_LEN) {
printf("JVS response overflow!\n");
status = JVS_STATUS_OVERFLOW;
break;
}
}
if ((o > 0) || (status != JVS_STATUS_GOOD)) {
send_message(status, msg_send, o);
}
} else {
printf("Checksum mismatch: theirs: %02x ours: %02x\n", their_checksum, our_checksum);
status = JVS_STATUS_CHECKSUM_ERROR;
send_message(status, msg_send, 0);
}
} else {
// note because of disabling the rx, we always read a 00 byte after sending here
update_termination(); // convenient time to read adc
//printf("Saw non-sync code %02x\n", sync);
}
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink