Портирование класса для lt8920 в процессе.

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "LT8920"]
+	path = LT8920
+	url = https://github.com/mengguang/LT8920.git

LT8920

@@ -0,0 +1 @@
+Subproject commit 3d1d9b8baaa2a8a7b3e2097656d00b9c04c24815

modules/debug/usart.c

@@ -0,0 +1,73 @@
+#include "stm32l0xx_hal.h"
+#include "usart.h"
+#include <stdio.h>
+#include <string.h>
+
+#ifdef __GNUC__    
+  #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)    
+#else    
+  #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)    
+#endif  
+
+
+UART_HandleTypeDef UartHandle;
+
+
+PUTCHAR_PROTOTYPE   
+{   
+    UartHandle.Instance->TDR = ch & 0x01FF;
+    //USART2->TDR = ch & 0x01FF;
+    while (__HAL_USART_GET_FLAG(&UartHandle, USART_FLAG_TC) == RESET) {}
+    //while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET) {}   
+    return ch; 
+}  
+
+
+//
+void usart_init(void)
+{
+    GPIO_InitTypeDef  GPIO_InitStruct;
+    
+    HAL_UART_DeInit(&UartHandle);
+    
+    __HAL_RCC_GPIOA_CLK_ENABLE();
+    __HAL_RCC_USART2_CLK_ENABLE();
+    
+    GPIO_InitStruct.Pin       = GPIO_PIN_2;
+    GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull      = GPIO_PULLUP;
+    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
+    GPIO_InitStruct.Alternate = GPIO_AF4_USART2;
+    
+    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+    
+    GPIO_InitStruct.Pin = GPIO_PIN_3;
+    GPIO_InitStruct.Alternate = GPIO_AF4_USART2;
+    
+    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+    
+    UartHandle.Instance        = USART2;
+
+    UartHandle.Init.BaudRate   = 115200;
+    UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
+    UartHandle.Init.StopBits   = UART_STOPBITS_1;
+    UartHandle.Init.Parity     = UART_PARITY_NONE;
+    UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
+    UartHandle.Init.Mode       = UART_MODE_TX_RX;
+    
+    
+    HAL_UART_Init(&UartHandle);
+}
+
+//
+void HAL_UART_MspDeInit(UART_HandleTypeDef *huart)
+{
+    if (huart->Instance == USART2)
+    {
+        __HAL_RCC_USART2_FORCE_RESET();
+        __HAL_RCC_USART2_RELEASE_RESET();
+  
+        HAL_GPIO_DeInit(GPIOA, GPIO_PIN_2);
+        HAL_GPIO_DeInit(GPIOA, GPIO_PIN_3);
+    }
+}

modules/debug/usart.h

@@ -0,0 +1,7 @@
+#ifndef __USART_H
+#define __USART_H
+
+//
+void usart_init(void);
+  
+#endif

modules/lt8920/lt8920.cpp

@@ -0,0 +1,380 @@
+#include "stm32l0xx_hal.h"
+#include "lt8920.h"
+#include "lt8920_trs.h"
+#include <stdio.h>
+
+
+void LT8920::dump_register(uint8_t reg) 
+{
+    uint16_t r = readRegister(reg);
+    printf("reg: %u, value: %X\r\n", reg, r);
+}
+
+LT8920::LT8920(void)
+{
+    _channel = DEFAULT_CHANNEL;
+    
+    LT8920_CS_HIGH;
+}
+
+void LT8920::begin()
+{
+    LT8920_RESET_LOW;
+    HAL_Delay(200);
+    LT8920_RESET_HIGH;
+    HAL_Delay(200);  
+    
+    //setup
+
+    writeRegister(0, 0x6fe0);
+    writeRegister(1, 0x5681);
+    writeRegister(2, 0x6617);
+    writeRegister(4, 0x9cc9);    //why does this differ from powerup (5447)
+    writeRegister(5, 0x6637);    //why does this differ from powerup (f000)
+    writeRegister(8, 0x6c90);    //power (default 71af) UNDOCUMENTED
+    
+    setCurrentControl(4, 0);     // power & gain.
+    
+    writeRegister(10, 0x7ffd);   //bit 0: XTAL OSC enable
+    writeRegister(11, 0x0000);   //bit 8: Power down RSSI (0=  RSSI operates normal)
+    writeRegister(12, 0x0000);
+    writeRegister(13, 0x48bd);   //(default 4855)
+    
+    writeRegister(22, 0x00ff);
+    writeRegister(23, 0x8005);  //bit 2: Calibrate VCO before each Rx/Tx enable
+    writeRegister(24, 0x0067);
+    writeRegister(25, 0x1659);
+    writeRegister(26, 0x19e0);
+    writeRegister(27, 0x1300);  //bits 5:0, Crystal Frequency adjust
+    writeRegister(28, 0x1800);
+    
+    //fedcba9876543210
+    writeRegister(32, 0x5000);  //AAABBCCCDDEEFFFG  A preamble length, B, syncword length, c trailer length, d packet type
+    //                  E FEC_type, F BRCLK_SEL, G reserved
+    //0x5000 = 0101 0000 0000 0000 = preamble 010 (3 bytes), B 10 (48 bits)
+    writeRegister(33, 0x3fc7);
+    writeRegister(34, 0x2000);  //
+    writeRegister(35, 0x0300);  //POWER mode,  bit 8/9 on = retransmit = 3x (default)
+    setSyncWord(0x03805a5a03800380);
+    
+    writeRegister(40, 0x4401);  //max allowed error bits = 0 (01 = 0 error bits)
+    writeRegister(R_PACKETCONFIG, PACKETCONFIG_CRC_ON |
+                  PACKETCONFIG_PACK_LEN_ENABLE | PACKETCONFIG_FW_TERM_TX);
+    
+    writeRegister(42, 0xfdb0);
+    writeRegister(43, 0x000f);
+    
+    //setDataRate(LT8920_1MBPS);
+    
+    writeRegister(R_FIFO, 0x0000);  //TXRX_FIFO_REG (FIFO queue)
+    
+    writeRegister(R_FIFO_CONTROL, 0x8080); //Fifo Rx/Tx queue reset
+    
+    HAL_Delay(200);
+    writeRegister(R_CHANNEL, _BV(CHANNEL_TX_BIT));  //set TX mode.  (TX = bit 8, RX = bit 7, so RX would be 0x0080)
+    HAL_Delay(2);
+    writeRegister(R_CHANNEL, _channel);  // Frequency = 2402 + channel
+}
+
+void LT8920::setChannel(uint8_t channel)
+{
+  _channel = channel;
+  writeRegister(R_CHANNEL,  (_channel & CHANNEL_MASK));
+}
+
+uint8_t LT8920::getChannel()
+{
+  return _channel;
+}
+
+void LT8920::setCurrentControl(uint8_t power, uint8_t gain)
+{
+  writeRegister(R_CURRENT,
+                ((power << CURRENT_POWER_SHIFT) & CURRENT_POWER_MASK) |
+                ((gain << CURRENT_GAIN_SHIFT) & CURRENT_GAIN_MASK));
+}
+
+bool LT8920::setDataRate(DataRate rate)
+{
+  uint16_t newValue;
+
+  switch (rate)
+  {
+    case LT8920_1MBPS:
+      newValue = DATARATE_1MBPS;
+      break;
+    case LT8920_250KBPS:
+      newValue = DATARATE_250KBPS;
+      break;
+    case LT8920_125KBPS:
+      newValue = DATARATE_125KBPS;
+      break;
+    case LT8920_62KBPS:
+      newValue = DATARATE_62KBPS;
+      break;
+    default:
+      return false;
+  }
+
+  writeRegister(R_DATARATE, newValue);
+  return ( (readRegister(R_DATARATE) & DATARATE_MASK) == (newValue & DATARATE_MASK));
+}
+
+LT8920::DataRate LT8920::getDataRate()
+{
+  uint16_t value = readRegister(R_DATARATE) & DATARATE_MASK;
+  switch (value)
+  {
+    case DATARATE_1MBPS:
+      return LT8920_1MBPS;
+    case DATARATE_250KBPS:
+      return LT8920_250KBPS;
+    case DATARATE_125KBPS:
+      return LT8920_125KBPS;
+    case DATARATE_62KBPS:
+      return LT8920_62KBPS;
+  }
+}
+
+uint16_t LT8920::readRegister(uint8_t reg)
+{
+    LT8920_CS_LOW;
+    SPI.transfer(REGISTER_READ | (REGISTER_MASK & reg));
+    uint8_t high = SPI.transfer(0x00);
+    uint8_t low = SPI.transfer(0x00);
+    LT8920_CS_HIGH;
+  
+
+  // Serial.print(reg);
+  // Serial.print(" = ");
+  // Serial.println(high << 8 | low);
+
+  return (high << 8 | low);
+}
+
+uint8_t LT8920::writeRegister(uint8_t reg, uint16_t data)
+{
+  uint8_t high = data >> 8;
+  uint8_t low = data & 0xFF;
+
+  return writeRegister2(reg, high, low);
+}
+
+uint8_t LT8920::writeRegister2(uint8_t reg, uint8_t high, uint8_t low)
+{
+
+  // char sbuf[32];
+  // sprintf_P(sbuf, PSTR("%d => %02x%02x"), reg, high, low);
+  // Serial.println(sbuf);
+
+
+  LT8920_CS_LOW;
+  uint8_t result = SPI.transfer(REGISTER_WRITE | (REGISTER_MASK & reg));
+  SPI.transfer(high);
+  SPI.transfer(low);
+
+  LT8920_CS_HIGH;
+  return result;
+}
+
+void LT8920::sleep()
+{
+  //set bit 14 on register 35.
+  writeRegister(35, readRegister(35) | _BV(14));
+}
+
+void LT8920::whatsUp(void)
+{
+  uint16_t mode = readRegister(R_CHANNEL);
+  
+#if 0  
+  print("\nTx_EN=");
+  println((mode & _BV(CHANNEL_TX_BIT)) != false);
+  print("Rx_EN=");
+  println((mode & _BV(CHANNEL_RX_BIT)) != false);
+  print("Channel=");
+  println(mode & CHANNEL_MASK);
+#endif
+  
+  //read the status register.
+  uint16_t state = readRegister(R_STATUS);
+
+  bool crc_error = state & _BV(15);
+  bool fec23_error = state & _BV(14);
+  uint8_t framer_st = (state & 0b0011111100000000) >> 8;
+  bool pkt_flag = state & _BV(6);
+  bool fifo_flag = state & _BV(5);
+
+#if 0  
+  stream.print("CRC=");
+  stream.println(crc_error);
+  stream.print("FEC=");
+  stream.println(fec23_error);
+  stream.print("FRAMER_ST=");
+  stream.println(framer_st);
+  stream.print("PKT=");
+  stream.println(pkt_flag);
+  stream.print("FIFO=");
+  stream.println(fifo_flag);
+#endif
+  
+  uint16_t fifo = readRegister(R_FIFO_CONTROL);
+#if 0
+  stream.print("FIFO_WR_PTR=");
+  stream.println((fifo >> 8) & 0b111111);
+  stream.print("FIFO_RD_PTR=");
+  stream.println(fifo & 0b111111);
+#endif  
+}
+
+bool LT8920::available()
+{
+  //read the PKT_FLAG state; this can also be done with a hard wire.
+
+  if (LT8920_GET_PKT != 0)
+  {
+    return true;
+  }
+
+  return false;
+}
+
+int LT8920::read(uint8_t *buffer, size_t maxBuffer)
+{
+  uint16_t value = readRegister(R_STATUS);
+  if (bitRead(value, STATUS_CRC_BIT) == 0)
+  {
+    //CRC ok
+
+    uint16_t data = readRegister(R_FIFO);
+    uint8_t packetSize = data >> 8;
+    if(maxBuffer < packetSize+1)
+    {
+        //BUFFER TOO SMALL
+        return -2;
+    }
+
+    uint8_t pos;
+    buffer[pos++] = (data & 0xFF);
+    while (pos < packetSize)
+    {
+      data = readRegister(R_FIFO);
+      buffer[pos++] = data >> 8;
+      buffer[pos++] = data & 0xFF;
+    }
+
+    return packetSize;
+  }
+  else
+  {
+    //CRC error
+    return -1;
+  }
+}
+
+void LT8920::startListening()
+{
+  writeRegister(R_CHANNEL, _channel & CHANNEL_MASK);   //turn off rx/tx
+  HAL_Delay(3);
+  writeRegister(R_FIFO_CONTROL, 0x0080);  //flush rx
+  writeRegister(R_CHANNEL,  (_channel & CHANNEL_MASK) | _BV(CHANNEL_RX_BIT));   //enable RX
+  HAL_Delay(5);
+}
+
+/* set the BRCLK_SEL value */
+void LT8920::setClock(uint8_t clock)
+{
+  //register 32, bits 3:1.
+  uint16_t val = readRegister(35);
+  val &= 0b1111111111110001;
+  val |= ((clock & 0x07) << 1);;
+
+  writeRegister(35, val);
+}
+
+bool LT8920::sendPacket(uint8_t *data, size_t packetSize)
+{
+  if (packetSize < 1 || packetSize > 255)
+  {
+    return false;
+  }
+
+  writeRegister(R_CHANNEL, 0x0000);
+  writeRegister(R_FIFO_CONTROL, 0x8000);  //flush tx
+
+  //packets are sent in 16bit words, and the first word will be the packet size.
+  //start spitting out words until we are done.
+
+  uint8_t pos = 0;
+  writeRegister2(R_FIFO, packetSize, data[pos++]);
+  while (pos < packetSize)
+  {
+    uint8_t msb = data[pos++];
+    uint8_t lsb = data[pos++];
+
+    writeRegister2(R_FIFO, msb, lsb);
+  }
+
+  writeRegister(R_CHANNEL,  (_channel & CHANNEL_MASK) | _BV(CHANNEL_TX_BIT));   //enable TX
+
+  //Wait until the packet is sent.
+  while (LT8920_GET_PKT == 0)
+  {
+      //do nothing.
+  }
+
+  return true;
+}
+
+void LT8920::setSyncWord(uint64_t syncWord)
+{
+  writeRegister(R_SYNCWORD1, syncWord);
+  writeRegister(R_SYNCWORD2, syncWord >> 16);
+  writeRegister(R_SYNCWORD3, syncWord >> 32);
+  writeRegister(R_SYNCWORD4, syncWord >> 48);
+}
+
+void LT8920::setSyncWordLength(uint8_t option)
+{
+  option &= 0x03;
+  option <<= 11;
+
+  writeRegister(32, (readRegister(32) & 0b0001100000000000) | option);
+}
+
+uint8_t LT8920::getRSSI()
+{
+    //RSSI: 15:10
+    uint16_t value = readRegister(6);
+
+    return (value >> 10);
+}
+
+void LT8920::scanRSSI(uint16_t *buffer, uint8_t start_channel, uint8_t num_channels)
+{
+    // writeRegister(R_CHANNEL, _BV(CHANNEL_RX_BIT));
+    //
+    // //add read mode.
+    writeRegister(R_FIFO_CONTROL, 0x8080);  //flush rx
+    // writeRegister(R_CHANNEL, 0x0000);
+
+    //set number of channels to scan.
+    writeRegister(42, (readRegister(42) & 0b0000001111111111) | ((num_channels-1 & 0b111111) << 10));
+
+    //set channel scan offset.
+    writeRegister(43, (readRegister(43) & 0b0000000011111111) | ((start_channel & 0b1111111) << 8));
+    writeRegister(43, (readRegister(43) & 0b0111111111111111) | _BV(15));
+
+    while (LT8920_GET_PKT == 0)
+    {
+    }
+
+
+    //read the results.
+     uint8_t pos = 0;
+    while(pos < num_channels)
+    {
+      uint16_t data = readRegister(R_FIFO);
+      buffer[pos++] = data >> 8;
+    }
+}

modules/lt8920/lt8920.h

@@ -0,0 +1,187 @@
+#ifndef __LT8920_H
+#define __LT8920_H
+
+
+#define REGISTER_READ       0b10000000  //bin
+#define REGISTER_WRITE      0b00000000  //bin
+#define REGISTER_MASK       0b01111111  //bin
+
+#define R_CHANNEL           7
+#define CHANNEL_RX_BIT      7
+#define CHANNEL_TX_BIT      8
+#define CHANNEL_MASK        0b01111111  //bin
+#define DEFAULT_CHANNEL     0x31
+
+#define R_CURRENT           9
+#define CURRENT_POWER_SHIFT 12
+#define CURRENT_POWER_MASK  0b1111000000000000
+#define CURRENT_GAIN_SHIFT  7
+#define CURRENT_GAIN_MASK   0b0000011110000000
+
+#define R_DATARATE          44
+#define DATARATE_MASK       0xFF00
+#define DATARATE_1MBPS      0x0101
+#define DATARATE_250KBPS    0x0401
+#define DATARATE_125KBPS    0x0801
+#define DATARATE_62KBPS     0x1001
+
+#define R_SYNCWORD1         36
+#define R_SYNCWORD2         37
+#define R_SYNCWORD3         38
+#define R_SYNCWORD4         39
+
+#define R_PACKETCONFIG      41
+#define PACKETCONFIG_CRC_ON             0x8000
+#define PACKETCONFIG_SCRAMBLE_ON        0x4000
+#define PACKETCONFIG_PACK_LEN_ENABLE    0x2000
+#define PACKETCONFIG_FW_TERM_TX         0x1000
+#define PACKETCONFIG_AUTO_ACK           0x0800
+#define PACKETCONFIG_PKT_FIFO_POLARITY  0x0400
+
+#define R_STATUS            48
+#define STATUS_CRC_BIT      15
+
+
+#define R_FIFO              50
+#define R_FIFO_CONTROL      52
+
+
+
+class LT8920
+{
+  public:
+    /** Data Data */
+    enum DataRate
+    {
+      LT8920_1MBPS,     /** default transmit rate */
+      LT8920_250KBPS,   /** 250 Kpbs, only on lt8910 */
+      LT8920_125KBPS,   /** 125 Kbps, only on lt8910 */
+      LT8920_62KBPS     /** 62 Kbps, only on lt8910 */
+    };
+
+  private:
+    uint8_t _pin_chipselect;
+    uint8_t _pin_pktflag;
+    uint8_t _pin_reset;
+    uint8_t _channel;
+
+  public:
+    /** Construct a new instance
+     * @param cs Chip Select, this is the SLAVE SELECT pin. Please note that it is a different location than the NRF24L01+ SS pin.
+     * @param pkt PKT_flag input signal pin. Comparable to the NRF24L01+ IRQ pin.
+     * @param rst RESET pin. Use 0 to disable.
+    */
+    LT8920(void);
+
+    /** Configures the module for initial use */
+    void begin();
+
+    /**
+    * @param channel has significant 7 bits
+    */
+    void setChannel(uint8_t channel);
+    /** Retrieve the current channel */
+    uint8_t getChannel();
+
+    /** Set power and gain
+    * @param power 0-0xf
+    * @param gain 0-0xf
+    */
+    void setCurrentControl(uint8_t power, uint8_t gain);
+
+    /** Sets the data rate
+    * @param rate the transmission/reception speed
+    * @returns true when the data rate was succesfully changed.
+    */
+    bool setDataRate(DataRate rate);
+
+    /** Returns the data rate
+    * @returns the active data rate.
+    */
+    DataRate getDataRate();
+
+    /** Read the value of a register
+    * @param reg
+    */
+    uint16_t readRegister(uint8_t reg);
+
+    /** Writes to a register
+    * @param reg The register to write to
+    * @param data 16bits of data, MSB first */
+    uint8_t writeRegister(uint8_t reg, uint16_t data);
+
+    /** Writes to a register, one byte at a time.
+    * This is a convenience function, because the LT8920 uses 16 bits registers with all 16 bits written at once.
+    * @param reg The register to write to
+    * @param high bits 15..8
+    * @param low bits 7..0  */
+    uint8_t writeRegister2(uint8_t reg, uint8_t high, uint8_t low);
+
+	void dump_register(uint8_t reg);
+	
+    /** Put the LT8920 module to sleep mode.
+     * In contrast to POWER DOWN, this mode will keep the register values
+     * Any SPI call will awaken the module automatically */
+    void sleep();
+
+    /** Dumps debug information on the selected port
+    * @param stream the output stream to use as output, eg. `whatsUp(&Serial);`
+    */
+    //void whatsUp(Stream &stream);
+    void whatsUp(void);
+
+    /** Signals a packet ready in the FIFO queue */
+    bool available();
+
+    /** Read a packet into the buffer
+    * @param buffer a pointer to a buffer large enough to hold the packet
+    * @param maxBuffer the maximum size of the buffer. Any bytes left over in the buffer will be dropped.
+    * @returns the size of the packet that was read, -1 for CRC error
+    */
+    int read(uint8_t *buffer, size_t maxBuffer);
+
+    /** Switch the module to RX mode */
+    void startListening();
+
+    /** Sets the internal clock divider
+   * @param clock
+   */
+    void setClock(uint8_t clock);
+
+    /** Sends a packet
+    * This call blocks until the packet was sent and the Tx Buffer has been completed
+    * @param data
+    * @param packetSize
+    * @returns true when the packet was sent, or false when the packetSize was invalid.
+    */
+    bool sendPacket(uint8_t *data, size_t packetSize);
+
+    /** Set Syncword
+    * @param syncWord 64 bits of sync word settings.
+    * @see setSyncwordLength
+    */
+    void setSyncWord(uint64_t syncWord);
+
+    /** Sets the length of the sync word used
+     * @param length:
+     *          11 = 64bits, 10 = 48 bits, 01 = 32 bits, 00 = 16 bits
+     * @see Check the datasheet for which bits are actually used.
+     */
+    void setSyncWordLength(uint8_t length);
+
+    /** Scan the signal strength for one or more channels
+    * @param buffer points to a buffer to store the signal strengths, at least num_channels
+    * @param start_channel starting channel to scan, where Frequency = 2402 + channel
+    * @param num_channels number of channels to scan in this batch, for example scanning 4 channels
+    *                     with start 2480 will scan 2480, 2481, 2482, 2483
+    */
+    void scanRSSI(uint16_t *buffer, uint8_t start_channel, uint8_t num_channels);
+
+    /** retrieve the analog signal strength for the current channel */
+    uint8_t getRSSI();
+};
+
+
+#define _BV(bit) (1 << (bit))
+
+#endif

modules/lt8920/lt8920_trs.cpp

@@ -0,0 +1,116 @@
+#include "stm32l0xx_hal.h"
+#include "lt8920_trs.h"
+#include "stm32l0xx_nucleo.h"
+#include <stdio.h>
+
+SPI_HandleTypeDef SpiHandle;
+
+
+//
+void lt_init(void)
+{
+    lt_gpio_init();
+    
+    lt_spi_gpio_init();
+    
+    lt_spi_init();
+}
+
+//
+void lt_spi_init(void)
+{
+    __HAL_RCC_SPI2_CLK_ENABLE();
+    
+    SpiHandle.Instance               = SPI2;
+    SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
+    SpiHandle.Init.Direction         = SPI_DIRECTION_2LINES;
+    SpiHandle.Init.CLKPhase          = SPI_PHASE_1EDGE;
+    SpiHandle.Init.CLKPolarity       = SPI_POLARITY_HIGH;
+    SpiHandle.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;
+    SpiHandle.Init.CRCPolynomial     = 7;
+    SpiHandle.Init.DataSize          = SPI_DATASIZE_8BIT;
+    SpiHandle.Init.FirstBit          = SPI_FIRSTBIT_MSB;
+    SpiHandle.Init.NSS               = SPI_NSS_SOFT;
+    SpiHandle.Init.TIMode            = SPI_TIMODE_DISABLE;
+    SpiHandle.Init.Mode = SPI_MODE_MASTER;
+
+    HAL_SPI_Init(&SpiHandle);
+      
+}
+
+//
+void lt_gpio_init(void)
+{
+    GPIO_InitTypeDef  GPIO_InitStruct;
+    
+    __HAL_RCC_GPIOB_CLK_ENABLE();
+        
+    // LT8920 Reset pin PB2
+    GPIO_InitStruct.Pin       = GPIO_PIN_2;
+    GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
+    GPIO_InitStruct.Pull      = GPIO_PULLUP;
+    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH  ;
+    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+    
+    // LT8920 PKT pin PB12
+    GPIO_InitStruct.Pin       = GPIO_PIN_12;
+    GPIO_InitStruct.Mode      = GPIO_MODE_INPUT;
+    GPIO_InitStruct.Pull      = GPIO_PULLUP;
+    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH  ;
+    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+}
+
+//
+void lt_spi_gpio_init(void)
+{
+    GPIO_InitTypeDef  GPIO_InitStruct;
+    
+    __HAL_RCC_GPIOB_CLK_ENABLE();
+    
+    // SPI SCK PB_13
+    GPIO_InitStruct.Pin       = GPIO_PIN_13;
+    GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull      = GPIO_PULLUP;
+    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH  ;
+    GPIO_InitStruct.Alternate = GPIO_AF0_SPI2;
+    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+    
+    // SPI MISO PB14
+    GPIO_InitStruct.Pin = GPIO_PIN_14;
+    GPIO_InitStruct.Alternate = GPIO_AF0_SPI2;
+    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+  
+    // SPI MOSI PB15
+    GPIO_InitStruct.Pin = GPIO_PIN_15;
+    GPIO_InitStruct.Alternate = GPIO_AF0_SPI2;
+    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+    
+    // SPI CS PB1
+    GPIO_InitStruct.Pin       = GPIO_PIN_1;
+    GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
+    GPIO_InitStruct.Pull      = GPIO_PULLUP;
+    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH  ;
+    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+}
+ 
+
+// -------------------------------------------------------------------------- //
+
+//
+void lt_spi_test(void)
+{
+    uint8_t tx_buf[12] = "hello world";
+    uint8_t rx_buf[12] = {0};
+    
+    if (HAL_SPI_TransmitReceive(&SpiHandle, tx_buf, rx_buf, 11, 1000) != HAL_OK) 
+    {
+        printf("[SPI] tx/rx error\r\n");
+        BSP_LED_On(LED2);
+    }
+    else 
+    {
+        printf("[SPI] rx: %s\r\n", rx_buf);
+        printf("[SPI] tx/rx OK\r\n");
+        BSP_LED_Toggle(LED2);
+    }
+}

modules/lt8920/lt8920_trs.h

@@ -0,0 +1,30 @@
+#ifndef __LT8920_TRS_H
+#define __LT8920_TRS_H
+
+
+#define LT8920_CS_HIGH      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_SET) 
+#define LT8920_CS_LOW       HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_RESET) 
+
+#define LT8920_RESET_HIGH   HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_SET) 
+#define LT8920_RESET_LOW    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_RESET) 
+
+#define LT8920_GET_PKT      (uint8_t)HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_12)
+
+//
+void lt_init(void);
+
+//
+void lt_spi_init(void);
+
+//
+void lt_gpio_init(void);
+
+//
+void lt_spi_gpio_init(void);
+
+// -------------------------------------------------------------------------- //
+
+//
+void lt_spi_test(void);
+
+#endif

project/ewarm/lt8920.ewp

@@ -49,16 +49,16 @@
                 <option>
                     <name>GRuntimeLibSelect</name>
                     <version>0</version>
-                    <state>1</state>
+                    <state>2</state>
                 </option>
                 <option>
                     <name>GRuntimeLibSelectSlave</name>
                     <version>0</version>
-                    <state>1</state>
+                    <state>2</state>
                 </option>
                 <option>
                     <name>RTDescription</name>
-                    <state>Use the normal configuration of the C/C++ runtime library. No locale interface, C locale, no file descriptor support, no multibytes in printf and scanf, and no hex floats in strtod.</state>
+                    <state>Use the full configuration of the C/C++ runtime library. Full locale interface, C locale, file descriptor support, multibytes in printf and scanf, and hex floats in strtod.</state>
                 </option>
                 <option>
                     <name>OGProductVersion</name>
@@ -112,7 +112,7 @@
                 </option>
                 <option>
                     <name>RTConfigPath2</name>
-                    <state>$TOOLKIT_DIR$\inc\c\DLib_Config_Normal.h</state>
+                    <state>$TOOLKIT_DIR$\inc\c\DLib_Config_Full.h</state>
                 </option>
                 <option>
                     <name>GBECoreSlave</name>
@@ -121,7 +121,7 @@
                 </option>
                 <option>
                     <name>OGUseCmsis</name>
-                    <state>0</state>
+                    <state>1</state>
                 </option>
                 <option>
                     <name>OGUseCmsisDspLib</name>
@@ -354,8 +354,9 @@
                     <state>$PROJ_DIR$/../../libs/stm32/system</state>
                     <state>$PROJ_DIR$/../../libs/stm32/cmsis</state>
                     <state>$PROJ_DIR$/../../user</state>
-                    <state>$PROJ_DIR$/../../modules</state>
                     <state>$PROJ_DIR$/../../modules/bsp</state>
+                    <state>$PROJ_DIR$/../../modules/debug</state>
+                    <state>$PROJ_DIR$/../../modules/lt8920</state>
                 </option>
                 <option>
                     <name>CCStdIncCheck</name>
@@ -371,7 +372,7 @@
                 </option>
                 <option>
                     <name>CCOptLevel</name>
-                    <state>1</state>
+                    <state>0</state>
                 </option>
                 <option>
                     <name>CCOptStrategy</name>
@@ -380,7 +381,7 @@
                 </option>
                 <option>
                     <name>CCOptLevelSlave</name>
-                    <state>1</state>
+                    <state>0</state>
                 </option>
                 <option>
                     <name>CompilerMisraRules98</name>
@@ -2279,9 +2280,27 @@
     </group>
     <group>
         <name>modules</name>
-        <file>
-            <name>$PROJ_DIR$\..\..\modules\bsp\stm32l0xx_nucleo.c</name>
-        </file>
+        <group>
+            <name>bsp</name>
+            <file>
+                <name>$PROJ_DIR$\..\..\modules\bsp\stm32l0xx_nucleo.c</name>
+            </file>
+        </group>
+        <group>
+            <name>debug</name>
+            <file>
+                <name>$PROJ_DIR$\..\..\modules\debug\usart.c</name>
+            </file>
+        </group>
+        <group>
+            <name>lt8920</name>
+            <file>
+                <name>$PROJ_DIR$\..\..\modules\lt8920\lt8920.cpp</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\..\modules\lt8920\lt8920_trs.cpp</name>
+            </file>
+        </group>
     </group>
     <group>
         <name>user</name>

project/ewarm/lt8920.ewt

@@ -2539,9 +2539,27 @@
     </group>
     <group>
         <name>modules</name>
-        <file>
-            <name>$PROJ_DIR$\..\..\modules\bsp\stm32l0xx_nucleo.c</name>
-        </file>
+        <group>
+            <name>bsp</name>
+            <file>
+                <name>$PROJ_DIR$\..\..\modules\bsp\stm32l0xx_nucleo.c</name>
+            </file>
+        </group>
+        <group>
+            <name>debug</name>
+            <file>
+                <name>$PROJ_DIR$\..\..\modules\debug\usart.c</name>
+            </file>
+        </group>
+        <group>
+            <name>lt8920</name>
+            <file>
+                <name>$PROJ_DIR$\..\..\modules\lt8920\lt8920.cpp</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\..\modules\lt8920\lt8920_trs.cpp</name>
+            </file>
+        </group>
     </group>
     <group>
         <name>user</name>

user/main.cpp

@@ -1,6 +1,8 @@
 #include "stm32l0xx_hal.h"
 #include "stm32l0xx_nucleo.h"
-
+#include "usart.h"
+#include "lt8920_trs.h"
+#include <stdio.h>
 
 void clock_hsi_init(void);
 static void Error_Handler(void);
@@ -16,9 +18,15 @@ int main()
     
     BSP_LED_Init(LED2);
     
+    usart_init();
+    printf("Controller starting...\r\n");
+    
+    lt_init();
+    
     while (1)
     {
         BSP_LED_Toggle(LED2);
+        //lt_spi_test();
         HAL_Delay(1000);
     }
 }

user/stm32l0xx_hal_conf.h

@@ -37,7 +37,7 @@
 /*#define HAL_CRC_MODULE_ENABLED */ 
 /*#define HAL_CRYP_MODULE_ENABLED */ 
 /*#define HAL_DAC_MODULE_ENABLED */  
-/*#define HAL_DMA_MODULE_ENABLED */
+#define HAL_DMA_MODULE_ENABLED 
 /*#define HAL_FIREWALL_MODULE_ENABLED */
 #define HAL_FLASH_MODULE_ENABLED 
 #define HAL_GPIO_MODULE_ENABLED 
@@ -50,11 +50,11 @@
 #define HAL_RCC_MODULE_ENABLED 
 /*#define HAL_RNG_MODULE_ENABLED */
 /*#define HAL_RTC_MODULE_ENABLED */
-/*#define HAL_SPI_MODULE_ENABLED */  
+#define HAL_SPI_MODULE_ENABLED
 /*#define HAL_TIM_MODULE_ENABLED */  
 /*#define HAL_TSC_MODULE_ENABLED */
-/*#define HAL_UART_MODULE_ENABLED */
-/*#define HAL_USART_MODULE_ENABLED */
+#define HAL_UART_MODULE_ENABLED 
+#define HAL_USART_MODULE_ENABLED
 /*#define HAL_IRDA_MODULE_ENABLED */
 /*#define HAL_SMARTCARD_MODULE_ENABLED */
 /*#define HAL_SMBUS_MODULE_ENABLED */