From ca7a80a94646bf62a6af11318d2e02964d778627 Mon Sep 17 00:00:00 2001 From: Kevin O'Connor Date: Fri, 17 Aug 2018 21:16:45 -0400 Subject: tmc2208: Initial support for configuring TMC2208 drivers Signed-off-by: Kevin O'Connor --- src/tmcuart.c | 249 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 249 insertions(+) create mode 100644 src/tmcuart.c (limited to 'src/tmcuart.c') diff --git a/src/tmcuart.c b/src/tmcuart.c new file mode 100644 index 00000000..82846b88 --- /dev/null +++ b/src/tmcuart.c @@ -0,0 +1,249 @@ +// Commands for sending messages to a TMC2208 via its single wire UART +// +// Copyright (C) 2018 Kevin O'Connor +// +// This file may be distributed under the terms of the GNU GPLv3 license. + +#include // memcpy +#include "board/gpio.h" // gpio_out_write +#include "board/irq.h" // irq_disable +#include "board/misc.h" // timer_read_time +#include "basecmd.h" // oid_alloc +#include "command.h" // DECL_COMMAND +#include "sched.h" // DECL_SHUTDOWN + +struct tmcuart_s { + struct timer timer; + struct gpio_out tx_pin; + struct gpio_in rx_pin; + uint8_t flags; + uint8_t pos, read_count, write_count; + uint32_t cfg_bit_time, bit_time; + uint8_t data[10]; +}; + +enum { + TU_LINE_HIGH = 1<<0, TU_ACTIVE = 1<<1, TU_READ_SYNC = 1<<2, + TU_REPORT = 1<<3, TU_PULLUP = 1<<4, TU_SINGLE_WIRE = 1<<5 +}; + +static struct task_wake tmcuart_wake; + +// Restore uart line to normal "idle" mode +static void +tmcuart_reset_line(struct tmcuart_s *t) +{ + if (t->flags & TU_SINGLE_WIRE) + gpio_out_reset(t->tx_pin, 1); + else + gpio_out_write(t->tx_pin, 1); + t->flags = (t->flags & (TU_PULLUP | TU_SINGLE_WIRE)) | TU_LINE_HIGH; +} + +// Helper function to end a transmission and schedule a response +static uint_fast8_t +tmcaurt_finalize(struct tmcuart_s *t) +{ + tmcuart_reset_line(t); + t->flags |= TU_REPORT; + sched_wake_task(&tmcuart_wake); + return SF_DONE; +} + +// Event handler for reading uart bits +static uint_fast8_t +tmcuart_read_event(struct timer *timer) +{ + struct tmcuart_s *t = container_of(timer, struct tmcuart_s, timer); + uint8_t v = gpio_in_read(t->rx_pin); + // Read and store bit + uint8_t pos = t->pos, mask = 1 << (pos & 0x07), data = t->data[pos >> 3]; + if (v) + data |= mask; + else + data &= ~mask; + t->data[pos >> 3] = data; + pos++; + if (pos >= t->read_count) + return tmcaurt_finalize(t); + t->pos = pos; + t->timer.waketime += t->bit_time; + return SF_RESCHEDULE; +} + +// Event handler for detecting start of data reception +static uint_fast8_t +tmcuart_read_sync_event(struct timer *timer) +{ + struct tmcuart_s *t = container_of(timer, struct tmcuart_s, timer); + uint8_t v = gpio_in_read(t->rx_pin); + if (v) { + t->flags |= TU_READ_SYNC; + } else if (t->flags & TU_READ_SYNC) { + // Now synchronized - begin reading + t->pos = 0; + t->timer.func = tmcuart_read_event; + return tmcuart_read_event(timer); + } + if (t->pos++ >= 64) { + // Timeout + t->read_count = 0; + return tmcaurt_finalize(t); + } + t->timer.waketime += t->bit_time; + return SF_RESCHEDULE; +} + +// Event handler called at end of uart writing +static uint_fast8_t +tmcuart_send_finish_event(struct timer *timer) +{ + struct tmcuart_s *t = container_of(timer, struct tmcuart_s, timer); + if (!t->read_count) + // This is a tx only operation - success + return tmcaurt_finalize(t); + // Prepare for message rx + if (t->flags & TU_SINGLE_WIRE) + gpio_in_reset(t->rx_pin, t->flags & TU_PULLUP); + t->pos = 0; + t->timer.func = tmcuart_read_sync_event; + t->timer.waketime += t->bit_time * 4; + return SF_RESCHEDULE; +} + +// Event handler for sending uart bits +static uint_fast8_t +tmcuart_send_event(struct timer *timer) +{ + struct tmcuart_s *t = container_of(timer, struct tmcuart_s, timer); + // Toggle uart output + gpio_out_toggle_noirq(t->tx_pin); + t->flags ^= TU_LINE_HIGH; + // Determine next toggle time + uint8_t line_state = t->flags & TU_LINE_HIGH; + uint32_t bit_time = t->bit_time, next = bit_time; + uint8_t pos = t->pos; + for (;;) { + pos++; + if (pos >= t->write_count) { + // No more toggles necessary - schedule finish event + t->timer.func = tmcuart_send_finish_event; + t->timer.waketime += next; + return SF_RESCHEDULE; + } + uint8_t data = t->data[pos >> 3], bit = (data >> (pos & 0x07)) & 0x01; + if (bit != line_state) + break; + next += bit_time; + } + t->pos = pos; + t->timer.waketime += next; + return SF_RESCHEDULE; +} + +// Event handler for sending sync nibble with enhanced baud detection +static uint_fast8_t +tmcuart_send_sync_event(struct timer *timer) +{ + struct tmcuart_s *t = container_of(timer, struct tmcuart_s, timer); + // Toggle uart output and note toggle time + gpio_out_toggle_noirq(t->tx_pin); + uint32_t cur = timer_read_time(); + t->flags ^= TU_LINE_HIGH; + // Determine next wakeup time + t->pos++; + if (t->pos == 1) { + // First bit just sent - record scheduling offset for later use + uint32_t offset = cur - t->timer.waketime; + t->bit_time = offset; + } else if (t->pos >= 5) { + // Last bit of sync nibble just sent - calculate actual baud rate used + uint32_t offset = cur - t->timer.waketime, start_offset = t->bit_time; + int32_t diff = offset - start_offset; + t->bit_time = t->cfg_bit_time + DIV_ROUND_CLOSEST(diff, 4); + t->timer.func = tmcuart_send_event; + t->timer.waketime += diff + t->bit_time; + return SF_RESCHEDULE; + } + t->timer.waketime += t->cfg_bit_time; + return SF_RESCHEDULE; +} + +void +command_config_tmcuart(uint32_t *args) +{ + struct tmcuart_s *t = oid_alloc(args[0], command_config_tmcuart + , sizeof(*t)); + uint8_t pull_up = args[2]; + uint32_t rx_pin = args[1], tx_pin = args[3]; + t->rx_pin = gpio_in_setup(rx_pin, pull_up); + t->tx_pin = gpio_out_setup(tx_pin, 1); + t->cfg_bit_time = args[4]; + t->flags = (TU_LINE_HIGH | (pull_up ? TU_PULLUP : 0) + | (rx_pin == tx_pin ? TU_SINGLE_WIRE : 0)); +} +DECL_COMMAND(command_config_tmcuart, + "config_tmcuart oid=%c rx_pin=%u pull_up=%c" + " tx_pin=%u bit_time=%u"); + +// Parse and schedule a TMC UART transmission request +void +command_tmcuart_send(uint32_t *args) +{ + struct tmcuart_s *t = oid_lookup(args[0], command_config_tmcuart); + if (t->flags & TU_ACTIVE) + // Uart is busy - silently drop this request (host should retransmit) + return; + uint8_t write_len = args[1]; + uint8_t *write = (void*)(size_t)args[2]; + uint8_t read_len = args[3]; + if (write_len > sizeof(t->data) || read_len > sizeof(t->data)) + shutdown("tmcuart data too large"); + memcpy(t->data, write, write_len); + t->pos = 0; + t->flags = (t->flags & (TU_LINE_HIGH|TU_PULLUP|TU_SINGLE_WIRE)) | TU_ACTIVE; + t->write_count = write_len * 8; + t->read_count = read_len * 8; + if (write_len >= 1 && (t->data[0] & 0x3f) == 0x2a) { + t->timer.func = tmcuart_send_sync_event; + } else { + t->bit_time = t->cfg_bit_time; + t->timer.func = tmcuart_send_event; + } + irq_disable(); + t->timer.waketime = timer_read_time() + timer_from_us(200); + sched_add_timer(&t->timer); + irq_enable(); +} +DECL_COMMAND(command_tmcuart_send, "tmcuart_send oid=%c write=%*s read=%c"); + +// Report completed response message back to host +void +tmcuart_task(void) +{ + if (!sched_check_wake(&tmcuart_wake)) + return; + uint8_t oid; + struct tmcuart_s *t; + foreach_oid(oid, t, command_config_tmcuart) { + if (!(t->flags & TU_REPORT)) + continue; + irq_disable(); + t->flags &= ~TU_REPORT; + irq_enable(); + sendf("tmcuart_response oid=%c read=%*s" + , oid, t->read_count / 8, t->data); + } +} +DECL_TASK(tmcuart_task); + +void +tmcuart_shutdown(void) +{ + uint8_t i; + struct tmcuart_s *t; + foreach_oid(i, t, command_config_tmcuart) { + tmcuart_reset_line(t); + } +} +DECL_SHUTDOWN(tmcuart_shutdown); -- cgit v1.2.3-70-g09d2