Proof of concept for a radio transmitter

This commit is contained in:
Savanni D'Gerinel 2022-07-02 17:54:19 -04:00
parent 3ec18f464e
commit 576ad4089e
9 changed files with 431 additions and 197 deletions

View File

@ -14,6 +14,7 @@ You should have received a copy of the GNU General Public License along with Lum
#include <display.h>
#include <util/delay.h>
#include <base.h>
#include <stdio.h>
#define ENABLE _BV(5)
#define CHARCODE _BV(4)
@ -111,3 +112,15 @@ void display_write_message(display_t *disp, const char *msg) {
}
}
void display_write_bit_pattern(display_t *disp, const uint8_t pattern) {
char msg[16];
sprintf(msg, "* ");
for (int i = 7; i >= 0; i--) {
if (pattern & _BV(i)) {
display_write_message(disp, "1");
} else {
display_write_message(disp, "0");
}
}
}

View File

@ -45,6 +45,7 @@ Lumeto. If not, see <https://www.gnu.org/licenses/>.
#define __DISPLAY_H__
#include <shift_register.h>
#include <stddef.h>
typedef struct DISPLAY {
shift_register_t reg;
@ -64,5 +65,7 @@ void display_set_location(display_t *, size_t, size_t);
void display_write_message(display_t *, const char *);
void display_write_bit_pattern(display_t *, const uint8_t);
#endif

View File

@ -37,16 +37,16 @@
'';
};
packages."x86_64-linux"."morse-tx" =
packages."x86_64-linux"."prime-tx" =
let
pkgs = import nixpkgs { system = "x86_64-linux"; };
lib = pkgs.lib;
avr = pkgs.pkgsCross.avr.buildPackages;
in pkgs.stdenv.mkDerivation rec {
name = "morse-tx";
name = "prime-tx";
src = ./.;
includes = [ "base" "spi" "morse" "rfm69hcw" ];
includes = [ "base" "spi" "shift_register" "rfm69hcw" "display" ];
MCU = "atmega32u4";
CHIP_SELECT = "AVR_ATmega32u4";
@ -57,9 +57,10 @@
buildPhase = ''
${avr.gcc}/bin/avr-gcc ${CFLAGS} ${INCLUDE_DIRS} -o rfm.o -c ${src}/rfm69hcw/rfm.c
${avr.gcc}/bin/avr-gcc ${CFLAGS} ${INCLUDE_DIRS} -o spi.o -c ${src}/spi/spi.c
${avr.gcc}/bin/avr-gcc ${CFLAGS} ${INCLUDE_DIRS} -o morse.o -c ${src}/morse/morse.c
${avr.gcc}/bin/avr-gcc ${CFLAGS} ${INCLUDE_DIRS} -o main.o -c ${src}/morse_tx/main.c
${avr.gcc}/bin/avr-gcc ${CFLAGS} -o main.elf main.o morse.o spi.o rfm.o
${avr.gcc}/bin/avr-gcc ${CFLAGS} ${INCLUDE_DIRS} -o reg.o -c ${src}/shift_register/shift_register.c
${avr.gcc}/bin/avr-gcc ${CFLAGS} ${INCLUDE_DIRS} -o display.o -c ${src}/display/display.c
${avr.gcc}/bin/avr-gcc ${CFLAGS} ${INCLUDE_DIRS} -o main.o -c ${src}/prime-tx/main.c
${avr.gcc}/bin/avr-gcc ${CFLAGS} -o main.elf main.o display.o spi.o rfm.o reg.o
$OBJCOPY -O ihex main.elf main.hex
'';
installPhase = ''

View File

@ -1,139 +0,0 @@
#include <avr/io.h>
#include <util/delay.h>
#include <base.h>
#include <spi.h>
#include <rfm.h>
// typedef struct RFM {
// spi_t spi;
// gpio_t irq;
// gpio_t reset;
// } rfm_t;
//
// void rfm_initialize(rfm_t *rfm) {
// spi_initialize(&rfm->spi);
//
// spi_acquire(&rfm->spi);
// spi_transfer_byte(&rfm->spi, 0x37 | _BV(7));
// spi_transfer_byte(&rfm->spi, 0);
// spi_release(&rfm->spi);
//
// spi_acquire(&rfm->spi);
// spi_transfer_byte(&rfm->spi, 0x38 | _BV(7));
// spi_transfer_byte(&rfm->spi, 1);
// spi_release(&rfm->spi);
// }
//
// void rfm_power_off(rfm_t *rfm) {
// spi_acquire(&rfm->spi);
// spi_transfer_byte(&rfm->spi, 0x11);
// spi_transfer_byte(&rfm->spi, 0x00);
// spi_release(&rfm->spi);
// }
//
// void rfm_send_data(rfm_t *rfm, uint8_t *data, size_t length) {
// /* Go into standby mode */
// spi_acquire(&rfm->spi);
// spi_transfer_byte(&rfm->spi, 0x11);
// spi_transfer_byte(&rfm->spi, 0x01);
// spi_release(&rfm->spi);
//
// /* Write data to FIFO */
// spi_acquire(&rfm->spi);
// spi_transfer_byte(&rfm->spi, 0x10);
// for (size_t i = 0; i < length; i++) {
// spi_transfer_byte(&rfm->spi, data[i]);
// }
// spi_release(&rfm->spi);
//
// /* Go into transmit mode */
// spi_acquire(&rfm->spi);
// spi_transfer_byte(&rfm->spi, 0x11);
// spi_transfer_byte(&rfm->spi, 0x03);
// spi_release(&rfm->spi);
//
// /* Return to standby mode */
// spi_acquire(&rfm->spi);
// spi_transfer_byte(&rfm->spi, 0x11);
// spi_transfer_byte(&rfm->spi, 0x01);
// spi_release(&rfm->spi);
// }
void flash(gpio_t *light, size_t count) {
for (size_t i = 0; i < count; i++) {
set_line(light);
_delay_ms(50);
clear_line(light);
_delay_ms(50);
}
}
int main(void) {
spi_t spi = (spi_t){
.clock = { .ddr = &DDRB, .port = &PORTB, .pin = &PINB, .addr = 1 },
.data_out = { .ddr = &DDRB, .port = &PORTB, .pin = &PINB, .addr = 2 },
.data_in = { .ddr = &DDRB, .port = &PORTB, .pin = &PINB, .addr = 3 },
.chip_select = { .ddr = &DDRB, .port = &PORTB, .pin = &PINB, .addr = 4 },
};
rfm_t rfm = (rfm_t){
.spi = spi,
.irq = { .ddr = &DDRE, .port = &PORTE, .pin = &PINE, .addr = 6 },
.reset = { .ddr = &DDRD, .port = &PORTD, .pin = &PIND, .addr = 4 },
};
gpio_t light = { .ddr = &DDRC, .port = &PORTC, .addr = 7 };
gpio_t fifo_full = { .ddr = &DDRB, .port = &PORTB, .addr = 7 };
gpio_t fifo_empty = { .ddr = &DDRB, .port = &PORTB, .addr = 6 };
set_line_direction(&light, LINE_OUT);
set_line_direction(&fifo_full, LINE_OUT);
set_line_direction(&fifo_empty, LINE_OUT);
flash(&light, 3);
rfm_initialize(&rfm);
set_line(&light);
uint8_t status = rfm_status(&rfm);
status & _BV(7) ? set_line(&fifo_full) : clear_line(&fifo_full);
status & _BV(6) ? set_line(&fifo_empty) : clear_line(&fifo_empty);
/*
spi_acquire(&rfm.spi);
spi_transfer_byte(&rfm.spi, 0x11);
spi_transfer_byte(&rfm.spi, 0x01);
spi_release(&rfm.spi);
spi_acquire(&rfm.spi);
spi_transfer_byte(&rfm.spi, 0x10);
spi_transfer_byte(&rfm.spi, 1);
spi_transfer_byte(&rfm.spi, 2);
spi_transfer_byte(&rfm.spi, 3);
spi_transfer_byte(&rfm.spi, 5);
spi_transfer_byte(&rfm.spi, 7);
spi_transfer_byte(&rfm.spi, 11);
spi_transfer_byte(&rfm.spi, 13);
spi_release(&rfm.spi);
status = rfm_status(&rfm);
if (status & _BV(7)) {
clear_line(&light);
} else {
set_line(&light);
}
*/
/*
uint8_t count[1] = { 0 };
while(1) {
rfm_send_data(&rfm, count, 1);
count[0]++;
set_line(&light);
_delay_ms(50);
clear_line(&light);
_delay_ms(50);
}
*/
return 0;
}

188
prime-tx/main.c Normal file
View File

@ -0,0 +1,188 @@
#include <avr/io.h>
#include <base.h>
#include <display.h>
#include <rfm.h>
#include <spi.h>
#include <stdio.h>
#include <util/delay.h>
void status(display_t *display, rfm_t *radio) {
op_mode_t mode = rfm_mode(radio);
interrupt_flags_t flags = rfm_interrupts(radio);
display_clear(display);
if (mode.listen_on) display_write_message(display, "Listen ");
if (mode.mode == sleep) display_write_message(display, "Sleep");
if (mode.mode == standby) display_write_message(display, "Standby");
if (mode.mode == fs) display_write_message(display, "FS");
if (mode.mode == tx) display_write_message(display, "TX");
if (mode.mode == rx) display_write_message(display, "RX");
display_set_location(display, 1, 0);
if (flags.mode_ready) display_write_message(display, "R ");
if (flags.rx_ready) display_write_message(display, "RX ");
if (flags.tx_ready) display_write_message(display, "TX ");
if (flags.timeout) display_write_message(display, "TO ");
if (flags.auto_mode) display_write_message(display, "AM ");
if (flags.sync_addr_match) display_write_message(display, "SM ");
if (flags.fifo_full) display_write_message(display, "F ");
if (flags.fifo_not_empty) display_write_message(display, "NE ");
if (flags.fifo_level) display_write_message(display, "LE ");
if (flags.fifo_overrun) display_write_message(display, "OR ");
if (flags.packet_sent) display_write_message(display, "PS ");
if (flags.payload_ready) display_write_message(display, "PR");
if (flags.crc_ok) display_write_message(display, "CRC");
}
int main(void) {
display_t display = {
.reg = {
.output = { .ddr = &DDRB, .port = &PORTB, .pin = &PINB, .addr = 7 },
.shift_clock = { .ddr = &DDRB, .port = &PORTB, .pin = &PINB, .addr = 6 },
.latch_clock = { .ddr = &DDRB, .port = &PORTB, .pin = &PINB, .addr = 5 },
},
};
rfm_t radio = (rfm_t){
.spi = {
.clock = { .ddr = &DDRB, .port = &PORTB, .pin = &PINB, .addr = 1 },
.data_out = { .ddr = &DDRB, .port = &PORTB, .pin = &PINB, .addr = 2 },
.data_in = { .ddr = &DDRB, .port = &PORTB, .pin = &PINB, .addr = 3 },
.chip_select = { .ddr = &DDRB, .port = &PORTB, .pin = &PINB, .addr = 4 },
},
.irq = { .ddr = &DDRE, .port = &PORTE, .pin = &PINE, .addr = 6 },
.reset = { .ddr = &DDRD, .port = &PORTD, .pin = &PIND, .addr = 4 },
};
_delay_ms(15);
display_init(&display);
rfm_error_e error;
rfm_init(&radio, (uint8_t [4]){ 0xde, 0xca, 0xfb, 0xad }, 4, &error);
status(&display, &radio);
_delay_ms(1000);
rfm_transmit(&radio, (uint8_t [7]){ 1, 2, 3, 5, 7, 11, 13 }, 7);
status(&display, &radio);
while (1) {
_delay_ms(1000);
status(&display, &radio);
interrupt_flags_t flags = rfm_interrupts(&radio);
if (flags.packet_sent) {
rfm_standby(&radio);
}
}
/*
*/
/*
if (!error) {
display_clear(&display);
display_write_message(&display, "Error detected");
} else {
while (1) {
status(&display, &radio);
_delay_ms(1000);
rfm_receive_mode(&radio);
status(&display, &radio);
_delay_ms(1000);
rfm_standby(&radio);
}
}
*/
/*
status(&display, &radio);
_delay_ms(1000);
rfm_set_mode(&display, &radio, (op_mode_t){ .listen_on = true, .mode = standby });
_delay_ms(1000);
rfm_set_mode(&display, &radio, (op_mode_t){ .listen_on = true, .mode = standby });
_delay_ms(1000);
*/
/*
rfm_packet_format(&radio, fixed, 8);
rfm_set_mode(&display, &radio, (op_mode_t){ .listen_on = false, .mode = rx });
_delay_ms(1000);
status(&display, &radio);
*/
/*
while (1) {
status(&display, &radio);
_delay_ms(1000);
uint8_t data;
rfm_receive(rfm, &data, 1);
*/
/*
uint8_t b[8];
char msg[32];
status(&display, &radio);
_delay_ms(1000);
interrupt_flags_t flags = rfm_interrupts(&radio);
if (flags.fifo_not_empty) {
rfm_receive(&radio, b, 8);
display_clear(&display);
for (int i = 0; i < 8; i++) {
sprintf(msg, "%x", b[i]);
}
display_write_message(&display, msg);
_delay_ms(1000);
}
*/
// }
/*
spi_acquire(&rfm.spi);
spi_transfer_byte(&rfm.spi, 0x11);
spi_transfer_byte(&rfm.spi, 0x01);
spi_release(&rfm.spi);
spi_acquire(&rfm.spi);
spi_transfer_byte(&rfm.spi, 0x10);
spi_transfer_byte(&rfm.spi, 1);
spi_transfer_byte(&rfm.spi, 2);
spi_transfer_byte(&rfm.spi, 3);
spi_transfer_byte(&rfm.spi, 5);
spi_transfer_byte(&rfm.spi, 7);
spi_transfer_byte(&rfm.spi, 11);
spi_transfer_byte(&rfm.spi, 13);
spi_release(&rfm.spi);
status = rfm_status(&rfm);
if (status & _BV(7)) {
clear_line(&light);
} else {
set_line(&light);
}
*/
/*
uint8_t count[1] = { 0 };
while(1) {
rfm_send_data(&rfm, count, 1);
count[0]++;
set_line(&light);
_delay_ms(50);
clear_line(&light);
_delay_ms(50);
}
*/
return 0;
}

View File

@ -13,86 +13,193 @@ You should have received a copy of the GNU General Public License along with Lum
#include <rfm.h>
void rfm_write(rfm_t *rfm, uint8_t reg, uint8_t *data, size_t length) {
#define REG_FIFO 0x00
#define REG_OP_MODE 0x01
#define REG_DATA_MODULE 0x02
#define REG_VERSION 0x10
#define REG_RSSI_VALUE 0x24
#define REG_DIO_MAPPING1 0x25
#define REG_IRQ_FLAGS1 0x27
#define REG_IRQ_FLAGS2 0x28
#define REG_SYNC_CONFIG 0x2e
#define REG_SYNC_VALUE1 0x2f
#define REG_PACKET_CONFIG1 0x37
#define REG_FIFO_THRESH 0x3c
#define REG_TEST_PA1 0x5a
#define REG_TEST_PA2 0x5c
#define PA1_LOW_POWER 0x55
#define PA2_LOW_POWER 0x70
void _rfm_write(rfm_t *rfm, uint8_t reg, uint8_t *data, size_t length) {
spi_acquire(&rfm->spi);
spi_transfer_byte(&rfm->spi, _BV(7) | reg);
spi_transceive(&rfm->spi, _BV(7) | reg);
for (size_t i = 0; i < length; i++) {
spi_transfer_byte(&rfm->spi, data[i]);
spi_transceive(&rfm->spi, data[i]);
}
spi_release(&rfm->spi);
}
void rfm_read(rfm_t *rfm, uint8_t reg, uint8_t *data, size_t length) {
void _rfm_read(rfm_t *rfm, uint8_t reg, uint8_t *data, size_t length) {
spi_acquire(&rfm->spi);
spi_transfer_byte(&rfm->spi, reg);
spi_transceive(&rfm->spi, reg);
for (size_t i = 0; i < length; i++) {
data[i] = spi_transfer_byte(&rfm->spi, 0);
data[i] = spi_transceive(&rfm->spi, 0);
}
spi_release(&rfm->spi);
}
void rfm_initialize(rfm_t *rfm) {
void _rfm_set_low_power(rfm_t *rfm) {
_rfm_write(rfm, REG_TEST_PA1, (uint8_t [1]){ PA1_LOW_POWER }, 1);
_rfm_write(rfm, REG_TEST_PA2, (uint8_t [1]){ PA2_LOW_POWER }, 1);
}
void rfm_init(rfm_t *rfm, uint8_t *sync_word, size_t length, rfm_error_e *error) {
if (!error) return;
spi_initialize(&rfm->spi);
set_line_direction(&rfm->irq, LINE_IN);
set_line_direction(&rfm->reset, LINE_OUT);
rfm_reset(rfm);
rfm_sleep(rfm);
uint8_t version;
_rfm_read(rfm, REG_VERSION, &version, 1);
if (version != 0x24) {
*error = radio_not_found;
return;
}
rfm_set_mode(rfm, (op_mode_t){ .listen_on = false, .mode = standby });
_rfm_write(rfm, REG_FIFO_THRESH, (uint8_t [1]){ 0x8f }, 1);
_rfm_set_low_power(rfm);
_rfm_write(rfm, REG_PACKET_CONFIG1,
(uint8_t [1]){
_BV(7) /* variable length packets */
| _BV(6) /* DC whitening */
| _BV(4) /* CRC on */
| _BV(1) /* packet filtering requires nodeaddress */
}, 1);
_rfm_write(rfm, REG_SYNC_CONFIG, (uint8_t [1]){ _BV(7) | (length << 3) }, 1);
uint8_t word_base = REG_SYNC_VALUE1;
for (int i = 0; i < length; i++) {
_rfm_write(rfm, word_base + i, &sync_word[i], length);
}
}
void rfm_reset(rfm_t *rfm) {
set_line(&rfm->reset);
_delay_us(100);
clear_line(&rfm->reset);
_delay_us(5);
}
void rfm_packet_format(rfm_t *rfm, packet_format_e format, size_t length) {
switch (format) {
case unlimited:
rfm_write(rfm, 0x37, (uint8_t [1]){ 0 }, 1);
rfm_write(rfm, 0x38, (uint8_t [1]){ 0 }, 1);
_rfm_write(rfm, 0x37, (uint8_t [1]){ 0 }, 1);
_rfm_write(rfm, 0x38, (uint8_t [1]){ 0 }, 1);
break;
case fixed:
rfm_write(rfm, 0x37, (uint8_t [1]){ 0 }, 1);
rfm_write(rfm, 0x38, (uint8_t [1]){ length }, 1);
_rfm_write(rfm, 0x37, (uint8_t [1]){ 0 }, 1);
_rfm_write(rfm, 0x38, (uint8_t [1]){ length }, 1);
break;
case variable:
rfm_write(rfm, 0x37, (uint8_t [1]){ _BV(7) }, 1);
rfm_write(rfm, 0x38, (uint8_t [1]){ 0 }, 1);
_rfm_write(rfm, 0x37, (uint8_t [1]){ _BV(7) }, 1);
_rfm_write(rfm, 0x38, (uint8_t [1]){ 0 }, 1);
break;
}
}
void rfm_sleep(rfm_t *rfm) {
rfm_set_mode(rfm, (op_mode_t){ .listen_on = false, .mode = sleep });
}
void rfm_standby(rfm_t *rfm) {
rfm_set_mode(rfm, (op_mode_t){ .listen_on = false, .mode = standby });
}
void rfm_transmit(rfm_t *rfm, uint8_t *data, size_t length) {
rfm_set_mode(rfm, (op_mode_t){ .listen_on = false, .mode = standby });
_rfm_write(rfm, REG_FIFO, data, length);
_rfm_write(rfm, REG_DIO_MAPPING1, (uint8_t [1]){ 0x00 }, 1);
rfm_set_mode(rfm, (op_mode_t){ .listen_on = false, .mode = tx });
}
void rfm_receive_mode(rfm_t *rfm) {
_rfm_write(rfm, REG_DIO_MAPPING1, (uint8_t [1]){ _BV(6) }, 1);
rfm_set_mode(rfm, (op_mode_t){ .listen_on = false, .mode = rx });
}
void rfm_receive(rfm_t *rfm, uint8_t *data, size_t length) {
_rfm_write(rfm, REG_DIO_MAPPING1, (uint8_t [1]){ _BV(6) }, 1);
rfm_set_mode(rfm, (op_mode_t){ .listen_on = false, .mode = rx });
_rfm_read(rfm, 0x00, data, length);
}
uint8_t rfm_temperature(rfm_t *rfm) {
uint8_t ready = 0;
uint8_t temp;
rfm_write(rfm, 0x4e, (uint8_t [1]){ _BV(3) }, 1);
_rfm_write(rfm, 0x4e, (uint8_t [1]){ _BV(3) }, 1);
_delay_ms(1);
uint8_t i = 0;
while (!(ready & _BV(2)) && i < 10) {
rfm_read(rfm, 0x4e, &ready, 1);
_rfm_read(rfm, 0x4e, &ready, 1);
i++;
_delay_us(100);
}
rfm_read(rfm, 0x4f, &temp, 1);
_rfm_read(rfm, 0x4f, &temp, 1);
return temp;
}
uint8_t rfm_mode(rfm_t *rfm) {
uint8_t mode_flag;
rfm_read(rfm, 0x01, &mode_flag, 1);
return mode_flag;
op_mode_t rfm_mode(rfm_t *rfm) {
op_mode_t op_mode = {
.listen_on = false,
.mode = sleep,
};
uint8_t flags;
_rfm_read(rfm, 0x01, &flags, 1);
if (flags & _BV(6)) op_mode.listen_on = 1;
op_mode.mode = (flags & 0b00011100) >> 2;
return op_mode;
}
void rfm_set_mode(rfm_t *rfm, op_mode_t mode) {
op_mode_t current = rfm_mode(rfm);
uint8_t flags = mode.mode << 2;
if (mode.listen_on) {
flags |= _BV(6);
} else if (current.listen_on) {
flags |= _BV(5);
_rfm_write(rfm, REG_OP_MODE, (uint8_t [1]){ flags }, 1);
flags = flags & ~_BV(5);
}
_rfm_write(rfm, REG_OP_MODE, (uint8_t [1]){ flags }, 1);
}
uint8_t rfm_status(rfm_t *rfm) {
uint8_t status_flag;
rfm_read(rfm, 0x28, &status_flag, 1);
_rfm_read(rfm, 0x28, &status_flag, 1);
return status_flag;
}
void rfm_listen(rfm_t *rfm) {
rfm_write(rfm, 0x01, (uint8_t [1]){ _BV(6) }, 1);
_delay_ms(100);
}
uint32_t rfm_frequency(rfm_t *rfm) {
uint8_t frequency_bytes[3];
uint32_t frequency;
rfm_read(rfm, 0x07, &frequency_bytes[2], 1);
rfm_read(rfm, 0x08, &frequency_bytes[1], 1);
rfm_read(rfm, 0x09, &frequency_bytes[0], 1);
_rfm_read(rfm, 0x07, &frequency_bytes[2], 1);
_rfm_read(rfm, 0x08, &frequency_bytes[1], 1);
_rfm_read(rfm, 0x09, &frequency_bytes[0], 1);
frequency = frequency_bytes[2];
frequency = frequency << 8;
@ -102,19 +209,43 @@ uint32_t rfm_frequency(rfm_t *rfm) {
return frequency * 61;
}
uint8_t rfm_set_mode(rfm_t *rfm, mode_e mode) {
uint8_t mode_flags;
rfm_read(rfm, 0x01, &mode_flags, 1);
mode_flags = mode_flags & 0b11100011;
/*
mode_flags += (mode << 2);
rfm_write(rfm, 0x01, &mode_flags, 1);
*/
return mode_flags;
}
interrupt_flags_t rfm_interrupts(rfm_t *rfm) {
uint8_t irq_1;
uint8_t irq_2;
interrupt_flags_t flags = {
.mode_ready = false,
.rx_ready = false,
.tx_ready = false,
.timeout = false,
.auto_mode = false,
.sync_addr_match = false,
uint8_t rfm_irq_1(rfm_t *rfm) {
uint8_t irq;
rfm_read(rfm, 0x27, &irq, 1);
return irq;
.fifo_full = false,
.fifo_not_empty = false,
.fifo_level = false,
.fifo_overrun = false,
.packet_sent = false,
.payload_ready = false,
.crc_ok = false,
};
_rfm_read(rfm, REG_IRQ_FLAGS1, &irq_1, 1);
_rfm_read(rfm, REG_IRQ_FLAGS2, &irq_2, 1);
if (irq_1 & _BV(7)) flags.mode_ready = true;
if (irq_1 & _BV(6)) flags.rx_ready = true;
if (irq_1 & _BV(5)) flags.tx_ready = true;
if (irq_1 & _BV(2)) flags.timeout = true;
if (irq_1 & _BV(1)) flags.auto_mode = true;
if (irq_1 & _BV(0)) flags.sync_addr_match = true;
if (irq_2 & _BV(7)) flags.fifo_full = true;
if (irq_2 & _BV(6)) flags.fifo_not_empty = true;
if (irq_2 & _BV(5)) flags.fifo_level = true;
if (irq_2 & _BV(4)) flags.fifo_overrun = true;
if (irq_2 & _BV(3)) flags.packet_sent = true;
if (irq_2 & _BV(2)) flags.payload_ready = true;
if (irq_2 & _BV(1)) flags.crc_ok = true;
return flags;
}

View File

@ -15,6 +15,12 @@ You should have received a copy of the GNU General Public License along with Lum
#include <base.h>
#include <spi.h>
#include <stdbool.h>
typedef enum RFM_ERROR_TYPES {
Ok,
radio_not_found,
} rfm_error_e;
typedef struct RFM {
spi_t spi;
@ -33,22 +39,53 @@ typedef enum MODE {
standby,
fs,
tx,
rx
rx,
listen
} mode_e;
void rfm_initialize(rfm_t *rfm);
/* make mode more of a state machine. define the transitions between those machines. */
typedef struct MODE_FLAGS {
bool listen_on;
mode_e mode;
} op_mode_t;
typedef struct INTERRUPT_FLAGS {
bool mode_ready;
bool rx_ready;
bool tx_ready;
bool timeout;
bool auto_mode;
bool sync_addr_match;
bool fifo_full;
bool fifo_not_empty;
bool fifo_level;
bool fifo_overrun;
bool packet_sent;
bool payload_ready;
bool crc_ok;
} interrupt_flags_t;
void rfm_init(rfm_t *, uint8_t *, size_t, rfm_error_e *);
void rfm_reset(rfm_t *);
void rfm_packet_format(rfm_t *rfm, packet_format_e format, size_t length);
void rfm_send_data(rfm_t *rfm, uint8_t *data, size_t length);
void rfm_receive_data(rfm_t *rfm, uint8_t *data, size_t length);
void rfm_sleep(rfm_t *);
void rfm_standby(rfm_t *);
void rfm_receive_mode(rfm_t *);
void rfm_transmit(rfm_t *rfm, uint8_t *data, size_t length);
void rfm_receive(rfm_t *rfm, uint8_t *data, size_t length);
op_mode_t rfm_mode(rfm_t *rfm);
void rfm_set_mode(rfm_t *rfm, op_mode_t mode);
uint8_t rfm_mode(rfm_t *rfm);
uint8_t rfm_status(rfm_t *rfm);
uint8_t rfm_temperature(rfm_t *rfm);
uint32_t rfm_frequency(rfm_t *rfm);
void rfm_listen(rfm_t *rfm);
uint8_t rfm_set_mode(rfm_t *rfm, mode_e mode);
uint8_t rfm_irq_1(rfm_t *rfm);
interrupt_flags_t rfm_interrupts(rfm_t *rfm);
#endif

View File

@ -31,7 +31,7 @@ void spi_release(spi_t *spi) {
set_line(&spi->chip_select);
}
uint8_t spi_transfer_byte(spi_t *spi, uint8_t output) {
uint8_t spi_transceive(spi_t *spi, uint8_t output) {
uint8_t input = 0;
int input_bit;

View File

@ -27,6 +27,6 @@ typedef struct SPI {
void spi_initialize(spi_t *spi);
void spi_acquire(spi_t *spi);
void spi_release(spi_t *spi);
uint8_t spi_transfer_byte(spi_t *spi, uint8_t output);
uint8_t spi_transceive(spi_t *spi, uint8_t output);
#endif