From 161a66812c7c57839c0af11cb37e8c544a8c2aee Mon Sep 17 00:00:00 2001 From: Jonathan Brandenburg Date: Wed, 9 May 2018 06:53:03 -0500 Subject: [PATCH] Add chat application --- .gitignore | 2 + chat/Makefile | 31 +++ chat/ax5043/ax5043init.h | 433 ++++++++++++++++++++++++++++++++++++++ chat/ax5043/ax5043mode.h | 50 +++++ chat/ax5043/ax5043rx.h | 15 ++ chat/ax5043/ax5043tx.h | 46 ++++ chat/chat/chat_main.c | 311 +++++++++++++++++++++++++++ chat/crc/crc.c | 85 ++++++++ chat/crc/crc.h | 16 ++ chat/generated/configrx.h | 25 +++ chat/generated/configtx.h | 22 ++ chat/libs/libax5043.a | Bin 0 -> 33188 bytes chat/spi/ax5043spi.c | 96 +++++++++ chat/spi/ax5043spi.h | 17 ++ probeTxRx/probeTxRx.o | Bin 1840 -> 0 bytes probeTxRx/spi/ax5043spi.o | Bin 3068 -> 0 bytes 16 files changed, 1149 insertions(+) create mode 100644 .gitignore create mode 100644 chat/Makefile create mode 100644 chat/ax5043/ax5043init.h create mode 100644 chat/ax5043/ax5043mode.h create mode 100644 chat/ax5043/ax5043rx.h create mode 100644 chat/ax5043/ax5043tx.h create mode 100644 chat/chat/chat_main.c create mode 100644 chat/crc/crc.c create mode 100644 chat/crc/crc.h create mode 100644 chat/generated/configrx.h create mode 100644 chat/generated/configtx.h create mode 100644 chat/libs/libax5043.a create mode 100644 chat/spi/ax5043spi.c create mode 100644 chat/spi/ax5043spi.h delete mode 100644 probeTxRx/probeTxRx.o delete mode 100644 probeTxRx/spi/ax5043spi.o diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..8d0857ac --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +*.o +radiochat diff --git a/chat/Makefile b/chat/Makefile new file mode 100644 index 00000000..1b272490 --- /dev/null +++ b/chat/Makefile @@ -0,0 +1,31 @@ +all: radiochat + +rebuild: clean +rebuild: all + +clean: + rm -f radiochat + rm -f *.o + rm -f */*.o + +radiochat: spi/ax5043spi.o +radiochat: chat/chat_main.o +radiochat: crc/crc.o + gcc -o radiochat -pthread -Llibs/. spi/ax5043spi.o chat/chat_main.o crc/crc.o -lwiringPi -lax5043 + +spi/ax5043spi.o: spi/ax5043spi.c +spi/ax5043spi.o: spi/ax5043spi.h + cd spi; gcc -Wall -Wextra -c ax5043spi.c; cd .. + +chat/chat_main.o: chat/chat_main.c +chat/chat_main.o: ax5043/ax5043init.h +chat/chat_main.o: spi/ax5043spi.h +chat/chat_main.o: ax5043/ax5043mode.h +chat/chat_main.o: ax5043/ax5043rx.h +chat/chat_main.o: generated/configrx.h + cd chat; gcc -Wall -Wextra -c chat_main.c; cd .. + +crc/crc.o: crc/crc.c +crc/crc.o: crc/crc.h + cd crc; gcc -Wall -Wextra -c crc.c; cd .. + diff --git a/chat/ax5043/ax5043init.h b/chat/ax5043/ax5043init.h new file mode 100644 index 00000000..20f53dee --- /dev/null +++ b/chat/ax5043/ax5043init.h @@ -0,0 +1,433 @@ +// Copyright (c) 2018 Brandenburg Tech, LLC + +// Copyright (c) 2007,2008,2009,2010,2011,2012,2013, 2014 AXSEM AG +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1.Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2.Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// 3.Neither the name of AXSEM AG, Duebendorf nor the +// names of its contributors may be used to endorse or promote products +// derived from this software without specific prior written permission. +// 4.All advertising materials mentioning features or use of this software +// must display the following acknowledgement: +// This product includes software developed by AXSEM AG and its contributors. +// 5.The usage of this source code is only granted for operation with AX5043 +// and AX8052F143. Porting to other radio or communication devices is +// strictly prohibited. +// +// THIS SOFTWARE IS PROVIDED BY AXSEM AG AND CONTRIBUTORS ``AS IS'' AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL AXSEM AG AND CONTRIBUTORS BE LIABLE FOR ANY +// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef AX5043INIT_H_ +#define AX5043INIT_H_ + +#include + +#define AXRADIO_ERR_NOERROR 0x00 +#define AXRADIO_ERR_NOTSUPPORTED 0x01 +#define AXRADIO_ERR_BUSY 0x02 +#define AXRADIO_ERR_TIMEOUT 0x03 +#define AXRADIO_ERR_INVALID 0x04 +#define AXRADIO_ERR_NOCHIP 0x05 +#define AXRADIO_ERR_RANGING 0x06 +#define AXRADIO_ERR_LOCKLOST 0x07 +#define AXRADIO_ERR_RETRANSMISSION 0x08 +#define AXRADIO_ERR_RESYNC 0x09 +#define AXRADIO_ERR_RESYNCTIMEOUT 0x0a +#define AXRADIO_ERR_RECEIVESTART 0x0b + +#define AXRADIO_MODE_UNINIT 0x00 +#define AXRADIO_MODE_OFF 0x01 +#define AXRADIO_MODE_DEEPSLEEP 0x02 +#define AXRADIO_MODE_CW_TRANSMIT 0x03 +#define AXRADIO_MODE_ASYNC_TRANSMIT 0x10 +#define AXRADIO_MODE_WOR_TRANSMIT 0x11 +#define AXRADIO_MODE_ACK_TRANSMIT 0x12 +#define AXRADIO_MODE_WOR_ACK_TRANSMIT 0x13 +#define AXRADIO_MODE_STREAM_TRANSMIT_UNENC 0x18 +#define AXRADIO_MODE_STREAM_TRANSMIT_SCRAM 0x19 +#define AXRADIO_MODE_STREAM_TRANSMIT_UNENC_LSB 0x1A +#define AXRADIO_MODE_STREAM_TRANSMIT_SCRAM_LSB 0x1B +#define AXRADIO_MODE_STREAM_TRANSMIT 0x1C +#define AXRADIO_MODE_ASYNC_RECEIVE 0x20 +#define AXRADIO_MODE_WOR_RECEIVE 0x21 +#define AXRADIO_MODE_ACK_RECEIVE 0x22 +#define AXRADIO_MODE_WOR_ACK_RECEIVE 0x23 +#define AXRADIO_MODE_STREAM_RECEIVE_UNENC 0x28 +#define AXRADIO_MODE_STREAM_RECEIVE_SCRAM 0x29 +#define AXRADIO_MODE_STREAM_RECEIVE_UNENC_LSB 0x2A +#define AXRADIO_MODE_STREAM_RECEIVE_SCRAM_LSB 0x2B +#define AXRADIO_MODE_STREAM_RECEIVE 0x2C +#define AXRADIO_MODE_STREAM_RECEIVE_DATAPIN 0x2D +#define AXRADIO_MODE_SYNC_MASTER 0x30 +#define AXRADIO_MODE_SYNC_ACK_MASTER 0x31 +#define AXRADIO_MODE_SYNC_SLAVE 0x32 +#define AXRADIO_MODE_SYNC_ACK_SLAVE 0x33 +#define AX5043_AFSKCTRL 0x114 /* AFSK Control */ +#define AX5043_AFSKMARK0 0x113 /* AFSK Mark (1) Frequency 0 */ +#define AX5043_AFSKMARK1 0x112 /* AFSK Mark (1) Frequency 1 */ +#define AX5043_AFSKSPACE0 0x111 /* AFSK Space (0) Frequency 0 */ +#define AX5043_AFSKSPACE1 0x110 /* AFSK Space (0) Frequency 1 */ +#define AX5043_AGCCOUNTER 0x043 /* AGC Counter */ +#define AX5043_AMPLFILTER 0x115 /* Amplitude Filter */ +#define AX5043_BBOFFSCAP 0x189 /* Baseband Offset Compensation Capacitors */ +#define AX5043_BBTUNE 0x188 /* Baseband Tuning */ +#define AX5043_BGNDRSSI 0x041 /* Background RSSI */ +#define AX5043_BGNDRSSIGAIN 0x22E /* Background RSSI Averaging Time Constant */ +#define AX5043_BGNDRSSITHR 0x22F /* Background RSSI Relative Threshold */ +#define AX5043_CRCINIT0 0x017 /* CRC Initial Value 0 */ +#define AX5043_CRCINIT1 0x016 /* CRC Initial Value 1 */ +#define AX5043_CRCINIT2 0x015 /* CRC Initial Value 2 */ +#define AX5043_CRCINIT3 0x014 /* CRC Initial Value 3 */ +#define AX5043_DACCONFIG 0x332 /* DAC Configuration */ +#define AX5043_DACVALUE0 0x331 /* DAC Value 0 */ +#define AX5043_DACVALUE1 0x330 /* DAC Value 1 */ +#define AX5043_DECIMATION 0x102 /* Decimation Factor */ +#define AX5043_DIVERSITY 0x042 /* Antenna Diversity Configuration */ +#define AX5043_ENCODING 0x011 /* Encoding */ +#define AX5043_FEC 0x018 /* Forward Error Correction */ +#define AX5043_FECSTATUS 0x01A /* Forward Error Correction Status */ +#define AX5043_FECSYNC 0x019 /* Forward Error Correction Sync Threshold */ +#define AX5043_FIFOCOUNT0 0x02B /* Number of Words currently in FIFO 0 */ +#define AX5043_FIFOCOUNT1 0x02A /* Number of Words currently in FIFO 1 */ +#define AX5043_FIFODATA 0x029 /* FIFO Data */ +#define AX5043_FIFOFREE0 0x02D /* Number of Words that can be written to FIFO 0 */ +#define AX5043_FIFOFREE1 0x02C /* Number of Words that can be written to FIFO 1 */ +#define AX5043_FIFOSTAT 0x028 /* FIFO Control */ +#define AX5043_FIFOTHRESH0 0x02F /* FIFO Threshold 0 */ +#define AX5043_FIFOTHRESH1 0x02E /* FIFO Threshold 1 */ +#define AX5043_FRAMING 0x012 /* Framing Mode */ +#define AX5043_FREQA0 0x037 /* Frequency A 0 */ +#define AX5043_FREQA1 0x036 /* Frequency A 1 */ +#define AX5043_FREQA2 0x035 /* Frequency A 2 */ +#define AX5043_FREQA3 0x034 /* Frequency A 3 */ +#define AX5043_FREQB0 0x03F /* Frequency B 0 */ +#define AX5043_FREQB1 0x03E /* Frequency B 1 */ +#define AX5043_FREQB2 0x03D /* Frequency B 2 */ +#define AX5043_FREQB3 0x03C /* Frequency B 3 */ +#define AX5043_FSKDEV0 0x163 /* FSK Deviation 0 */ +#define AX5043_FSKDEV1 0x162 /* FSK Deviation 1 */ +#define AX5043_FSKDEV2 0x161 /* FSK Deviation 2 */ +#define AX5043_FSKDMAX0 0x10D /* Four FSK Rx Maximum Deviation 0 */ +#define AX5043_FSKDMAX1 0x10C /* Four FSK Rx Maximum Deviation 1 */ +#define AX5043_FSKDMIN0 0x10F /* Four FSK Rx Minimum Deviation 0 */ +#define AX5043_FSKDMIN1 0x10E /* Four FSK Rx Minimum Deviation 1 */ +#define AX5043_GPADC13VALUE0 0x309 /* GPADC13 Value 0 */ +#define AX5043_GPADC13VALUE1 0x308 /* GPADC13 Value 1 */ +#define AX5043_GPADCCTRL 0x300 /* General Purpose ADC Control */ +#define AX5043_GPADCPERIOD 0x301 /* GPADC Sampling Period */ +#define AX5043_IFFREQ0 0x101 /* 2nd LO / IF Frequency 0 */ +#define AX5043_IFFREQ1 0x100 /* 2nd LO / IF Frequency 1 */ +#define AX5043_IRQINVERSION0 0x00B /* IRQ Inversion 0 */ +#define AX5043_IRQINVERSION1 0x00A /* IRQ Inversion 1 */ +#define AX5043_IRQMASK0 0x007 /* IRQ Mask 0 */ +#define AX5043_IRQMASK1 0x006 /* IRQ Mask 1 */ +#define AX5043_IRQREQUEST0 0x00D /* IRQ Request 0 */ +#define AX5043_IRQREQUEST1 0x00C /* IRQ Request 1 */ +#define AX5043_LPOSCCONFIG 0x310 /* Low Power Oscillator Calibration Configuration */ +#define AX5043_LPOSCFREQ0 0x317 /* Low Power Oscillator Frequency Tuning Low Byte */ +#define AX5043_LPOSCFREQ1 0x316 /* Low Power Oscillator Frequency Tuning High Byte */ +#define AX5043_LPOSCKFILT0 0x313 /* Low Power Oscillator Calibration Filter Constant Low Byte */ +#define AX5043_LPOSCKFILT1 0x312 /* Low Power Oscillator Calibration Filter Constant High Byte */ +#define AX5043_LPOSCPER0 0x319 /* Low Power Oscillator Period Low Byte */ +#define AX5043_LPOSCPER1 0x318 /* Low Power Oscillator Period High Byte */ +#define AX5043_LPOSCREF0 0x315 /* Low Power Oscillator Reference Frequency Low Byte */ +#define AX5043_LPOSCREF1 0x314 /* Low Power Oscillator Reference Frequency High Byte */ +#define AX5043_LPOSCSTATUS 0x311 /* Low Power Oscillator Calibration Status */ +#define AX5043_MATCH0LEN 0x214 /* Pattern Match Unit 0, Pattern Length */ +#define AX5043_MATCH0MAX 0x216 /* Pattern Match Unit 0, Maximum Match */ +#define AX5043_MATCH0MIN 0x215 /* Pattern Match Unit 0, Minimum Match */ +#define AX5043_MATCH0PAT0 0x213 /* Pattern Match Unit 0, Pattern 0 */ +#define AX5043_MATCH0PAT1 0x212 /* Pattern Match Unit 0, Pattern 1 */ +#define AX5043_MATCH0PAT2 0x211 /* Pattern Match Unit 0, Pattern 2 */ +#define AX5043_MATCH0PAT3 0x210 /* Pattern Match Unit 0, Pattern 3 */ +#define AX5043_MATCH1LEN 0x21C /* Pattern Match Unit 1, Pattern Length */ +#define AX5043_MATCH1MAX 0x21E /* Pattern Match Unit 1, Maximum Match */ +#define AX5043_MATCH1MIN 0x21D /* Pattern Match Unit 1, Minimum Match */ +#define AX5043_MATCH1PAT0 0x219 /* Pattern Match Unit 1, Pattern 0 */ +#define AX5043_MATCH1PAT1 0x218 /* Pattern Match Unit 1, Pattern 1 */ +#define AX5043_MAXDROFFSET0 0x108 /* Maximum Receiver Datarate Offset 0 */ +#define AX5043_MAXDROFFSET1 0x107 /* Maximum Receiver Datarate Offset 1 */ +#define AX5043_MAXDROFFSET2 0x106 /* Maximum Receiver Datarate Offset 2 */ +#define AX5043_MAXRFOFFSET0 0x10B /* Maximum Receiver RF Offset 0 */ +#define AX5043_MAXRFOFFSET1 0x10A /* Maximum Receiver RF Offset 1 */ +#define AX5043_MAXRFOFFSET2 0x109 /* Maximum Receiver RF Offset 2 */ +#define AX5043_MODCFGA 0x164 /* Modulator Configuration A */ +#define AX5043_MODCFGF 0x160 /* Modulator Configuration F */ +#define AX5043_MODCFGP 0xF5F /* Modulator Configuration P */ +#define AX5043_MODULATION 0x010 /* Modulation */ +#define AX5043_PINFUNCANTSEL 0x025 /* Pin Function ANTSEL */ +#define AX5043_PINFUNCDATA 0x023 /* Pin Function DATA */ +#define AX5043_PINFUNCDCLK 0x022 /* Pin Function DCLK */ +#define AX5043_PINFUNCIRQ 0x024 /* Pin Function IRQ */ +#define AX5043_PINFUNCPWRAMP 0x026 /* Pin Function PWRAMP */ +#define AX5043_PINFUNCSYSCLK 0x021 /* Pin Function SYSCLK */ +#define AX5043_PINSTATE 0x020 /* Pin State */ +#define AX5043_PKTACCEPTFLAGS 0x233 /* Packet Controller Accept Flags */ +#define AX5043_PKTCHUNKSIZE 0x230 /* Packet Chunk Size */ +#define AX5043_PKTMISCFLAGS 0x231 /* Packet Controller Miscellaneous Flags */ +#define AX5043_PKTSTOREFLAGS 0x232 /* Packet Controller Store Flags */ +#define AX5043_PLLCPI 0x031 /* PLL Charge Pump Current */ +#define AX5043_PLLCPIBOOST 0x039 /* PLL Charge Pump Current (Boosted) */ +#define AX5043_PLLLOCKDET 0x182 /* PLL Lock Detect Delay */ +#define AX5043_PLLLOOP 0x030 /* PLL Loop Filter Settings */ +#define AX5043_PLLLOOPBOOST 0x038 /* PLL Loop Filter Settings (Boosted) */ +#define AX5043_PLLRANGINGA 0x033 /* PLL Autoranging A */ +#define AX5043_PLLRANGINGB 0x03B /* PLL Autoranging B */ +#define AX5043_PLLRNGCLK 0x183 /* PLL Autoranging Clock */ +#define AX5043_PLLVCODIV 0x032 /* PLL Divider Settings */ +#define AX5043_PLLVCOI 0x180 /* PLL VCO Current */ +#define AX5043_PLLVCOIR 0x181 /* PLL VCO Current Readback */ +#define AX5043_POWCTRL1 0xF08 /* Power Control 1 */ +#define AX5043_POWIRQMASK 0x005 /* Power Management Interrupt Mask */ +#define AX5043_POWSTAT 0x003 /* Power Management Status */ +#define AX5043_POWSTICKYSTAT 0x004 /* Power Management Sticky Status */ +#define AX5043_PWRAMP 0x027 /* PWRAMP Control */ +#define AX5043_PWRMODE 0x002 /* Power Mode */ +#define AX5043_RADIOEVENTMASK0 0x009 /* Radio Event Mask 0 */ +#define AX5043_RADIOEVENTMASK1 0x008 /* Radio Event Mask 1 */ +#define AX5043_RADIOEVENTREQ0 0x00F /* Radio Event Request 0 */ +#define AX5043_RADIOEVENTREQ1 0x00E /* Radio Event Request 1 */ +#define AX5043_RADIOSTATE 0x01C /* Radio Controller State */ +#define AX5043_REF 0xF0D /* Reference */ +#define AX5043_RSSI 0x040 /* Received Signal Strength Indicator */ +#define AX5043_RSSIABSTHR 0x22D /* RSSI Absolute Threshold */ +#define AX5043_RSSIREFERENCE 0x22C /* RSSI Offset */ +#define AX5043_RXDATARATE0 0x105 /* Receiver Datarate 0 */ +#define AX5043_RXDATARATE1 0x104 /* Receiver Datarate 1 */ +#define AX5043_RXDATARATE2 0x103 /* Receiver Datarate 2 */ +#define AX5043_SCRATCH 0x001 /* Scratch */ +#define AX5043_SILICONREVISION 0x000 /* Silicon Revision */ +#define AX5043_TIMER0 0x05B /* 1MHz Timer 0 */ +#define AX5043_TIMER1 0x05A /* 1MHz Timer 1 */ +#define AX5043_TIMER2 0x059 /* 1MHz Timer 2 */ +#define AX5043_TMGRXAGC 0x227 /* Receiver AGC Settling Time */ +#define AX5043_TMGRXBOOST 0x223 /* Receive PLL Boost Time */ +#define AX5043_TMGRXCOARSEAGC 0x226 /* Receive Coarse AGC Time */ +#define AX5043_TMGRXOFFSACQ 0x225 /* Receive Baseband DC Offset Acquisition Time */ +#define AX5043_TMGRXPREAMBLE1 0x229 /* Receiver Preamble 1 Timeout */ +#define AX5043_TMGRXPREAMBLE2 0x22A /* Receiver Preamble 2 Timeout */ +#define AX5043_TMGRXPREAMBLE3 0x22B /* Receiver Preamble 3 Timeout */ +#define AX5043_TMGRXRSSI 0x228 /* Receiver RSSI Settling Time */ +#define AX5043_TMGRXSETTLE 0x224 /* Receive PLL (post Boost) Settling Time */ +#define AX5043_TMGTXBOOST 0x220 /* Transmit PLL Boost Time */ +#define AX5043_TMGTXSETTLE 0x221 /* Transmit PLL (post Boost) Settling Time */ +#define AX5043_TRKAFSKDEMOD0 0x055 /* AFSK Demodulator Tracking 0 */ +#define AX5043_TRKAFSKDEMOD1 0x054 /* AFSK Demodulator Tracking 1 */ +#define AX5043_TRKAMPLITUDE0 0x049 /* Amplitude Tracking 0 */ +#define AX5043_TRKAMPLITUDE1 0x048 /* Amplitude Tracking 1 */ +#define AX5043_TRKDATARATE0 0x047 /* Datarate Tracking 0 */ +#define AX5043_TRKDATARATE1 0x046 /* Datarate Tracking 1 */ +#define AX5043_TRKDATARATE2 0x045 /* Datarate Tracking 2 */ +#define AX5043_TRKFREQ0 0x051 /* Frequency Tracking 0 */ +#define AX5043_TRKFREQ1 0x050 /* Frequency Tracking 1 */ +#define AX5043_TRKFSKDEMOD0 0x053 /* FSK Demodulator Tracking 0 */ +#define AX5043_TRKFSKDEMOD1 0x052 /* FSK Demodulator Tracking 1 */ +#define AX5043_TRKPHASE0 0x04B /* Phase Tracking 0 */ +#define AX5043_TRKPHASE1 0x04A /* Phase Tracking 1 */ +#define AX5043_TRKRFFREQ0 0x04F /* RF Frequency Tracking 0 */ +#define AX5043_TRKRFFREQ1 0x04E /* RF Frequency Tracking 1 */ +#define AX5043_TRKRFFREQ2 0x04D /* RF Frequency Tracking 2 */ +#define AX5043_TXPWRCOEFFA0 0x169 /* Transmitter Predistortion Coefficient A 0 */ +#define AX5043_TXPWRCOEFFA1 0x168 /* Transmitter Predistortion Coefficient A 1 */ +#define AX5043_TXPWRCOEFFB0 0x16B /* Transmitter Predistortion Coefficient B 0 */ +#define AX5043_TXPWRCOEFFB1 0x16A /* Transmitter Predistortion Coefficient B 1 */ +#define AX5043_TXPWRCOEFFC0 0x16D /* Transmitter Predistortion Coefficient C 0 */ +#define AX5043_TXPWRCOEFFC1 0x16C /* Transmitter Predistortion Coefficient C 1 */ +#define AX5043_TXPWRCOEFFD0 0x16F /* Transmitter Predistortion Coefficient D 0 */ +#define AX5043_TXPWRCOEFFD1 0x16E /* Transmitter Predistortion Coefficient D 1 */ +#define AX5043_TXPWRCOEFFE0 0x171 /* Transmitter Predistortion Coefficient E 0 */ +#define AX5043_TXPWRCOEFFE1 0x170 /* Transmitter Predistortion Coefficient E 1 */ +#define AX5043_TXRATE0 0x167 /* Transmitter Bitrate 0 */ +#define AX5043_TXRATE1 0x166 /* Transmitter Bitrate 1 */ +#define AX5043_TXRATE2 0x165 /* Transmitter Bitrate 2 */ +#define AX5043_WAKEUP0 0x06B /* Wakeup Time 0 */ +#define AX5043_WAKEUP1 0x06A /* Wakeup Time 1 */ +#define AX5043_WAKEUPFREQ0 0x06D /* Wakeup Frequency 0 */ +#define AX5043_WAKEUPFREQ1 0x06C /* Wakeup Frequency 1 */ +#define AX5043_WAKEUPTIMER0 0x069 /* Wakeup Timer 0 */ +#define AX5043_WAKEUPTIMER1 0x068 /* Wakeup Timer 1 */ +#define AX5043_WAKEUPXOEARLY 0x06E /* Wakeup Crystal Oscillator Early */ +#define AX5043_XTALAMPL 0xF11 /* Crystal Oscillator Amplitude Control */ +#define AX5043_XTALCAP 0x184 /* Crystal Oscillator Load Capacitance */ +#define AX5043_XTALOSC 0xF10 /* Crystal Oscillator Control */ +#define AX5043_XTALSTATUS 0x01D /* Crystal Oscillator Status */ + +#define AX5043_0xF00 0xF00 +#define AX5043_0xF0C 0xF0C +#define AX5043_0xF18 0xF18 +#define AX5043_0xF1C 0xF1C +#define AX5043_0xF21 0xF21 +#define AX5043_0xF22 0xF22 +#define AX5043_0xF23 0xF23 +#define AX5043_0xF26 0xF26 +#define AX5043_0xF30 0xF30 +#define AX5043_0xF31 0xF31 +#define AX5043_0xF32 0xF32 +#define AX5043_0xF33 0xF33 +#define AX5043_0xF34 0xF34 +#define AX5043_0xF35 0xF35 +#define AX5043_0xF44 0xF44 + +#define AX5043_AGCAHYST0 0x122 /* AGC Analog Hysteresis */ +#define AX5043_AGCAHYST1 0x132 /* AGC Analog Hysteresis */ +#define AX5043_AGCAHYST2 0x142 /* AGC Analog Hysteresis */ +#define AX5043_AGCAHYST3 0x152 /* AGC Analog Hysteresis */ +#define AX5043_AGCGAIN0 0x120 /* AGC Speed */ +#define AX5043_AGCGAIN1 0x130 /* AGC Speed */ +#define AX5043_AGCGAIN2 0x140 /* AGC Speed */ +#define AX5043_AGCGAIN3 0x150 /* AGC Speed */ +#define AX5043_AGCMINMAX0 0x123 /* AGC Analog Update Behaviour */ +#define AX5043_AGCMINMAX1 0x133 /* AGC Analog Update Behaviour */ +#define AX5043_AGCMINMAX2 0x143 /* AGC Analog Update Behaviour */ +#define AX5043_AGCMINMAX3 0x153 /* AGC Analog Update Behaviour */ +#define AX5043_AGCTARGET0 0x121 /* AGC Target */ +#define AX5043_AGCTARGET1 0x131 /* AGC Target */ +#define AX5043_AGCTARGET2 0x141 /* AGC Target */ +#define AX5043_AGCTARGET3 0x151 /* AGC Target */ +#define AX5043_AMPLITUDEGAIN0 0x12B /* Amplitude Estimator Bandwidth */ +#define AX5043_AMPLITUDEGAIN1 0x13B /* Amplitude Estimator Bandwidth */ +#define AX5043_AMPLITUDEGAIN2 0x14B /* Amplitude Estimator Bandwidth */ +#define AX5043_AMPLITUDEGAIN3 0x15B /* Amplitude Estimator Bandwidth */ +#define AX5043_BBOFFSRES0 0x12F /* Baseband Offset Compensation Resistors */ +#define AX5043_BBOFFSRES1 0x13F /* Baseband Offset Compensation Resistors */ +#define AX5043_BBOFFSRES2 0x14F /* Baseband Offset Compensation Resistors */ +#define AX5043_BBOFFSRES3 0x15F /* Baseband Offset Compensation Resistors */ +#define AX5043_DRGAIN0 0x125 /* Data Rate Estimator Bandwidth */ +#define AX5043_DRGAIN1 0x135 /* Data Rate Estimator Bandwidth */ +#define AX5043_DRGAIN2 0x145 /* Data Rate Estimator Bandwidth */ +#define AX5043_DRGAIN3 0x155 /* Data Rate Estimator Bandwidth */ +#define AX5043_FOURFSK0 0x12E /* Four FSK Control */ +#define AX5043_FOURFSK1 0x13E /* Four FSK Control */ +#define AX5043_FOURFSK2 0x14E /* Four FSK Control */ +#define AX5043_FOURFSK3 0x15E /* Four FSK Control */ +#define AX5043_FREQDEV00 0x12D /* Receiver Frequency Deviation 0 */ +#define AX5043_FREQDEV01 0x13D /* Receiver Frequency Deviation 0 */ +#define AX5043_FREQDEV02 0x14D /* Receiver Frequency Deviation 0 */ +#define AX5043_FREQDEV03 0x15D /* Receiver Frequency Deviation 0 */ +#define AX5043_FREQDEV10 0x12C /* Receiver Frequency Deviation 1 */ +#define AX5043_FREQDEV11 0x13C /* Receiver Frequency Deviation 1 */ +#define AX5043_FREQDEV12 0x14C /* Receiver Frequency Deviation 1 */ +#define AX5043_FREQDEV13 0x15C /* Receiver Frequency Deviation 1 */ +#define AX5043_FREQUENCYGAINA0 0x127 /* Frequency Estimator Bandwidth A */ +#define AX5043_FREQUENCYGAINA1 0x137 /* Frequency Estimator Bandwidth A */ +#define AX5043_FREQUENCYGAINA2 0x147 /* Frequency Estimator Bandwidth A */ +#define AX5043_FREQUENCYGAINA3 0x157 /* Frequency Estimator Bandwidth A */ +#define AX5043_FREQUENCYGAINB0 0x128 /* Frequency Estimator Bandwidth B */ +#define AX5043_FREQUENCYGAINB1 0x138 /* Frequency Estimator Bandwidth B */ +#define AX5043_FREQUENCYGAINB2 0x148 /* Frequency Estimator Bandwidth B */ +#define AX5043_FREQUENCYGAINB3 0x158 /* Frequency Estimator Bandwidth B */ +#define AX5043_FREQUENCYGAINC0 0x129 /* Frequency Estimator Bandwidth C */ +#define AX5043_FREQUENCYGAINC1 0x139 /* Frequency Estimator Bandwidth C */ +#define AX5043_FREQUENCYGAINC2 0x149 /* Frequency Estimator Bandwidth C */ +#define AX5043_FREQUENCYGAINC3 0x159 /* Frequency Estimator Bandwidth C */ +#define AX5043_FREQUENCYGAIND0 0x12A /* Frequency Estimator Bandwidth D */ +#define AX5043_FREQUENCYGAIND1 0x13A /* Frequency Estimator Bandwidth D */ +#define AX5043_FREQUENCYGAIND2 0x14A /* Frequency Estimator Bandwidth D */ +#define AX5043_FREQUENCYGAIND3 0x15A /* Frequency Estimator Bandwidth D */ +#define AX5043_FREQUENCYLEAK 0x116 /* Baseband Frequency Recovery Loop Leakiness */ +#define AX5043_PHASEGAIN0 0x126 /* Phase Estimator Bandwidth */ +#define AX5043_PHASEGAIN1 0x136 /* Phase Estimator Bandwidth */ +#define AX5043_PHASEGAIN2 0x146 /* Phase Estimator Bandwidth */ +#define AX5043_PHASEGAIN3 0x156 /* Phase Estimator Bandwidth */ +#define AX5043_PKTADDR0 0x207 /* Packet Address 0 */ +#define AX5043_PKTADDR1 0x206 /* Packet Address 1 */ +#define AX5043_PKTADDR2 0x205 /* Packet Address 2 */ +#define AX5043_PKTADDR3 0x204 /* Packet Address 3 */ +#define AX5043_PKTADDRCFG 0x200 /* Packet Address Config */ +#define AX5043_PKTADDRMASK0 0x20B /* Packet Address Mask 0 */ +#define AX5043_PKTADDRMASK1 0x20A /* Packet Address Mask 1 */ +#define AX5043_PKTADDRMASK2 0x209 /* Packet Address Mask 2 */ +#define AX5043_PKTADDRMASK3 0x208 /* Packet Address Mask 3 */ +#define AX5043_PKTLENCFG 0x201 /* Packet Length Configuration */ +#define AX5043_PKTLENOFFSET 0x202 /* Packet Length Offset */ +#define AX5043_PKTMAXLEN 0x203 /* Packet Maximum Length */ +#define AX5043_RXPARAMCURSET 0x118 /* Receiver Parameter Current Set */ +#define AX5043_RXPARAMSETS 0x117 /* Receiver Parameter Set Indirection */ +#define AX5043_TIMEGAIN0 0x124 /* Time Estimator Bandwidth */ +#define AX5043_TIMEGAIN1 0x134 /* Time Estimator Bandwidth */ +#define AX5043_TIMEGAIN2 0x144 /* Time Estimator Bandwidth */ +#define AX5043_TIMEGAIN3 0x154 /* Time Estimator Bandwidth */ + +// power states +#define AX5043_PWRSTATE_POWERDOWN 0x0 +#define AX5043_PWRSTATE_DEEPSLEEP 0x1 +#define AX5043_PWRSTATE_REGS_ON 0x4 +#define AX5043_PWRSTATE_XTAL_ON 0x5 +#define AX5043_PWRSTATE_FIFO_ON 0x7 +#define AX5043_PWRSTATE_SYNTH_RX 0x8 +#define AX5043_PWRSTATE_FULL_RX 0x9 +#define AX5043_PWRSTATE_WOR_RX 0xb +#define AX5043_PWRSTATE_SYNTH_TX 0xc +#define AX5043_PWRSTATE_FULL_TX 0xd + +//fifo commands +#define AX5043_FIFOCMD_NOP 0x00 +#define AX5043_FIFOCMD_DATA 0x01 +#define AX5043_FIFOCMD_REPEATDATA 0x02 +#define AX5043_FIFOCMD_TIMER 0x10 +#define AX5043_FIFOCMD_RSSI 0x11 +#define AX5043_FIFOCMD_FREQOFFS 0x12 +#define AX5043_FIFOCMD_RFFREQOFFS 0x13 +#define AX5043_FIFOCMD_DATARATE 0x14 +#define AX5043_FIFOCMD_ANTRSSI 0x15 +#define AX5043_FIFOCMD_TXCTRL 0x1C +#define AX5043_FIFOCMD_TXPWR 0x1D + +#define SILICONREV1 0x51 +\ +#define RADIO_OK 0 +#define RADIO_ERR_REVISION 1 +#define RADIO_ERR_COMM 2 +#define RADIO_ERR_IRQ 3 +#define RADIO_ERR_WAKEUPTIMEOUT 4 + +#define PKTDATA_BUFLEN 260 + +typedef enum { + trxstate_off, + trxstate_rx, + trxstate_rxwor, + trxstate_wait_xtal, + trxstate_xtal_ready, + trxstate_pll_ranging, + trxstate_pll_ranging_done, + trxstate_pll_settling, + trxstate_pll_settled, + trxstate_tx_xtalwait, + trxstate_tx_longpreamble, + trxstate_tx_shortpreamble, + trxstate_tx_packet, + trxstate_tx_waitdone, + trxstate_txcw_xtalwait, + trxstate_txstream_xtalwait, + trxstate_txstream +} axradio_trxstate_t; + +struct axradio_address { + uint8_t addr[4]; +}; + +struct axradio_address_mask { + uint8_t addr[4]; + uint8_t mask[4]; +}; + +uint8_t axradio_init(void); +void axradio_wait_for_xtal(void); + +#endif /* AX5043INIT_H_ */ diff --git a/chat/ax5043/ax5043mode.h b/chat/ax5043/ax5043mode.h new file mode 100644 index 00000000..9a869fad --- /dev/null +++ b/chat/ax5043/ax5043mode.h @@ -0,0 +1,50 @@ +// Copyright (c) 2018 Brandenburg Tech, LLC + +// Copyright (c) 2007,2008,2009,2010,2011,2012,2013, 2014 AXSEM AG +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1.Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2.Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// 3.Neither the name of AXSEM AG, Duebendorf nor the +// names of its contributors may be used to endorse or promote products +// derived from this software without specific prior written permission. +// 4.All advertising materials mentioning features or use of this software +// must display the following acknowledgement: +// This product includes software developed by AXSEM AG and its contributors. +// 5.The usage of this source code is only granted for operation with AX5043 +// and AX8052F143. Porting to other radio or communication devices is +// strictly prohibited. +// +// THIS SOFTWARE IS PROVIDED BY AXSEM AG AND CONTRIBUTORS ``AS IS'' AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL AXSEM AG AND CONTRIBUTORS BE LIABLE FOR ANY +// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef AX5043MODE_H_ +#define AX5043MODE_H_ + +#include + +uint8_t mode_tx(); +uint8_t mode_rx(); +uint8_t ax5043_off(void); +uint8_t ax5043_off_xtal(void); +uint8_t ax5043_init_registers_tx(void); +uint8_t axradio_get_pllvcoi(void); +uint8_t ax5043_init_registers_rx(void); +uint8_t ax5043_receiver_on_continuous(void); + + +#endif /* AX5043MODE_H_ */ diff --git a/chat/ax5043/ax5043rx.h b/chat/ax5043/ax5043rx.h new file mode 100644 index 00000000..cd780450 --- /dev/null +++ b/chat/ax5043/ax5043rx.h @@ -0,0 +1,15 @@ +/* + * ax5043rx.h + * + * Created on: Feb 23, 2018 + * Author: Jonathan Brandenburg + */ + +#ifndef AX5043RX_H_ +#define AX5043RX_H_ + +#include + +uint8_t receive_packet(void); + +#endif /* AX5043RX_H_ */ diff --git a/chat/ax5043/ax5043tx.h b/chat/ax5043/ax5043tx.h new file mode 100644 index 00000000..5474cfc6 --- /dev/null +++ b/chat/ax5043/ax5043tx.h @@ -0,0 +1,46 @@ +// Copyright (c) 2018 Brandenburg Tech, LLC + +// Copyright (c) 2007,2008,2009,2010,2011,2012,2013, 2014 AXSEM AG +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1.Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2.Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// 3.Neither the name of AXSEM AG, Duebendorf nor the +// names of its contributors may be used to endorse or promote products +// derived from this software without specific prior written permission. +// 4.All advertising materials mentioning features or use of this software +// must display the following acknowledgement: +// This product includes software developed by AXSEM AG and its contributors. +// 5.The usage of this source code is only granted for operation with AX5043 +// and AX8052F143. Porting to other radio or communication devices is +// strictly prohibited. +// +// THIS SOFTWARE IS PROVIDED BY AXSEM AG AND CONTRIBUTORS ``AS IS'' AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL AXSEM AG AND CONTRIBUTORS BE LIABLE FOR ANY +// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef AX5043TX_H_ +#define AX5043TX_H_ + +#include + +#include "ax5043init.h" + +uint8_t transmit_packet(const struct axradio_address *addr, const uint8_t *pkt, uint16_t pktlen); +void ax5043_writefifo(const uint8_t *ptr, uint8_t len); +void ax5043_prepare_tx(void); + +#endif /* AX5043TX_H_ */ diff --git a/chat/chat/chat_main.c b/chat/chat/chat_main.c new file mode 100644 index 00000000..8d0b7336 --- /dev/null +++ b/chat/chat/chat_main.c @@ -0,0 +1,311 @@ +// Copyright (c) 2018 Brandenburg Tech, LLC +// All rights reserved. + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "../ax5043/ax5043init.h" +#include "../spi/ax5043spi.h" +#include "../ax5043/ax5043mode.h" +#include "../ax5043/ax5043rx.h" +#include "../ax5043/ax5043tx.h" +#include "../generated/configrx.h" +#include "../generated/configtx.h" + +#define MAX_MESSAGE_LENGTH (197) + +extern uint8_t axradio_rxbuffer[]; + +void *receive(void *arg); +void *transmit(void *arg); +int get_message(uint8_t *buffer, int avail); + +enum RadioState {UnknownState, RxState, TxState}; +enum RadioState currentState = UnknownState; + +enum ReceiveState {WaitingForNewPacket, WaitingForPacketCounter1, + WaitingForPacketCounter2, WaitingForMessageLength1, + WaitingForMessageLength2, WaitingForMessage, + WaitingForChecksum1, WaitingForChecksum2}; + +int main(void) +{ + uint8_t retVal; + + // Configure SPI bus to AX5043 + setSpiChannel(SPI_CHANNEL); + setSpiSpeed(SPI_SPEED); + initializeSpi(); + + // Initialize the AX5043 + retVal = axradio_init(); + if (retVal == AXRADIO_ERR_NOCHIP) { + fprintf(stderr, "ERROR: No AX5043 RF chip found\n"); + exit(EXIT_FAILURE); + } + if (retVal != AXRADIO_ERR_NOERROR) { + fprintf(stderr, "ERROR: Unable to initialize AX5043\n"); + exit(EXIT_FAILURE); + } + + printf("INFO: Found and initialized AX5043\n"); + + int result; + + sem_t ax5043_sem; + result = sem_init(&ax5043_sem, 0, 1); + if (result != 0) { + fprintf(stderr, "ERROR: Unable to create semaphore with error %s\n", strerror(errno)); + exit(EXIT_FAILURE); + } + + + pthread_t receive_thread; + result = pthread_create(&receive_thread, NULL, receive, (void *)&ax5043_sem); + if (result != 0) { + fprintf(stderr, "ERROR: Unable to spawn receive thread with error %s\n", strerror(errno)); + exit(EXIT_FAILURE); + } + + pthread_t transmit_thread; + result = pthread_create(&transmit_thread, NULL, transmit, (void *)&ax5043_sem); + if (result != 0) { + fprintf(stderr, "ERROR: Unable to spawn transmit thread with error %s\n", strerror(errno)); + exit(EXIT_FAILURE); + } + + + void *transmit_result; + result = pthread_join(transmit_thread, &transmit_result); + if (result != 0) { + fprintf(stderr, "ERROR: Unable to wait for transmit thread to finish with error %s\n", strerror(errno)); + exit(EXIT_FAILURE); + } + + sem_destroy(&ax5043_sem); + + return 0; +} + +void *receive(void *arg) { + sem_t *sem; + sem = (sem_t *)arg; + + uint8_t retVal; + uint16_t packetNumber; + uint16_t messageLength; + uint16_t checksum; + char ch; + + enum ReceiveState currentReceiveState = WaitingForNewPacket; + + for (;;) { + int result; + + result = sem_wait(sem); + if (result != 0) { + fprintf(stderr, "Failed to wait on semaphore with error %s\n", strerror(errno)); + exit(EXIT_FAILURE); + } + + + // Enter receive mode only if not already in receive mode + if (currentState != RxState) { + retVal = mode_rx(); + if (retVal != AXRADIO_ERR_NOERROR) { + fprintf(stderr, "ERROR: Unable to enter RX mode\n"); + exit(EXIT_FAILURE); + } + currentState = RxState; + } + + retVal = receive_packet(); + if (retVal > 0) { + uint8_t counter = 0; + while (retVal-- > 0) { + switch(currentReceiveState) { + case WaitingForNewPacket: + printf("Pkt Len: %d ", (int)axradio_rxbuffer[counter++]); + currentReceiveState = WaitingForPacketCounter1; + break; + case WaitingForPacketCounter1: + packetNumber = (int)axradio_rxbuffer[counter++]; + currentReceiveState = WaitingForPacketCounter2; + break; + case WaitingForPacketCounter2: + packetNumber |= (int)axradio_rxbuffer[counter++] << 8; + printf("Pkt Num: %d ", (int)packetNumber); + currentReceiveState = WaitingForMessageLength1; + break; + case WaitingForMessageLength1: + messageLength = (int)axradio_rxbuffer[counter++]; + currentReceiveState = WaitingForMessageLength2; + break; + case WaitingForMessageLength2: + messageLength |= (int)axradio_rxbuffer[counter++] << 8; + printf("Msg Len: %d ", (int)messageLength); + currentReceiveState = WaitingForMessage; + break; + case WaitingForMessage: + ch = (char)axradio_rxbuffer[counter++]; + if (ch != '\n') { + printf("%c", ch); + } + else { + printf(" "); + currentReceiveState = WaitingForChecksum1; + } + break; + case WaitingForChecksum1: + checksum = (int)axradio_rxbuffer[counter++]; + currentReceiveState = WaitingForChecksum2; + break; + case WaitingForChecksum2: + checksum |= (int)axradio_rxbuffer[counter++] << 8; + printf("(Chksum: %d)\n", (int)checksum); + currentReceiveState = WaitingForNewPacket; + break; + default: + fprintf(stderr, "ERROR: Unknown state in receive state machine\n"); + exit(EXIT_FAILURE); + break; + } + } + + fflush(stdout); + + } + + result = sem_post(sem); + if (result != 0) { + fprintf(stderr, "Failed to post on semaphore with error %s\n", strerror(errno)); + exit(EXIT_FAILURE); + } + + usleep(100000); + } + + return NULL; +} + +void *transmit(void *arg) { + sem_t *sem; + sem = (sem_t *)arg; + + uint8_t retVal; + + for (;;) { + int result; + + // allocate space for the buffer + static uint8_t packet[MAX_MESSAGE_LENGTH + 1]; + uint16_t pkt_counter; + + ++pkt_counter; + + // Calculate the number of reserved bytes at the beginning of the packet + int reserved_space = 0; + + // if transmitting a packet counter, reserve two bytes + if (framing_insert_counter) { + reserved_space += 2; + } + + // reserve two bytes for the overall length of the packet including the + // packet counter, if present, and the field containing the length + reserved_space += 2; + + // get a message to transmit. + int msg_length = get_message(&packet[reserved_space], (MAX_MESSAGE_LENGTH + 1) - reserved_space); + + // if message consists only of a newline, terminate + if (msg_length <= 1) { + break; + } + + if (framing_insert_counter) { + packet[framing_counter_pos] = pkt_counter & 0xFF ; + packet[framing_counter_pos+1] = (pkt_counter>>8) & 0xFF; + + // include the message length + packet[framing_counter_pos+2] = msg_length & 0xFF ; + packet[framing_counter_pos+3] = (msg_length>>8) & 0xFF; + } + else { // only include the message length + packet[framing_counter_pos] = msg_length & 0xFF ; + packet[framing_counter_pos+1] = (msg_length>>8) & 0xFF; + } + + result = sem_wait(sem); + if (result != 0) { + fprintf(stderr, "Failed to wait on semaphore with error %s\n", strerror(errno)); + exit(EXIT_FAILURE); + } + + // Enter transmit mode only if not already in receive mode + if (currentState != TxState) { + retVal = mode_tx(); + if (retVal != AXRADIO_ERR_NOERROR) { + fprintf(stderr, "ERROR: Unable to enter TX mode\n"); + exit(EXIT_FAILURE); + } + currentState = TxState; + } + + //printf("INFO: Sending another packet...\n"); + //printf("DEBUG: msg_length = %d\n", msg_length); + //printf("DEBUG: reserved_space = %d\n", reserved_space); + retVal = transmit_packet(&remoteaddr_tx, packet, msg_length + reserved_space); + if (retVal != AXRADIO_ERR_NOERROR) { + fprintf(stderr, "ERROR: Unable to transmit a packet\n"); + exit(EXIT_FAILURE); + } + + result = sem_post(sem); + if (result != 0) { + fprintf(stderr, "Failed to post on semaphore with error %s\n", strerror(errno)); + exit(EXIT_FAILURE); + } + } + + return NULL; +} + +int get_message(uint8_t *buffer, int avail) { + + static int instructionsPrinted = 0; + + // obtain a line of text. We state the message is limited to avail-2 to + // leave space for the newline and the null terminator + if (!instructionsPrinted) { + printf("Please enter your message, up to %d characters\n (empty message to terminate the program):\n", avail-2); + instructionsPrinted = 1; + } + fgets((char *)buffer, avail, stdin); + + // If the newline isn't present, the message is too long + + //printf("DEBUG: ***%s***\n", buffer); + + if (buffer[strlen((char *)buffer) - 1] != '\n') { + buffer[strlen((char *)buffer) - 1] = '\n'; + printf("WARNING: message too long. It will be truncated to\n%s", (char *)buffer); + + // If the newline isn't in the buffer, read characters from the keyboard buffer to the newline + int c; + do { + c = getchar(); + } while (c != '\n' && c != EOF); + } + + //printf("DEBUG: ***%s***\n", buffer); + + return strlen((char *)buffer); +} diff --git a/chat/crc/crc.c b/chat/crc/crc.c new file mode 100644 index 00000000..954a1241 --- /dev/null +++ b/chat/crc/crc.c @@ -0,0 +1,85 @@ +// Copyright (c) 2018 Brandenburg Tech, LLC + +#include "crc.h" + +/* Polynomial: x^16 + x^15 + x^2 + 1 = 0x18005 LSB first */ + +const uint16_t crc_crc16_table[256] = { + 0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241, + 0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440, + 0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40, + 0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841, + 0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40, + 0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41, + 0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641, + 0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040, + 0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240, + 0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441, + 0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41, + 0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840, + 0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41, + 0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40, + 0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640, + 0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041, + 0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240, + 0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441, + 0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41, + 0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840, + 0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41, + 0xbe01, 0x7ec0, 0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40, + 0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640, + 0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041, + 0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241, + 0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440, + 0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40, + 0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841, + 0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40, + 0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41, + 0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, + 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040 +}; + +uint16_t crc_crc16(const uint8_t *buf, uint16_t buflen, uint16_t crc) +{ + if (!buflen) + return crc; + do { + crc = crc_crc16_byte(crc, *buf++); + } while (--buflen); + return crc; +} + +uint16_t crc_crc16_byte(uint16_t crc, uint8_t c) +{ + return (crc >> 8) ^ crc_crc16_table[((uint8_t)crc ^ c) & (uint8_t)0xff]; +} + +uint16_t pn9_buffer(uint8_t *buf, uint16_t buflen, uint16_t pn9, uint8_t xor) +{ + if (!buflen) + return pn9; + do { + *buf++ ^= pn9 ^ xor; + pn9 = pn9_advance_byte(pn9); + } while (--buflen); + return pn9; +} + +uint16_t pn9_advance_bits(uint16_t pn9, uint16_t bits) +{ + if (!bits) + return pn9; + do { + pn9 = (uint8_t)(pn9 >> 1) | (((pn9 << 3) ^ (pn9 << 8)) & 0x100); + } while (--bits); + return pn9; +} + +uint16_t pn9_advance_byte(uint16_t pn9) +{ + uint8_t bits = 8; + do { + pn9 = (uint8_t)(pn9 >> 1) | (((pn9 << 3) ^ (pn9 << 8)) & 0x100); + } while (--bits); + return pn9; +} diff --git a/chat/crc/crc.h b/chat/crc/crc.h new file mode 100644 index 00000000..667440ab --- /dev/null +++ b/chat/crc/crc.h @@ -0,0 +1,16 @@ +// Copyright (c) 2018 Brandenburg Tech, LLC + +#ifndef CRC_H_ +#define CRC_H_ + +#include + +uint16_t crc_crc16(const uint8_t *buf, uint16_t buflen, uint16_t crc); +uint16_t crc_crc16_byte(uint16_t crc, uint8_t c); +uint16_t pn9_buffer(uint8_t *buf, uint16_t buflen, uint16_t pn9, uint8_t xor); +uint16_t pn9_advance_bits(uint16_t pn9, uint16_t bits); +uint16_t pn9_advance_byte(uint16_t pn9); + + + +#endif /* CRC_H_ */ diff --git a/chat/generated/configrx.h b/chat/generated/configrx.h new file mode 100644 index 00000000..1f7eecb9 --- /dev/null +++ b/chat/generated/configrx.h @@ -0,0 +1,25 @@ +/* Warning: This file is automatically generated by AX-RadioLAB. +Manual changes are overwritten! */ + +#include "../ax5043/ax5043init.h" + + +#define USE_LCD +#define USE_DBGLINK +//#define USE_COM0 +//#define DEBUGMSG +#define MCU_SLEEP +#define WTIMER0_CLKSRC CLKSRC_LPOSC +#define WTIMER0_PRESCALER 0x01 +#define RADIO_MODE_RX AXRADIO_MODE_ASYNC_RECEIVE +#define FXTAL 48000000 + +extern const struct axradio_address remoteaddr_rx; +extern const struct axradio_address_mask localaddr_rx; + +extern const uint8_t framing_insert_counter; +extern const uint8_t framing_counter_pos; + +extern const uint16_t lposckfiltmax; + +extern const uint16_t lpxosc_settlingtime; diff --git a/chat/generated/configtx.h b/chat/generated/configtx.h new file mode 100644 index 00000000..85a3881b --- /dev/null +++ b/chat/generated/configtx.h @@ -0,0 +1,22 @@ +/* Warning: This file is automatically generated by AX-RadioLAB. +Manual changes are overwritten! */ + +#include "../ax5043/ax5043init.h" + + +//#define USE_LCD +//#define USE_DBGLINK +#define USE_COM0 +//#define DEBUGMSG +//#define MCU_SLEEP +#define WTIMER0_CLKSRC CLKSRC_LPOSC +#define WTIMER0_PRESCALER 0x01 +#define WTIMER0_PERIOD 0x0280 +#define RADIO_MODE_TX AXRADIO_MODE_ASYNC_TRANSMIT +extern const struct axradio_address remoteaddr_tx; +extern const struct axradio_address_mask localaddr_tx; +extern const uint8_t demo_packet[6]; +extern const uint8_t framing_insert_counter; +extern const uint8_t framing_counter_pos; + +extern const uint16_t lpxosc_settlingtime; diff --git a/chat/libs/libax5043.a b/chat/libs/libax5043.a new file mode 100644 index 0000000000000000000000000000000000000000..fe799438e42a4cebfa276ea3ad85411770869a80 GIT binary patch literal 33188 zcmeHQ4RBP~b$+{&U=acqEIYESI19+Oum!9@VC*Q4_;HK_PB6v|iJeL-?aETTXqDXs zM+r?hrE%*4}30uidv8mBa+sT=kC z?mOr0-KSk4J8qKBaA)qGbM8I&+;e~5{Wod(7YsU%`dfw^=Z4SK!2?OhDds=X<2Y0KwqeIn|4gVO9ox~> z{Zva=cP5d}wzQ{qc4rf5M}viK=}BdrWKVA@)83LvWV1;m$#(5XIO)WWR5lTd$I~s@ zUMHDqk0q6eBdVn**8X%NYqO%@9jMH^Q#kCt@esjduk$rKD^ zc7>Q*AhJmK?o_&1RC}sBJ5^ju1_e$gdSa+8=myqwEZ&tub#?D*=}0F&i=Whv&d(Ky z$fm5|p3Y}b)7^4qE!h;wbkt*MdnTKpDw6_Q+IDty zpgC1vuUR`2?N7I~r`spR#Cm!X-SNCAD&5n4pT|nN8-qWFf+X2GZe1{#fh^jjz@B6> z-ThQocUP|Nlz&%ys;gjxn`V+I^5+F20Nt*uEiVwAiHf8;I_&mhp6N`ct4MGzm`W$9fv^@%2C1F7fu+eA7f&Q(xn66> zurtQGGdsFC9J(hLoT)R3&vqBAVmvZ>V$UQ~vAA6Y?5e&I!P+Po#zzU7FrD3*n*$AV zCK=n6Xd$}0t2>_B?G@RI<#f>%OHR$i*q+$VOs*$e5->d!($vj7ogim2mC4nLm9#r; z9x?7vwZhZAvG}f-J$d9s7B5Y@*WZFWQt_PD*>o=|${LW~Q`W1Rbgwtho5v>#U_GRE z$GXfM)6$!bCA~Ce%4J5@lN2KW@kRurbB|#17~b5|)yI&FNGIA8UAq$LmQ**NkJ+y7 zovEFyNh23oSi9`%^%&8#jx5&`IarUWJprWibVZAEvdyRwOnu8tH|7A7}M;ULG3 zuBX~lJ9ebHm!+0RimgX=8G7FuZT*Z~A1R=I7aY~&q0&+4-?Pze%@X=*HdZu%egiywO$h#YmxY7>* zrxx^#&u^%9r#9}bIp5_{)LE8!W=A&G2AEB|uv4*YqBrX-i^sAtXIUGD^|ExzCD>6C zSoIj6MW^7Je2yH-glaeUP-)2~a1AgjtVG4H@EY^+j@^5I6|+OG{H&7qVt%Nw>NdY; zu^qIxyG$j{AXXb`!?lW)90qplW&e#nXz^l{w zfZ^oRIp8C}r!xoqmI@N6W6VDXkZ(G3z##ahGY9NJMysv7HDCW6@NGmCp99jrv^jv| zpYs6Sm8On3aV?^@#@jpiT!SZR7IV4n8mA0YjD%m9w_>$DD-YkH#lQ)~`c zhv@0d0lO_(M0G6s=K%6eXAZ!D@3iKCUS!0ziaO2LKL-p=IS1$};QH%;hG;{>3bPWp z{yJdb4x^Q~4yeG+z}dL;UrL95XEYQZI3IQf&i{O3;>Ql~`GVI1Um*BRz^eog0AFa~ zi!6Mxh2LS}cUpM2;4>g6P~qlV3Vd7HOJmewCh*OIQ=bij{~PeN^IZNa;8BaG&cY)W zzE1f2z+WNZi-DI4{wKiSE_L%Q1HNAPcLBd7;XeaDEco-l&k0W5&I*1N_^X0{ANYc~ zuAa{UKPKVhz#kU*7l02)_$lBA1)m3ezu+GL{!!sC2fjzbiDw089VP{*KAVJ}_;xFN zi{RAlCQG*_i>J}T>jl3A{zpXSdEiwNPMyPoQ|FN2)cIqU&R0v^x~0yS1*gsz1P=oL zxbUwAepbS70sgAsEXzs3CxG8<=|5=k9JcU7g8vBokBj_K;Cm&U`u7P={d)zc{=Xso zbAZPsocNQ1Q~zy(Q~ys``Zr5B^H`k~*BW_}fJOZiEj>IP(h1*z5y-$O=Co z_^SxtC-_m|3#D9VfcIMAJ%Tg5Q}E9N|B~cOe4B(n5B#?!oPDNQ!dC!aB=ReP*IVJW zf;0TfR$YZ9JcIC%;4J&|!t*}hR|9T+UIczwaF+do;B5EBl5Yg~S&L_-)s82u@MD5A zuR#lcOZYjz9h7k5`vva=zE^OzU7z5bLwW^22)sw|I^dmxhk>^Weh2XFf;-N@h_m-E zF9q<-3Bs4am%-0~p9wz;z8row{2chX@blnrhJPRYLiju2?}Wb#ehK{D@b|zkgim}+=N00a=$jWyA_F7A=)g!nd@$NST+%Qw5{kOK>l+6~@^}yzjIJLpSs@T< zLy*ICUYa$zG@pwOoPQx$GR!<|KH`fZThnMBHV^fil)t5;U#8)=@-}6fj=oLT*EdfW z>K(altR(tu!7}^nvZN5dm1jXc3#HMr0Zz)_FVC*0srZr3mc{z-cbsvS*NL`|hNT~9 z`}oU7o(k|(gl{u_Yf^jp>p!}7*ziMs7l~Xe?9%`r_j%zKXmo-(>TqqkZv}=>gR7q zzkVi-)S*8QXqMOFbqEAf87s7gj z^YJUuO(SMqV$C1AJ_k30wIvj^TXPupYIp z1CjpGaAfuv)0sAn3>)Y~PMJEl;}@ARHgVCsN8IP3_cO|6U6l4$JYLn{}0Q0cQ?~%ieWWz{EGB ze6Dlj4_Y+SAF^nsziQEpzh=>lujeI~ajyI|7R~siMKgV`MKk`mMKk`SMT7Jl@7>6s zb1pr^LsH}1{Eu6-#t`zH-gcAk^+M*3mOQMZ1?X4q(Wjd#48Us-#ytthcs!#_eJLFW z&H8DU_%8smK9v3jXqJDY#D5=<<=u{hYs&i}=qeQQ0QO3xe+rt8{bD}K9|kgrJs$6s z7|;Fm9w@d?=tn?@Q2sihxetz7^e)ibLAOf$e$eVzz868W{sw_l{&zr=g`W9;4+vEA z=r=$^b>kWT7HAa5i?0B4g++7!Onz71PbQjt^rN8J#%_F>(*c@#F%9MSfyQ&ji~kzv zn=Sg!K;L4~e*>EH0f0&WLm<^w{7*saT?XaP#gMA8;_n1~yOsVS&=HG{gI;9OUj$ui z(Jz9&6SS7+80fn!`tLxqtu+2k&`T_O0SbP%MK1w;k43KqU2oB!2EEjxe+x7%aa8_S zK`*!HqoAV}{aw%v7X1UzD=hloL30cMnEI^1+`@Ycm47Gb`z-ol&`lP90(7%Qe*yFc zi~pOTAGGL`pg&^K{|tH~Xf&J2|1Hp)fvY}cn7_AJ^zERxS#%TV?G_ya&9STLKM%SU zw95Ym=r+(=zCQ=uZqa`aIu4qBoc-tDK=)X5Ip%^rpjE!u1@YD|Mx&rYw%ii<2^xWI zHI~xGOf1i6+_GxR56>B@`NMD6hr^29eH)xvCXD}h3 zy@Y!O9uPPna8TfJfu{wY75Ik0O9HP7vtQ8m)*d%bHz-1r6m@3XBM>7q~{?27y}yJ}IzMU{+wC zzh8PIVyPBl?mC2{?^=6gYI_Bf&WGaSyCc`3O}v#_a*$74%b{N!U_@?DuwTA!%Jf`CG1&|_cp?)AMfVVXo@Qq-3|KZP42n1 z+8y#tJP<9xS@N3~c{el@=kX^c%>-ni^yNcB^SrqqXZ@MT#Ko6!Ue3E#oP!!&cqpiFuHh{`D7yBx_FN14gIZ)E8_@M1L!p_@wE#bRzWk9~;Ka=tIeoHrwD~`keoR~mXxcA1rl3i}f zbC zcWTsO4%-y>X~!XF4$AZe=)*ALGfdpTdA9pQsOLG6C%nGOx#XnOaTSiK{c)_f{-)uP zZ^9EdceLSw5w*?y2Ky-TXL(;inT{J>w~mzI2$|(G`dIl<7xp#Qc?5kem)|-wuc{uMao5wOw}>uyOcu~(-LR<__Dl3D>V!M{Q60Ns=ywct&+-t*bNG4IWv(t@tA(^P zCWYnhKedf`uZlW4@3w>6Mxgr>i_ceXE{K)IMd!?n%uPQ%>{XPc=!wrxq2ZU5%Q4@Xa(CuG~9 z?A0bO=^J*tozWA5-9L61IG-a|Wc;E|tM^M-INERe73bBesN2WbUVOf2+uC!khOxcFA`f$J zbv@-tel`zn0P0NKsj*tglXd<)>YVlAuS2!>X1%GsH*vN1j!OBMzs_5wD1+kETX~Ml z+Ks&IclH=mI*2l8U&W)cnmioe8c%s@=S^EzZF`;9D0?ns^BKqI%0{dmwZCz_$$FnB zdDwMYVd7pGtAw3LCEDEI4;WUcADHk0{lJ75=m#gPH7U-k$_It!+GwBP+AnZVRJ}*S zjLuj~cG@(?H0{f{#x!e4tYN(MB<99;j2+eo+q{|SFy_$L#=mcc*GYJxXV`1#M**qF zxzY!{dbaBR@c+1D^sKCp3f1qRiF;wJ3iVr6pne%vsD4d&f%-M!1?o47d;+H5pBifx zeIhb0IIqk=c{op@Uh>v7W}d=N3`}YRu3-vkkL|f%`|liJrnemJJ?wYixI^WhGv@;4 zuADT_;eyz4lK%j3*98ne=5f<)t~?-q;RD)eFDPk_FPJJl^#`eq(B80Y4=I=nFpjKYVnVRRpGg zzmGOHPLhW4AM?fYT?ciH{~~C%-)Z2q@AzF`{O^Ni`|<3E@qY@M_4_))NFVp{pY_p~ zeDweL=qj(Tx%I*KC)80toJD75KPX!SAS1c3vA#`fMA{d(jVTU<4EuxIy4{fk}aV0uKm0BJdm`4re16 z3pEkQAq3q+2)TO*7s7^1!p)ry!p)ry!a1hMUx%?k{zgKCbF47@ISJ>y9)z;IdkHRb zoMVKGVb4Wa>p12P<__47fo8h52_Y|p`M{J<;6}jUotU=?aW2p);aP#^P6b9v&yj|l z0|HM-ytzX`_ywUaOMD&XkQ$^jcO!`JA&vaa-3MrMw*mSD!$EV-A-twErfc%I;(0*0 z5t|r7bB6%FIBCie$mc{5AL8f)sx@D0MdQEx(5 z;vkrE>IH5PxL@EQ!X=J#m=JosD)2HP^teWd^rhIC5rzfU2&^SUx{X3_5&EFehXoEw z_ywU$VY^CsH3Az2ZWdUH=Og1I0_zB2G`2zLxWGLE4+tC-$meSihXR)gahdQo;WBh` z814nJc`hZyU;k_ z^6atsrgH}}1bNL!h^}hvCaGT-p0t($sB;B@Y0M|;w7mX1kYg~;{G>7gDxdp&-~)Dg zcOWa)=!cB1e+ROM%Hmj=YZ_V-`0qftN9LYN--F=Z8AU0ly+8MiNIrf&9tfVi|FF)4 zua_QIVb{&$z0^a`)^cYvJmWzbtUchQ{gjl)KA$0fgTBiw`!D-knB_)Yx_egaU+p-a z#SO@QPWAEc>o9$f>sbTaNY9S(2sp|!6nkI#K{>a;W5S%@*>QSaqV2%^{!z}wP;MiO zX9wP1xX@nGYR}W6H|r0NoATpA^Grj}+t9a<@~mSq^f_deQ}e|XdUUUZ>-hktm+D># z)AIpyr(vIQ$oYUdL$dBTK8!uF)}x+RDvdT6x5}3HZipEc{vRnT>+7pBK6nP`Z@*6H zdN%r+Ig@1leMQdVna)0QS3R0>ZmBr=^&MW|=j){XcrK`CK$H3)^fdP^|L^ze?%tJa zzvCzq_r`pLM!h-I-K%r0=Q=mO!kcv6_=rU_J?&VOUopbz?0xa5HZG1|?)CU=xeUKi z=na6a(3k6B#`9ZL{O3V8fqqWn4*@nJeZA0wfa>^6`3ofgN&EN8BM4)C zP$%Z^-z!%@wmPO?=%e{<0dy z8he{hjOIS<{mcCvDYtFD9ccb{$aC8<-I?mf+Wv;AhUq@(z1wINmdwhOiuS2n+|r$& zW%c&9`c3TI$FD2Uwl!$rC?OUoJwls(8zx|m$C^s4&k1ivpGLdaVBNAoAkU&mcM`(B zVu-Lx_G<{gD)H9{VH;9|K1+U%ZLXV*tsD3`mbreWtsD1km4tZURS|OiP6+-wK<)#c zB!rw+!ien4AZMS19~5|4Am@VMLKNcHbiI8N`l%}w#J}E-VsU&0aa<##I?Xv8asPVz zswE52hL_O4-Y&++zCihebmW`PdYkX#*p4#j9)^bqb}i$`H=XtNcJM{ePq<{|(KN+} z;Yr&??8O4eK8w?Q{p;-r5*A-?Pyf52t5(bB!lv=v&~?dEa?l?sRCElgEQ~2H!p9{XA`6*3L8ciZ7NT-5+9o zk7M zIR^wUjX*ByD!lNqv0jaryJM!K+*!Q;fei$4)&<{_4=-FlwoUk{2fA4~?ITQ`LB7@} z*Wzr4dW#pw59P(|u(*$UISe`THjTcG`*4=`8rF_OXj8U1>3OpLv)6*Mf@ z*2y*8p|Nkx%7quacQT`($j^ihSXpQD9-ZHzslvO|-=4o|Of7X_*)0%>Xa*f1bFm=V?20Y$0rJus@+(%IwEG_>6CZOl_wm^5z&} zzt=F6zeR5@z_S)QXj!o4G&T=&r_gy7_(LLx<^Le+X04@1jfGz@HUqC2`<$TIEU~ZY zeiKvL(G$WGf?eT61mEdfiFnxlaldEA6l`+1|2rUj9P@psv&T>e%4f!#@L{Pj-szLM zwTR4SOJ)EvZz>|w*lJkyxWMW&b1`n%Zs;S`*DN~$9L<$q61p7vm!sWgTKB7*U(t=t z`3CRb-T3}d<^3jXC>7_uKHHr21{^jjIXfk7>po+v@EY=v`GbmbI*_GJo?-d zW7`(f&h#ICWb?Rp+x@QH7;KuT6TgA*lZlD@E0CUZ#&@RCudxR~x!f_tzIAyKY;~N+ zFwePtn`L9a);`XDge6xw`>SU^>g)G*U-zC#R{8vWy;Ywf7SETUm$7reIN|-jjx*K` z$JW|#ZamrjxKQ84n!ucI`1|cStKTvY>eYvSt$mR3+Fu!ub%>cKRF2K3{a@wqzFx?BLfek* zMH?&j6RfMAr+pRUC5vz_F&c3ZSB&xf4hFa~${Hx>}8D;2~cqVzz zOv>Pz#?|pzGe^34my9w`^mokJ&Un(C|GY4^40RZQ4y|Il7|^lo42Gwxix73q5;yBoxi}Jf3Av~-6^Emlv&uOQ@n8Ypy zvVzPQv7xX<8!XeytB^qu5;7NSvi6NCjJOF9>)3Q*`21)`BKQdkHVzPgXcB&{)c-S zJcm3-`a>S&?s>NR=nfzKS-!hGT*_j9!`_z;{^aK|=7;o`dI&Cxt#I@tpgEIB&c{ zh$rq=4od@{$3vJ$MMYljS;qdWAK2*)5^WOuOEJPb#LjU=1F+NnANrSA6BcHuqQT^5kANlD{fv?ax@mj=D zUv<}t==UfXFsyoPK09BPL8!Wsw+@G2yf>g&RFSC{Le>+4J-24AK&f}@-$uos zfUkw;84dSR5Lu10c~58ey@>UB??oi>j_8w87d(4;1pH50XRh}{hB@{yqdpPb{dA4KM*K8kM0UFcYxNQ@G=?8ZC*#AN= z^tHVDE|ebAmwC@90Dg?MJbu1+G7s_GKiYMNzHib{XVuT$r|0(ktY^ME!?b#)$-cpN z8JSlaapoM#-kY*l!iBL%4aqmct8g}pbGMOOkr(?Lb;4L1=X+?}3(tvc8sm8%-(d(g z_YbQ+%*%tslJ=eAJ2WI5I8I(?j@1XPEC&{t7mw=#HLy&-SE{n8jG(o|N1oAn>rjBLcZbCEt+1V*-y0JR$I;z|#U>6?jJAS%I$$JSXrCfx`l?0UCYL zp$HENf~RWaQ% +#include +#include +#include + +//#include "dummyspi.h" +//#warning "For production builds, must not include dummyspi.h" +#include +#include + +int spiChannel = -1; +int spiSpeed = -1; + +void setSpiChannel(int newSpiChannel) { + spiChannel = newSpiChannel; +} + +void setSpiSpeed(int newSpiSpeed) { + spiSpeed = newSpiSpeed; +} + +void initializeSpi() { + //printf("INFO: Initializing SPI\n"); + + if (spiChannel < 0) { + fprintf(stderr, "ERROR: invalid SPI channel %d\n", spiChannel); + exit(EXIT_FAILURE); + } + if (spiSpeed < 0) { + fprintf(stderr, "ERROR: invalid SPI speed %d\n", spiSpeed); + exit(EXIT_FAILURE); + } + + + int fd; + + wiringPiSetup(); + + fd = wiringPiSPISetup(spiChannel, spiSpeed); + if (fd < 0) { + fprintf(stderr, "ERROR: Cannot open SPI bus with error %d, %s\n", + errno, strerror(errno)); + exit(EXIT_FAILURE); + } + + //printf("INFO: Finished initializing SPI\n"); +} + +void ax5043WriteReg(uint16_t reg, uint8_t val) { + uint8_t buf[3]; + int result; + + if (spiChannel < 0) { + fprintf(stderr, "ERROR: invalid SPI channel %d\n", spiChannel); + exit(EXIT_FAILURE); + } + + buf[0] = (unsigned char)(0x00f0 | ((reg & 0xf00) >> 8)); + buf[1] = (reg & 0xff); + buf[2] = val & 0xff; + + result = wiringPiSPIDataRW(spiChannel, buf, sizeof(buf)); + if (result < 0) { + fprintf(stderr, "Failed to write the register with result %d and error %s\n", + result, strerror(result)); + exit(EXIT_FAILURE); + } +} + +uint8_t ax5043ReadReg(uint16_t reg) { + uint8_t buf[3]; + int result; + + if (spiChannel < 0) { + fprintf(stderr, "ERROR: invalid SPI channel %d\n", spiChannel); + exit(EXIT_FAILURE); + } + + buf[0] = (unsigned char)(0x0070 | ((reg & 0xf00) >> 8)); + buf[1] = (reg & 0xff); + buf[2] = 0x0000; + + result = wiringPiSPIDataRW(spiChannel, buf, sizeof(buf)); + if (result < 0) { + fprintf(stderr, "Failed to read register with result = %d and error %s\n", + result, strerror(errno)); + exit(EXIT_FAILURE); + } + + //printf("DEBUG: read value: %d\n", (int)buf[2]); + return (buf[2] & 0xff); +} diff --git a/chat/spi/ax5043spi.h b/chat/spi/ax5043spi.h new file mode 100644 index 00000000..a39b6d4c --- /dev/null +++ b/chat/spi/ax5043spi.h @@ -0,0 +1,17 @@ +// Copyright (c) 2018 Brandenburg Tech, LLC + +#ifndef AX5043SPI_H_ +#define AX5043SPI_H_ + +#include + +#define SPI_CHANNEL (0) +#define SPI_SPEED (32000000) + +void setSpiChannel(int newSpiChannel); +void setSpiSpeed(int newSpiSpeed); +void initializeSpi(); +void ax5043WriteReg(uint16_t reg, uint8_t val); +uint8_t ax5043ReadReg(uint16_t reg); + +#endif /* AX5043SPI_H_ */ diff --git a/probeTxRx/probeTxRx.o b/probeTxRx/probeTxRx.o deleted file mode 100644 index 785fcd50193b67d4834c47f779c1703cce2fdf9f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1840 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