sx1308.cpp

00001 /*
00002  / _____)             _              | |
00003 ( (____  _____ ____ _| |_ _____  ____| |__
00004  \____ \| ___ |    (_   _) ___ |/ ___)  _ \
00005  _____) ) ____| | | || |_| ____( (___| | | |
00006 (______/|_____)_|_|_| \__)_____)\____)_| |_|
00007   (C)2017 Semtech
00008 */
00009 
00010 #include "SX1308.h"
00011 #include "mbed.h"
00012 #include "board.h"
00013 #include "loragw_hal.h"
00014 
00015 #define DELAYSPI 1
00016 
00017 SX1308::SX1308(PinName slaveSelectPin, PinName mosi, PinName miso, PinName sclk, PinName GPIO0, PinName Reset)
00018     : _slaveSelectPin(slaveSelectPin), _spi(mosi, miso, sclk), _interrupt(GPIO0), _reset(Reset) {
00019 
00020 }
00021 
00022 bool SX1308::init() {
00023 #ifdef V2
00024     FEM_EN = 1;
00025 #endif
00026     HSCLKEN = 1;
00027 
00028     dig_reset();
00029 
00030     _slaveSelectPin = 1;
00031     wait_ms(10);
00032     _spi.format(8, 0);
00033     _spi.frequency(8000000);
00034 
00035     _interrupt.fall(this, &SX1308::isr0);
00036 
00037     firsttx = true;
00038     txongoing = 0;
00039     offtmstpstm32 = 0;
00040     timerstm32ref.reset();
00041     timerstm32ref.start();
00042 
00043     return true;
00044 }
00045 
00046 void SX1308::dig_reset() { //init modem for s2lp
00047     _reset = 1;
00048     wait_us(10);
00049     _reset = 0;
00050     wait_us(10);
00051 }
00052 
00053 void SX1308::isr0() {
00054     __disable_irq();
00055     if (txongoing == 1) {
00056         waittxend = 0;
00057     }
00058     __enable_irq();
00059 }
00060 
00061 void SX1308::spiWrite(uint8_t reg, uint8_t val) {
00062     __disable_irq();    // Disable Interrupts
00063     _slaveSelectPin = 0;
00064     wait_us(DELAYSPI);
00065     _spi.write(0x80 | (reg & 0x7F));
00066     _spi.write(val);
00067     wait_us(DELAYSPI);
00068     _slaveSelectPin = 1;
00069     __enable_irq();     // Enable Interrupts
00070 }
00071 
00072 void SX1308::spiWriteBurstF(uint8_t reg, uint8_t * val, int size) {
00073     int i = 0;
00074 
00075     __disable_irq();    // Disable Interrupts
00076     _slaveSelectPin = 0;
00077     wait_us(DELAYSPI);
00078     _spi.write(0x80 | (reg & 0x7F));
00079     for (i = 0; i < size; i++) {
00080         _spi.write(val[i]);
00081     }
00082     __enable_irq();     // Enable Interrupts
00083 }
00084 
00085 void SX1308::spiWriteBurstM(uint8_t reg, uint8_t * val, int size) {
00086     int i = 0;
00087 
00088     __disable_irq();    // Disable Interrupts
00089     for (i = 0; i < size; i++) {
00090         _spi.write(val[i]);
00091     }
00092     __enable_irq();     // Enable Interrupts
00093 }
00094 
00095 void SX1308::spiWriteBurstE(uint8_t reg, uint8_t * val, int size) {
00096     int i = 0;
00097 
00098     __disable_irq();    // Disable Interrupts
00099     for (i = 0; i < size; i++) {
00100         _spi.write(val[i]);
00101     }
00102     wait_us(DELAYSPI);
00103     _slaveSelectPin = 1;
00104     __enable_irq();     // Enable Interrupts
00105 }
00106 
00107 void SX1308::spiWriteBurst(uint8_t reg, uint8_t * val, int size) {
00108     int i = 0;
00109 
00110     __disable_irq();    // Disable Interrupts
00111     _slaveSelectPin = 0;
00112     wait_us(DELAYSPI);
00113     _spi.write(0x80 | (reg & 0x7F));
00114     for (i = 0; i < size; i++) {
00115         _spi.write(val[i]);
00116     }
00117     wait_us(DELAYSPI);
00118     _slaveSelectPin = 1;
00119     __enable_irq();     // Enable Interrupts
00120 }
00121 
00122 uint8_t SX1308::spiRead(uint8_t reg) {
00123     uint8_t val = 0;
00124 
00125     __disable_irq();    // Disable Interrupts
00126     _slaveSelectPin = 0;
00127     wait_us(DELAYSPI);
00128     _spi.write(reg & 0x7F); // The written value is ignored, reg value is read
00129     val = _spi.write(0);
00130     wait_us(DELAYSPI);
00131     _slaveSelectPin = 1;
00132     __enable_irq();     // Enable Interrupts
00133 
00134     return val;
00135 }
00136 
00137 uint8_t SX1308::spiReadBurstF(uint8_t reg, uint8_t *data, int size) {
00138     int i;
00139     uint8_t val = 0;
00140 
00141     __disable_irq();    // Disable Interrupts
00142     _slaveSelectPin = 0;
00143     wait_us(DELAYSPI);
00144     _spi.write(reg & 0x7F); // The written value is ignored, reg value is read
00145     for (i = 0; i < size; i++) {
00146         data[i] = _spi.write(0);
00147     }
00148     __enable_irq();     // Enable Interrupts
00149 
00150     return val;
00151 }
00152 
00153 uint8_t SX1308::spiReadBurstM(uint8_t reg, uint8_t *data, int size) {
00154     int i;
00155     uint8_t val = 0;
00156 
00157     __disable_irq();    // Disable Interrupts
00158     // The written value is ignored, reg value is read
00159     for (i = 0; i < size; i++) {
00160         data[i] = _spi.write(0);
00161     }
00162     __enable_irq();     // Enable Interrupts
00163 
00164     return val;
00165 }
00166 
00167 uint8_t SX1308::spiReadBurstE(uint8_t reg, uint8_t *data, int size) {
00168     int i;
00169     uint8_t val = 0;
00170 
00171     __disable_irq();    // Disable Interrupts
00172     for (i = 0; i < size; i++) {
00173         data[i] = _spi.write(0);
00174     }
00175     wait_us(DELAYSPI);
00176     _slaveSelectPin = 1;
00177     __enable_irq();     // Enable Interrupts
00178 
00179     return val;
00180 }
00181 
00182 uint8_t SX1308::spiReadBurst(uint8_t reg, uint8_t *data, int size) {
00183     int i;
00184     uint8_t val = 0;
00185 
00186     __disable_irq();    // Disable Interrupts
00187     _slaveSelectPin = 0;
00188     wait_us(10);
00189     _spi.write(reg & 0x7F);
00190     for (i = 0; i < size; i++) {
00191         data[i] = _spi.write(0);
00192     }
00193     wait_us(DELAYSPI);
00194     _slaveSelectPin = 1;
00195     __enable_irq();     // Enable Interrupts
00196 
00197     return val;
00198 }