diff options
| -rw-r--r-- | center_fw/8seg_protocol.c | 61 | ||||
| -rw-r--r-- | center_fw/8seg_protocol.h | 26 | ||||
| -rw-r--r-- | center_fw/Makefile | 2 | ||||
| -rw-r--r-- | center_fw/adc.c | 53 | ||||
| -rw-r--r-- | center_fw/adc.h | 16 | ||||
| -rw-r--r-- | center_fw/global.h | 1 | ||||
| -rw-r--r-- | center_fw/main.c | 91 | ||||
| -rw-r--r-- | center_fw/notes | 10 | ||||
| -rw-r--r-- | center_fw/protocol.c | 101 | ||||
| -rw-r--r-- | center_fw/protocol.h | 8 | ||||
| -rw-r--r-- | center_fw/protocol_test.c | 1 | ||||
| -rw-r--r-- | center_fw/transmit.c | 53 | ||||
| -rw-r--r-- | center_fw/transmit.h | 18 |
13 files changed, 360 insertions, 81 deletions
diff --git a/center_fw/8seg_protocol.c b/center_fw/8seg_protocol.c new file mode 100644 index 0000000..0d0a2eb --- /dev/null +++ b/center_fw/8seg_protocol.c @@ -0,0 +1,61 @@ + +#include "global.h" +#include "adc.h" +#include "transmit.h" +#include "8seg_protocol.h" + +struct cmd_if_struct { + struct command_if_def cmd_if; + int payload_len[PKT_TYPE_MAX]; +}; + +const struct cmd_if_struct cmd_if = {{.packet_type_max=PKT_TYPE_MAX}, { + [PKT_TYPE_RESERVED] = 0, + [PKT_TYPE_SET_OUTPUTS_BINARY] = 1, + [PKT_TYPE_SET_GLOBAL_BRIGHTNESS] = 1, + [PKT_TYPE_SET_OUTPUTS] = 8, + [PKT_TYPE_GET_STATUS] = 0 } +}; + +volatile union { + struct status_tx status_tx; + uint8_t p[0]; +} tx_buf; + +void protocol_init() { + adc_configure_monitor_mode(&cmd_if.cmd_if, 20 /*us*/); + tx_init((uint8_t *)&tx_buf); +} + + +void handle_command(int command, uint8_t *args) { + static int global_brightness = 0xff; + switch (command) { + case PKT_TYPE_SET_OUTPUTS_BINARY: + set_outputs_binary(args[0], global_brightness); + break; + + case PKT_TYPE_SET_GLOBAL_BRIGHTNESS: + global_brightness = args[0]; + break; + + case PKT_TYPE_SET_OUTPUTS: + set_outputs(args); + break; + + case PKT_TYPE_GET_STATUS: + tx_buf.status_tx.temp_tenths_C = adc_data.temp_celsius_tenths; + tx_buf.status_tx.uptime_s = sys_time_seconds; + tx_buf.status_tx.decoding_error_cnt = decoding_error_cnt; + tx_buf.status_tx.protocol_error_cnt = protocol_error_cnt; + tx_buf.status_tx.vcc_mv = adc_data.vcc_mv; + tx_buf.status_tx.vin_mv = adc_data.mean_a_mv; + tx_buf.status_tx.vskew_mv = adc_data.mean_diff_mv; + tx_buf.status_tx.jitter_meas_avg_ns = jitter_meas_avg_ns; + + /* Initialize transmission here, *after* all data has been copied to the buffer */ + tx_transmit(sizeof(tx_buf.status_tx)); + break; + } +} + diff --git a/center_fw/8seg_protocol.h b/center_fw/8seg_protocol.h new file mode 100644 index 0000000..2da42c4 --- /dev/null +++ b/center_fw/8seg_protocol.h @@ -0,0 +1,26 @@ +#ifndef __8SEG_PROTOCOL_H__ +#define __8SEG_PROTOCOL_H__ + +enum packet_type { + PKT_TYPE_RESERVED = 0, + PKT_TYPE_SET_OUTPUTS_BINARY = 1, + PKT_TYPE_SET_GLOBAL_BRIGHTNESS = 2, + PKT_TYPE_SET_OUTPUTS = 3, + PKT_TYPE_GET_STATUS = 4, + PKT_TYPE_MAX +}; + +struct status_tx { + int16_t temp_tenths_C; + uint32_t uptime_s; + uint32_t decoding_error_cnt, protocol_error_cnt; + int16_t vcc_mv, vin_mv, vskew_mv; + uint16_t jitter_meas_avg_ns; +}; + +extern void set_outputs(uint8_t val[8]); +extern void set_outputs_binary(int mask, int global_brightness); + +void protocol_init(void); + +#endif /* __8SEG_PROTOCOL_H__ */ diff --git a/center_fw/Makefile b/center_fw/Makefile index 16cf5c7..2123b18 100644 --- a/center_fw/Makefile +++ b/center_fw/Makefile @@ -76,7 +76,7 @@ sources.tar.xz.zip: sources.tar.xz sources.c: sources.tar.xz.zip xxd -i $< | head -n -1 | sed 's/=/__attribute__((section(".source_tarball"))) =/' > $@ -main.elf: main.o startup_stm32f030x6.o system_stm32f0xx.o $(HAL_PATH)/Src/stm32f0xx_ll_utils.o base.o cmsis_exports.o ../common/8b10b.o adc.o protocol.o +main.elf: main.c startup_stm32f030x6.s system_stm32f0xx.c $(HAL_PATH)/Src/stm32f0xx_ll_utils.c base.c cmsis_exports.c ../common/8b10b.c adc.c protocol.c 8seg_protocol.c transmit.c $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^ $(LIBS) $(OBJCOPY) -O ihex $@ $(@:.elf=.hex) $(OBJCOPY) -O binary $@ $(@:.elf=.bin) diff --git a/center_fw/adc.c b/center_fw/adc.c index eb5d4b5..0fb8251 100644 --- a/center_fw/adc.c +++ b/center_fw/adc.c @@ -78,7 +78,7 @@ void adc_configure_scope_mode(uint8_t channel_mask, int sampling_interval_ns) { } /* Regular operation receiver mode */ -void adc_configure_monitor_mode(struct command_if_def *cmd_if, int ivl_us) { +void adc_configure_monitor_mode(const struct command_if_def *cmd_if, int ivl_us) { /* First, disable trigger timer, DMA and ADC in case we're reconfiguring on the fly. */ TIM1->CR1 &= ~TIM_CR1_CEN; ADC1->CR &= ~ADC_CR_ADSTART; @@ -168,6 +168,11 @@ static void adc_timer_init(int psc, int ivl) { static void gdb_dump(void) { } +/* Called on reception of a bit. This feeds the bit to the 8b10b state machine. When the 8b10b state machine recognizes + * a received symbol, this in turn calls receive_symbol. Since this is called at sampling time roughly halfway into a + * bit being received, receive_symbol is called roughly half-way through the last bit of the symbol, just before the + * symbol's end. + */ void receive_bit(struct bit_detector_st *st, int bit) { int symbol = xfr_8b10b_feed_bit((struct state_8b10b_dec *)&st->rx8b10b, bit); if (symbol == -K28_1) @@ -180,9 +185,9 @@ void receive_bit(struct bit_detector_st *st, int bit) { st->sync = 0; /* Fall through so we also pass the error to receive_symbol */ - GPIOA->BSRR = 1<<9; + GPIOA->BSRR = 1<<9; /* debug */ receive_symbol(&st->rx_st, symbol); - GPIOA->BRR = 1<<9; + GPIOA->BRR = 1<<9; /* debug */ /* Debug scope logic */ /* @@ -205,23 +210,43 @@ void receive_bit(struct bit_detector_st *st, int bit) { */ } +/* From a series of detected line levels, extract discrete bits. This self-synchronizes to signal transitions. This + * expects base_interval_cycles to be set correctly. When a bit is detected, this calls receive_bit(st, bit). The call + * to receive_bit happens at the sampling point about half-way through the bit being received. + */ void bit_detector(struct bit_detector_st *st, int a) { int new_bit = st->last_bit; - int diff = a-5500; + int diff = a-5500; /* FIXME extract constants */ if (diff < - st->hysteresis_mv/2) new_bit = 0; else if (diff > st->hysteresis_mv/2) new_bit = 1; else - blank(); + blank(); /* Safety, in case we get an unexpected transition */ st->len_ctr++; - if (new_bit != st->last_bit) { + if (new_bit != st->last_bit) { /* On transition */ st->last_bit = new_bit; st->len_ctr = 0; - st->committed_len_ctr = st->base_interval_cycles>>1; + st->committed_len_ctr = st->base_interval_cycles>>1; /* Commit first half of bit */ } else if (st->len_ctr >= st->committed_len_ctr) { + /* The line stayed constant for a longer interval than the commited length. Interpret this as a transmitted bit. + * + * +-- Master clock edges -->| - - - - |<-- One bit period + * | | | + * 1 X X X X X X X X + * ____/^^^^*^^^^\_______________________________________/^^^^*^^^^^^^^^*^^^^\__________________________________ + * 0 v ^ v ^ + * | | | | + * | +-------------------------------+ +---------+ + * | | | + * At this point, commit 1/2 bit (until here). This When we arrive at the committed value, commit next + * happens in the block above. full bit as we're now right in the middle of the + * first bit. This happens in the line below. + */ + + /* Commit second half of this and first half of possible next bit */ st->committed_len_ctr += st->base_interval_cycles; receive_bit(st, st->last_bit); } @@ -238,24 +263,28 @@ void DMA1_Channel1_IRQHandler(void) { if (st.adc_mode == ADC_SCOPE) return; + /* FIXME This code section currently is a mess since I left it as soon as it worked. Re-work this and try to get + * back all the useful monitoring stuff, in particular temperature. */ + /* This has been copied from the code examples to section 12.9 ADC>"Temperature sensor and internal reference * voltage" in the reference manual with the extension that we actually measure the supply voltage instead of * hardcoding it. This is not strictly necessary since we're running off a bored little LDO but it's free and * the current supply voltage is a nice health value. */ - // FIXME DEBUG adc_data.adc_vcc_mv = (3300 * VREFINT_CAL)/(st.adc_aggregate[VREF_CH]); + // FIXME DEBUG adc_data.vcc_mv = (3300 * VREFINT_CAL)/(st.adc_aggregate[VREF_CH]); int64_t vcc = 3300; /* FIXME debug - int64_t vcc = adc_data.adc_vcc_mv; + int64_t vcc = adc_data.vcc_mv; int64_t read = st.adc_aggregate[TEMP_CH] * 10 * 10000; int64_t cal = TS_CAL1 * 10 * 10000; - adc_data.adc_temp_celsius_tenths = 300 + ((read/4096 * vcc) - (cal/4096 * 3300))/43000; + adc_data.temp_celsius_tenths = 300 + ((read/4096 * vcc) - (cal/4096 * 3300))/43000; */ + /* Calculate the line voltage from the measured ADC voltage and the used resistive divider ratio */ const long vmeas_r_total = VMEAS_R_HIGH + VMEAS_R_LOW; - //int a = adc_data.adc_vmeas_a_mv = (st.adc_aggregate[VMEAS_A]*(vmeas_r_total * vcc / VMEAS_R_LOW)) >> 12; - int a = adc_data.adc_vmeas_a_mv = (adc_buf[VMEAS_A]*13300) >> 12; + //int a = adc_data.vmeas_a_mv = (st.adc_aggregate[VMEAS_A]*(vmeas_r_total * vcc / VMEAS_R_LOW)) >> 12; + int a = adc_data.vmeas_a_mv = (adc_buf[VMEAS_A]*13300) >> 12; bit_detector((struct bit_detector_st *)&st.det_st, a); /* ISR timing measurement for debugging */ diff --git a/center_fw/adc.h b/center_fw/adc.h index a3e9d53..105fde5 100644 --- a/center_fw/adc.h +++ b/center_fw/adc.h @@ -23,13 +23,13 @@ #include "protocol.h" struct adc_measurements { - int16_t adc_vcc_mv; - int16_t adc_temp_celsius_tenths; - int16_t adc_vmeas_a_mv; - int16_t adc_vmeas_b_mv; - int16_t adc_mean_a_mv; - int16_t adc_mean_b_mv; - int16_t adc_mean_diff_mv; + int16_t vcc_mv; + int16_t temp_celsius_tenths; + int16_t vmeas_a_mv; + int16_t vmeas_b_mv; + int16_t mean_a_mv; + int16_t mean_b_mv; + int16_t mean_diff_mv; }; enum channel_mask { @@ -85,7 +85,7 @@ extern volatile struct adc_measurements adc_data; void adc_init(void); void adc_configure_scope_mode(uint8_t channel_mask, int sampling_interval_ns); -void adc_configure_monitor_mode(struct command_if_def *cmd_if, int ivl_us); +void adc_configure_monitor_mode(const struct command_if_def *cmd_if, int ivl_us); void bit_detector(struct bit_detector_st *st, int a); void receive_bit(struct bit_detector_st *st, int bit); diff --git a/center_fw/global.h b/center_fw/global.h index 15a5e87..413c22b 100644 --- a/center_fw/global.h +++ b/center_fw/global.h @@ -47,5 +47,6 @@ extern volatile unsigned int sys_time; extern volatile unsigned int sys_time_seconds; +extern uint16_t jitter_meas_avg_ns; #endif/*__GLOBAL_H__*/ diff --git a/center_fw/main.c b/center_fw/main.c index 2340ecb..a2c6eaa 100644 --- a/center_fw/main.c +++ b/center_fw/main.c @@ -18,36 +18,20 @@ #include "global.h" #include "adc.h" +#include "8seg_protocol.h" +#include "transmit.h" volatile unsigned int sys_time = 0; volatile unsigned int sys_time_seconds = 0; +uint16_t jitter_meas_avg_ns = 0; void TIM1_BRK_UP_TRG_COM_Handler() { TIM1->SR &= ~TIM_SR_UIF_Msk; } -enum packet_type { - PKT_TYPE_RESERVED = 0, - PKT_TYPE_SET_OUTPUTS_BINARY = 1, - PKT_TYPE_SET_GLOBAL_BRIGHTNESS = 2, - PKT_TYPE_SET_OUTPUTS = 3, - PKT_TYPE_MAX -}; - -struct { - struct command_if_def cmd_if; - int payload_len[PKT_TYPE_MAX]; -} cmd_if = {{.packet_type_max=PKT_TYPE_MAX}, { - [PKT_TYPE_RESERVED] = 0, - [PKT_TYPE_SET_OUTPUTS_BINARY] = 1, - [PKT_TYPE_SET_GLOBAL_BRIGHTNESS] = 1, - [PKT_TYPE_SET_OUTPUTS] = 8 } -}; - void set_drv_gpios(uint8_t val) { int a=!!(val&1), b=!!(val&2), c=!!(val&4), d=!!(val&8); - GPIOA->ODR &= ~(!a<<3 | !b<<7 | c<<6 | d<<4); - GPIOA->ODR |= a<<3 | b<<7 | !c<<6 | !d<<4; + GPIOA->BSRR = ((!a<<3 | !b<<7 | c<<6 | d<<4)<<16) | (a<<3 | b<<7 | !c<<6 | !d<<4); } uint8_t out_state = 0x01; @@ -67,44 +51,39 @@ void set_outputs_binary(int mask, int global_brightness) { set_outputs(val); } +void set_load(bool load) { + GPIOA->BSRR = (1<<2) << (load ? 0 : 16); +} + void blank(void) { set_drv_gpios(0); } volatile int bit; /* FIXME */ void unblank_low(void) { - if (bit) - set_drv_gpios(out_state & 0xf); - else - set_drv_gpios(out_state >> 4); + if (backchannel_frame) { /* Set from protocol.c */ + if (tx_next_bit() == 1) + set_load(1); + else /* 0; but also TX_IDLE */ + set_load(0); + + } else { + if (bit) + set_drv_gpios(out_state & 0xf); + else + set_drv_gpios(out_state >> 4); + } } void TIM3_IRQHandler(void) { - GPIOA->BSRR = 1<<10; + GPIOA->BSRR = 1<<10; /* debug */ if (TIM3->SR & TIM_SR_UIF) unblank_low(); else blank(); TIM3->SR = 0; - GPIOA->BRR = 1<<10; -} - -void handle_command(int command, uint8_t *args) { - static int global_brightness = 0xff; - switch (command) { - case PKT_TYPE_SET_OUTPUTS_BINARY: - set_outputs_binary(args[0], global_brightness); - break; - - case PKT_TYPE_SET_GLOBAL_BRIGHTNESS: - global_brightness = args[0]; - break; - - case PKT_TYPE_SET_OUTPUTS: - set_outputs(args); - break; - } + GPIOA->BRR = 1<<10; /* debug */ } int main(void) { @@ -127,9 +106,9 @@ int main(void) { TIM3->CCMR2 = (6<<TIM_CCMR2_OC4M_Pos); /* PWM Mode 1 to get a clean trigger signal */ TIM3->CCER = TIM_CCER_CC4E; /* Enable capture/compare unit 4 connected to ADC */ - TIM3->PSC = 48-1; - TIM3->CCR4 = 170-1; - TIM3->ARR = 200-1; + TIM3->PSC = 48-1; /* 48MHz -> 1MHz */ + TIM3->CCR4 = 170-1; /* CC4 is ADC trigger, fire 30us before end of cycle. */ + TIM3->ARR = 200-1; /* 1MHz -> 5kHz */ TIM3->DIER |= TIM_DIER_UIE | TIM_DIER_CC4IE; @@ -159,14 +138,28 @@ int main(void) { set_drv_gpios(0); - adc_configure_monitor_mode(&cmd_if.cmd_if, 20 /*us*/); + protocol_init(); + uint32_t jitter_meas_sum = 0, jitter_meas_cnt = 0; while (42) { - int new = GPIOA->IDR & (1<<0); - if (new != bit) { + int new = GPIOA->IDR & (1<<0); /* Sample current polarity */ + if (new != bit) { /* Zero-crossing detected */ bit = new; + + /* Store old counter value for jitter measurement. Let it overflow to handle negative offsets. */ + int16_t cnt = (int16_t)TIM3->CNT; + /* Re-initialize the counter to align it with the signal edge */ TIM3->EGR |= TIM_EGR_UG; + /* Unblank since the update interrupt will not fire this time */ unblank_low(); + + /* Don't handle overflow of _sum here since this value is only for monitoring anyway */ + jitter_meas_sum += (cnt >= 0) ? cnt : -cnt; + if (++jitter_meas_cnt == 4000) { /* One measurement roughly every 800ms */ + /* Divide aggregate over 4000 us-resolution measurements by 4 -> ns-resolution average */ + uint32_t divided = jitter_meas_sum>>2; + jitter_meas_avg_ns = (divided < UINT16_MAX) ? divided : UINT16_MAX; + } } /* idle */ } diff --git a/center_fw/notes b/center_fw/notes new file mode 100644 index 0000000..99a8b2a --- /dev/null +++ b/center_fw/notes @@ -0,0 +1,10 @@ +Pink led strip details: +at Vcc = 11.88V, the voltage across the 68R dropper resistor is 2.06V. +Thus, I is 30mA, the forward voltage of the LEDs is 9.82V/3 = 3.27V. +A single group of 3 LEDs dissipates 0.36W. At 60LEDs/m that's 7.2W/m. + +We loose 50% brightness due to the 2:1 AC multiplexing and another ~15% due to the generous blanking periods. To make up +for that we need to scale the current by a factor of 2.35. This can be done by increasing VCC from 12.0V to about 14.5V. +Assuming the multiplexing doesn't stop that's not a problem as the power dissipation of the LEDs and dropper resistors +will remain the same as before. We need a safety cutoff in the circle firmware for that though so the LED tape doesn't +burn up if something crashes (FIXME). diff --git a/center_fw/protocol.c b/center_fw/protocol.c index 87d46e4..dfa0d3e 100644 --- a/center_fw/protocol.c +++ b/center_fw/protocol.c @@ -1,59 +1,142 @@ +/* Control protocol receiver sitting between 8b10b.c and logical protocol handlers */ #include <unistd.h> #include "protocol.h" #include "8b10b.h" -void reset_receiver(struct proto_rx_st *st, struct command_if_def *cmd_if) { +volatile uint32_t decoding_error_cnt = 0, protocol_error_cnt = 0; +volatile bool backchannel_frame = 0; + +/* Reset the given protocol state and register the command definition given with it. */ +void reset_receiver(struct proto_rx_st *st, const struct command_if_def *cmd_if) { st->rxpos = -1; st->address = 5; /* FIXME debug code */ st->cmd_if = cmd_if; } +/* Receive an 8b10b symbol using the given protocol state. Handle any packets matching the enclosed command definition. + * + * This method is called from adc.c during the last bit period of the symbol, just before the actual end of the symbol + * and start of the next symbol. + */ void receive_symbol(struct proto_rx_st *st, int symbol) { + + if (symbol == -K28_2) { /* Backchannel marker */ + /* This symbol is inserted into the symbol stream at regular intervals. It is not passed to the higher protocol + * layers but synchronizes the backchannel logic through all nodes. The backchannel works by a node putting a + * specified additional load of about 100mA (FIXME) on the line (1) or not (0) with all other nodes being + * silent. The master can detect this additional current. The backchannel is synchronized to the 8b10b frame + * being sent from the master, and the data is also 8b10b encoded. This means the backchannel is independent + * from the forward-channel. + * + * This means while the forward-channel (the line voltage) might go like the upper trace, the back-channel (the + * line current drawn by the node) might simultaneously look like the lower trace: + * + * Zoomed in on two master frames: + * + * |<--- D31.1 --->| |<--- D03.6 --->| + * Master -> Node 1 0 1 0 1 1 1 0 0 1 1 1 0 0 0 1 0 1 1 0 + * Voltage (V) .../^^\__/^^\__/^^^^^^^^\_____/^^^^^^^^\________/^^\__/^^^^^\___... + * + * Current (I) ...\_____________________________/^^^^^V^^^^^^^^V^^V^^V^^^^^V^^\... + * Node -> Master 0 1 + * + * + * Zoomed out on two node frames, or twenty master frames: + * + * Master -> Node | | | | | | | | | | | | | | | | | | |<- symbols, one after another + * Voltage (V) ...XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX... + * + * Current (I) ...___/^^^^^\__/^^\_____/^^\__/^^^^^\_____/^^\__/^^^^^\__/^^\___... + * Node -> Master 0 1 1 0 1 0 0 1 0 1 1 0 0 1 0 1 1 0 1 0 + * |<--- D22.2 --->| |<--- D09.5 --->| + * + * Note that during backchannel transmissions only one node transmits at a time, and all nodes including the + * transmitter keep their LEDs blanked to allow the master to more easily demodulate the transmission. + * + * This means that: + * * backchannel transmissions should be sparse (one per several regular symbols) to not affect brightness + * too much + * * backchannel transmissions should be spaced-out evenly and frequent enough to not cause visible flicker + * + * A consequence of this is that the backchannel has a bandwidth of only a fraction of the forward-channel. The + * master can dynamically adjust the frequency of the forward-channel and spacing of the backchannel markers. + * For 5kHz and 10% backchannel data (every tenth symbol being a backchannel symbol) the bandwidth works out to: + * + * BW(forward-channel) = 5 [kHz] / 10 [8b10b] = 500 byte/s + * BW(backchannel) = 5 [kHz] / 10 [8b10b] / 10 [every 10th symbol] / 10 [8b10b again] = 5 byte/s + * + * Luckily, we only use the backchannel for monitoring anyway and at ~20byte per monitoring frame we can easily + * monitor a bus-load (heh!) of nodes once a minute, which is enough for our purposes. + */ + + /* Blank the LEDs for the next frame to keep the bus quiet during backchannel transmission. This happens on all + * nodes. */ + backchannel_frame = true; + return; /* We're done handling this symbol */ + } else { + /* On anything else than a backchannel marker, turn off backchannel blanking for the next frame */ + backchannel_frame = false; + } + if (symbol == -K28_1) { /* Comma/frame delimiter */ st->rxpos = 0; /* Fall through and return and just ignore incomplete packets */ } else if (symbol == -DECODING_ERROR) { + if (decoding_error_cnt < UINT32_MAX) + decoding_error_cnt++; goto reset; - } else if (symbol < 0) { /* Unknown comma symbol or error */ + } else if (symbol < 0) { /* Unknown comma symbol */ + if (protocol_error_cnt < UINT32_MAX) + protocol_error_cnt++; goto reset; - } else if (st->rxpos == -1) { + } else if (st->rxpos == -1) { /* Receiver freshly reset and no comma seen yet */ return; } else if (st->rxpos == 0) { /* First data symbol, and not an error or comma symbol */ st->packet_type = symbol & ~PKT_TYPE_BULK_FLAG; if (st->packet_type >= st->cmd_if->packet_type_max) - goto reset; + goto reset; /* Not a protocol error */ + /* If this a bulk packet, calculate and store the offset of our portion of it. Otherwise just prime the state + * for receiving the indidual packet by setting the offset to the first packet byte after the address. */ int payload_len = st->cmd_if->payload_len[st->packet_type]; st->is_bulk = symbol & PKT_TYPE_BULK_FLAG; st->offset = (st->is_bulk) ? (st->address*payload_len + 1) : 2; st->rxpos++; if (payload_len == 0 && st->is_bulk) { + /* Length-0 packet type, handle now for bulk packets as we don't know when the master will send the next + * comma or other symbol. For individually addressed packets, wait for the address byte. */ handle_command(st->packet_type, NULL); goto reset; } - } else if (!st->is_bulk && st->rxpos == 1) { - if (symbol != st->address) + } else if (!st->is_bulk && st->rxpos == 1) { /* First byte (address byte) of individually adressed packet */ + if (symbol != st->address) /* A different node is adressed */ goto reset; if (st->cmd_if->payload_len[st->packet_type] == 0) { + /* Length-0 packet type, handle now as we don't know when the master will send the next comma or other + * symbol. */ handle_command(st->packet_type, NULL); goto reset; } - st->rxpos = 2; + st->rxpos++; - } else { - if (st->rxpos - st->offset >= 0) + } else { /* Receiving packet body */ + if (st->rxpos - st->offset >= 0) { + /* Either we're receiving an individually adressed packet adressed to us, or we're in the middle of a bulk + * packet at our offset */ st->argbuf[st->rxpos - st->offset] = symbol; + } st->rxpos++; if (st->rxpos - st->offset == st->cmd_if->payload_len[st->packet_type]) { + /* We're at the end of either an individual packet or our portion of a bulk packet. Handle packet here. */ handle_command(st->packet_type, (uint8_t *)st->argbuf); goto reset; } diff --git a/center_fw/protocol.h b/center_fw/protocol.h index 9178c42..89c93e2 100644 --- a/center_fw/protocol.h +++ b/center_fw/protocol.h @@ -2,6 +2,7 @@ #define __PROTOCOL_H__ #include <stdint.h> +#include <stdbool.h> #define PKT_TYPE_BULK_FLAG 0x80 @@ -12,7 +13,7 @@ struct proto_rx_st { int address; uint8_t argbuf[8]; int offset; - struct command_if_def *cmd_if; + const struct command_if_def *cmd_if; }; struct command_if_def { @@ -20,10 +21,13 @@ struct command_if_def { int payload_len[0]; }; +extern volatile uint32_t decoding_error_cnt, protocol_error_cnt; +extern volatile bool backchannel_frame; + /* Callback */ void handle_command(int command, uint8_t *args); void receive_symbol(struct proto_rx_st *st, int symbol); -void reset_receiver(struct proto_rx_st *st, struct command_if_def *cmd_if); +void reset_receiver(struct proto_rx_st *st, const struct command_if_def *cmd_if); #endif diff --git a/center_fw/protocol_test.c b/center_fw/protocol_test.c index d417a1b..4a12ef5 100644 --- a/center_fw/protocol_test.c +++ b/center_fw/protocol_test.c @@ -1,3 +1,4 @@ +/* Unit test file testing protocol.c */ #include <string.h> #include <assert.h> diff --git a/center_fw/transmit.c b/center_fw/transmit.c new file mode 100644 index 0000000..c31c833 --- /dev/null +++ b/center_fw/transmit.c @@ -0,0 +1,53 @@ + +#include "global.h" +#include "transmit.h" +#include "8b10b.h" + +struct { + uint8_t *buf; + size_t pos, len; + uint16_t current_symbol; + struct state_8b10b_enc enc; +} tx_state = {0}; + +volatile uint32_t tx_overflow_cnt = 0; + +void tx_init(uint8_t *tx_buf) { + tx_state.buf = tx_buf; + tx_state.pos = 0; + tx_state.current_symbol = 0; + xfr_8b10b_encode_reset(&tx_state.enc); +} + +int tx_transmit(size_t len) { + if (!tx_state.buf) + return TX_ERR_UNINITIALIZED; + + if (tx_state.len) { + tx_overflow_cnt++; + return TX_ERR_BUSY; + } + + tx_state.len = len; + tx_state.current_symbol = 1; + return 0; +} + +int tx_next_bit() { + if (!tx_state.len) + return TX_IDLE; + + int sym = tx_state.current_symbol; + if (sym == 1) /* We're transmitting the first bit of a new frame now. */ + sym = xfr_8b10b_encode(&tx_state.enc, tx_state.buf[tx_state.pos++]) | (1<<10); + + int bit = sym&1; + sym >>= 1; + + if (sym == 1 && tx_state.pos == tx_state.len) + /* We're transmitting the last bit of a transmission now. Reset state. */ + tx_state.pos = tx_state.len = sym = 0; + + tx_state.current_symbol = sym; + return bit; +} diff --git a/center_fw/transmit.h b/center_fw/transmit.h new file mode 100644 index 0000000..dd9bcb9 --- /dev/null +++ b/center_fw/transmit.h @@ -0,0 +1,18 @@ +#ifndef __TRANSMIT_H__ +#define __TRANSMIT_H__ + +#include "global.h" +#include "8b10b.h" + +#define TX_IDLE (-1) + +#define TX_ERR_BUSY -1 +#define TX_ERR_UNINITIALIZED -2 + +extern volatile uint32_t tx_overflow_cnt; + +void tx_init(uint8_t *tx_buf); +int tx_transmit(size_t len); +int tx_next_bit(void); + +#endif /* __TRANSMIT_H__ */ |