A little trick I just learned today. First, the scenario.
I have a driver for a USART port, the USART on the ATMega32U4 in fact. It uses a FIFO interface to represent the incoming and outgoing data.
I have a library that also uses a FIFO to represent the data to be sent and received on a USART.
I have an application that will configure the USART and pipe between that and the library.
Now, I could have each component implement its own FIFOs, and have the main application shovel data between them. That could work. But I don’t want to do this. I could have the user pass in a pointer to the FIFOs in initialisation functions for the USART driver and the library, but I don’t want to store the extra pointers or incur the additional overheads.
Turns out, you can define a symbol somewhere, then alias it to make two variables appear in the same place. This is done with the alias attribute, and it requires that the target is defined with the nocommon attribute.
In the USART driver, I’ve simply declared the FIFOs as extern entities. This tells the C compiler what to expect in terms of data type but does not define a location in memory. Within the driver, use the symbols as normal.
/* usart.h */
/*! FIFO buffer for USART receive data */
extern struct fifo_t usart_fifo_rx;
/*! FIFO buffer for USART transmit data */
extern struct fifo_t usart_fifo_tx;
/* usart.c */
static void usart_send_next() {
/* Ready to send next byte */
int16_t byte = fifo_read_one(&usart_fifo_tx);
if (byte >= 0)
UDR1 = byte;
}
ISR(USART1_RX_vect) {
fifo_write_one(&usart_fifo_rx, UDR1);
}
I can do the same for the protocol library.
/* External FIFO to host UART */ extern struct fifo_t proto_host_uart_rx, proto_host_uart_tx; /*! External FIFO to target UART */ extern struct fifo_t proto_target_uart_rx, proto_target_uart_tx;
Now how do I link the two? They go by different names. I create aliases, that’s how.
/*
* FIFO buffers for target communications.
*/
static struct fifo_t target_fifo_rx __attribute__((nocommon));
static uint8_t target_fifo_rx_buffer[128];
extern struct fifo_t usart_fifo_rx __attribute__((alias ("target_fifo_rx")));
extern struct fifo_t proto_target_uart_rx __attribute__((alias ("target_fifo_rx")));
static struct fifo_t target_fifo_tx __attribute__((nocommon));
static uint8_t target_fifo_tx_buffer[128];
extern struct fifo_t usart_fifo_tx __attribute__((alias ("target_fifo_tx")));
extern struct fifo_t proto_target_uart_tx __attribute__((alias ("target_fifo_tx")));
/*
* FIFO buffers for host communications.
*/
static struct fifo_t host_fifo_rx __attribute__((nocommon));
static uint8_t host_fifo_rx_buffer[128];
extern struct fifo_t proto_host_uart_rx __attribute__((alias ("host_fifo_rx")));
static struct fifo_t host_fifo_tx __attribute__((nocommon));
static uint8_t host_fifo_tx_buffer[128];
extern struct fifo_t proto_host_uart_tx __attribute__((alias ("host_fifo_tx")));
Now a quick check with nm should reveal these to all be at the same locations:
RC=0 stuartl@vk4msl-mb ~/projects/debugwire/firmware $ avr-nm leodebug.elf \
| grep '\(proto_.*_uart_.x\|host_fifo_.x\|target_fifo_.x\)'
0080022c b host_fifo_rx
008001ac b host_fifo_rx_buffer
0080019c b host_fifo_tx
0080011c b host_fifo_tx_buffer
0080022c B proto_host_uart_rx
0080019c B proto_host_uart_tx
0080034c B proto_target_uart_rx
008002bc B proto_target_uart_tx
0080034c b target_fifo_rx
008002cc b target_fifo_rx_buffer
008002bc b target_fifo_tx
0080023c b target_fifo_tx_buffer
Recent Comments