uint8_t SelectorGetValue( void )
{
uint8_t i = 0;
uint8_t j = 0;
uint8_t k = 255;
// Active
GpioInit( &Sel1, SEL_1, PIN_INPUT, PIN_PUSH_PULL, PIN_PULL_UP, 0 );
GpioInit( &Sel2, SEL_2, PIN_INPUT, PIN_PUSH_PULL, PIN_PULL_UP, 0 );
GpioInit( &Sel3, SEL_3, PIN_INPUT, PIN_PUSH_PULL, PIN_PULL_UP, 0 );
GpioInit( &Sel4, SEL_4, PIN_INPUT, PIN_PUSH_PULL, PIN_PULL_UP, 0 );
do
{
j = i;
k = j;
// 1 ms delay between checks
DelayMs( 1 );
i = !GpioRead( &Sel1 );
i += 2 * !GpioRead( &Sel2 );
i += 4 * !GpioRead( &Sel3 );
i += 8 * !GpioRead( &Sel4 );
} while( ( i != j ) && ( i != k ) ); // Waits for 3 successive values to be equal
// Sleep
GpioInit( &Sel1, SEL_1, PIN_OUTPUT, PIN_OPEN_DRAIN, PIN_NO_PULL, 0 );
GpioInit( &Sel2, SEL_2, PIN_OUTPUT, PIN_OPEN_DRAIN, PIN_NO_PULL, 0 );
GpioInit( &Sel3, SEL_3, PIN_OUTPUT, PIN_OPEN_DRAIN, PIN_NO_PULL, 0 );
GpioInit( &Sel4, SEL_4, PIN_OUTPUT, PIN_OPEN_DRAIN, PIN_NO_PULL, 0 );
return i;
}
void buttons_step()
{
if (config.gui.disp_flags & CFG_DISP_FLIP)
{
button_handle(2, GpioRead(SWITCH1));
button_handle(0, GpioRead(SWITCH3));
}
else
{
button_handle(0, GpioRead(SWITCH1));
button_handle(2, GpioRead(SWITCH3));
}
button_handle(1, GpioRead(SWITCH2));
if (buttons_state[0] > BS_IDLE || buttons_state[1] > BS_IDLE || buttons_state[2] > BS_IDLE)
button_lock.Lock();
else
button_lock.Unlock();
}
void BoardInitMcu( void )
{
Gpio_t ioPin;
if( McuInitialized == false )
{
HAL_Init( );
// LEDs
GpioInit( &Led1, LED_1, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &Led2, LED_2, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &Led3, LED_3, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, Led3Status );
SystemClockConfig( );
GpioInit( &ioPin, UART_RX, PIN_INPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
if( GpioRead( &ioPin ) == 1 ) // Debug Mode
{
UsbIsConnected = true;
FifoInit( &Uart1.FifoTx, UartTxBuffer, UART_FIFO_TX_SIZE );
FifoInit( &Uart1.FifoRx, UartRxBuffer, UART_FIFO_RX_SIZE );
// Configure your terminal for 8 Bits data (7 data bit + 1 parity bit), no parity and no flow ctrl
UartInit( &Uart1, UART_1, UART_TX, UART_RX );
UartConfig( &Uart1, RX_TX, 115200, UART_8_BIT, UART_1_STOP_BIT, NO_PARITY, NO_FLOW_CTRL );
}
else
{
UsbIsConnected = false;
UartDeInit( &Uart1 );
}
RtcInit( );
BoardUnusedIoInit( );
}
else
{
SystemClockReConfig( );
}
I2cInit( &I2c, I2C_SCL, I2C_SDA );
AdcInit( &Adc, BAT_LEVEL_PIN );
SpiInit( &SX1272.Spi, RADIO_MOSI, RADIO_MISO, RADIO_SCLK, NC );
SX1272IoInit( );
if( McuInitialized == false )
{
McuInitialized = true;
if( GetBoardPowerSource( ) == BATTERY_POWER )
{
CalibrateSystemWakeupTime( );
}
}
}
uint8_t SX126xGetPaSelect( uint32_t channel )
{
if( GpioRead( &DeviceSel ) == 1 )
{
return SX1261;
}
else
{
return SX1262;
}
}
void testPCO( void )
{
printf("----------------\n");
printf("ON_TEST_INTERUPT\n");
printf("----------------\n");
if(GpioRead( &Led2 ) == 0){
GpioWrite( &Led2, 1 );
}else{
GpioWrite( &Led2, 0 );
}
}
int main(void)
{
I2cInit( &I2c, I2C_SCL, I2C_SDA );
GpioInit( &UsbDetect, USB_ON, PIN_INPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DcDcEnable, DC_DC_EN, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &RadioPushButton, RADIO_PUSH_BUTTON, PIN_INPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &Led1, LED_1, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &Led2, LED_2, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &Led3, LED_3, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &Led4, LED_4, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
if( GpioRead( &RadioPushButton ) == 0 )
{ /* Test if user code is programmed starting from address 0x8003000 */
if( ( ( *( volatile uint32_t* )ApplicationAddress ) & 0x2FFE0000 ) == 0x20000000 )
{ /* Jump to user application */
JumpAddress = *( volatile uint32_t* )( ApplicationAddress + 4 );
Jump_To_Application = ( pFunction ) JumpAddress;
/* Initialize user application's Stack Pointer */
__set_MSP( *( volatile uint32_t* ) ApplicationAddress );
Jump_To_Application( );
}
} /* Otherwise enters DFU mode to allow user to program his application */
/* Enter DFU mode */
DeviceState = STATE_dfuERROR;
DeviceStatus[0] = STATUS_ERRFIRMWARE;
DeviceStatus[4] = DeviceState;
UsbMcuInit( );
/* Main loop */
while (1)
{
GpioWrite( &Led1, 0 );
GpioWrite( &Led2, 0 );
GpioWrite( &Led3, 0 );
GpioWrite( &Led4, 0 );
DelayLoop( 500 );
GpioWrite( &Led1, 1 );
GpioWrite( &Led2, 1 );
GpioWrite( &Led3, 1 );
GpioWrite( &Led4, 1 );
DelayLoop( 500 );
}
}
void BoardDeInitMcu( void )
{
Gpio_t ioPin;
I2cDeInit( &I2c );
SpiDeInit( &SX1272.Spi );
SX1272IoDeInit( );
GpioInit( &Led1, LED_1, PIN_ANALOGIC, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &Led2, LED_2, PIN_ANALOGIC, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
Led3Status = GpioRead( &Led3 );
if( Led3Status == 1 )
{
GpioInit( &Led3, LED_3, PIN_ANALOGIC, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
}
GpioInit( &Sel1, SEL_1, PIN_OUTPUT, PIN_OPEN_DRAIN, PIN_NO_PULL, 0 );
GpioInit( &Sel2, SEL_2, PIN_OUTPUT, PIN_OPEN_DRAIN, PIN_NO_PULL, 0 );
GpioInit( &Sel3, SEL_3, PIN_OUTPUT, PIN_OPEN_DRAIN, PIN_NO_PULL, 0 );
GpioInit( &Sel4, SEL_4, PIN_OUTPUT, PIN_OPEN_DRAIN, PIN_NO_PULL, 0 );
#if ( defined( USE_DEBUG_PINS ) && !defined( LOW_POWER_MODE_ENABLE ) )
GpioInit( &DbgPin1, J5_1, PIN_ANALOGIC, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin2, J5_2, PIN_ANALOGIC, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin3, J5_3, PIN_ANALOGIC, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin4, J5_4, PIN_ANALOGIC, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
#endif
GpioInit( &ioPin, OSC_HSE_IN, PIN_ANALOGIC, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &ioPin, OSC_HSE_OUT, PIN_ANALOGIC, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &ioPin, OSC_LSE_IN, PIN_INPUT, PIN_PUSH_PULL, PIN_PULL_DOWN, 1 );
GpioInit( &ioPin, OSC_LSE_OUT, PIN_INPUT, PIN_PUSH_PULL, PIN_PULL_DOWN, 1 );
McuInitialized = false;
}
void SX126xWaitOnBusy( void )
{
while( GpioRead( &SX126x.BUSY ) == 1 );
}
void BoardInitMcu( void )
{
if( McuInitialized == false )
{
#if defined( USE_BOOTLOADER )
// Set the Vector Table base location at 0x3000
NVIC_SetVectorTable( NVIC_VectTab_FLASH, 0x3000 );
#endif
// We use IRQ priority group 4 for the entire project
// When setting the IRQ, only the preemption priority is used
NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
// Disable Systick
SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk; // Systick IRQ off
SCB->ICSR |= SCB_ICSR_PENDSTCLR_Msk; // Clear SysTick Exception pending flag
I2cInit( &I2c, I2C_SCL, I2C_SDA );
AdcInit( &Adc, BAT_LEVEL );
SpiInit( &SX1272.Spi, RADIO_MOSI, RADIO_MISO, RADIO_SCLK, NC );
SX1272IoInit( );
#if defined( USE_DEBUG_PINS )
GpioInit( &DbgPin1, CON_EXT_1, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin2, CON_EXT_3, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin3, CON_EXT_7, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin4, CON_EXT_9, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
#endif
#if defined( USE_USB_CDC )
{
Gpio_t usbDM;
GpioInit( &usbDM, USB_DM, PIN_INPUT, PIN_PUSH_PULL, PIN_PULL_UP, 0 );
if( GpioRead( &usbDM ) == 0 )
{
TimerSetLowPowerEnable( false );
UsbMcuInit( );
UartInit( &UartUsb, UART_USB_CDC, NC, NC );
UartConfig( &UartUsb, RX_TX, 115200, UART_8_BIT, UART_1_STOP_BIT, NO_PARITY, NO_FLOW_CTRL );
}
else
{
TimerSetLowPowerEnable( true );
GpioInit( &usbDM, USB_DM, PIN_ANALOGIC, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
}
}
#elif defined( LOW_POWER_MODE_ENABLE )
TimerSetLowPowerEnable( true );
#else
TimerSetLowPowerEnable( false );
#endif
BoardUnusedIoInit( );
if( TimerGetLowPowerEnable( ) == true )
{
RtcInit( );
}
else
{
TimerHwInit( );
}
McuInitialized = true;
}
}
bool storage_init()
{
uint8_t res;
GpioSetPull(SD_IN, gpio_pull_up);
GpioSetDirection(SD_IN, INPUT);
DEBUG("SD_IN %d\n", GpioRead(SD_IN));
if (!SD_CARD_DETECT)
return false;
//power spi & sdcard
SD_EN_ON;
SD_SPI_PWR_ON;
DEBUG("Mounting SD card ... ");
for (uint8_t i = 0; i < 5; i++)
{
//power spi & sdcard
SD_EN_ON;
SD_SPI_PWR_ON;
res = f_mount(&FatFs, "", 1); /* Give a work area to the default drive */
DEBUG("%d ", i + 1);
if (res == RES_OK)
break;
sd_spi_usart.Stop();
//power spi & sdcard
SD_EN_OFF;
SD_SPI_PWR_OFF;
for (uint8_t j = 0; j < i +1; j++)
_delay_ms(10);
}
if (res != RES_OK)
{
DEBUG("Error %02X\n", res);
sd_spi_usart.Stop();
//power spi & sdcard
SD_EN_OFF;
SD_SPI_PWR_OFF;
sd_avalible = false;
return false;
}
DEBUG("OK\n");
uint32_t size;
FATFS * FatFs1;
res = f_getfree("", &size, &FatFs1);
// DEBUG1("f_getfree res = %d, size = %lu MiB", res, size / 256);
uint32_t sector_count;
res = disk_ioctl(0, GET_SECTOR_COUNT, §or_count);
// DEBUG1("GET_SECTOR_COUNT res = %d, size = %lu", res, sector_count);
uint16_t sector_size;
res = disk_ioctl(0, GET_SECTOR_SIZE, §or_size);
// DEBUG1("GET_SECTOR_SIZE res = %d, size = %u", res, sector_size);
storage_space = sector_count * sector_size;
storage_free_space = size * 4 * 1024;
DEBUG("Disk info\n");
DEBUG(" sector size %12u\n", sector_size);
DEBUG(" sector count %12lu\n", sector_count);
DEBUG(" total space %12lu\n", storage_space);
DEBUG(" free space %12lu\n", storage_free_space);
sd_avalible = true;
return true;
}
/**
* Main application entry point.
*/
int main( void )
{
bool isMaster = true;
uint8_t i;
// Target board initialisation
BoardInitMcu( );
BoardInitPeriph( );
// Radio initialization
RadioEvents.TxDone = OnTxDone;
RadioEvents.RxDone = OnRxDone;
RadioEvents.TxTimeout = OnTxTimeout;
RadioEvents.RxTimeout = OnRxTimeout;
RadioEvents.RxError = OnRxError;
Radio.Init( &RadioEvents );
Radio.SetChannel( RF_FREQUENCY );
#if defined( USE_MODEM_LORA )
Radio.SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
LORA_SPREADING_FACTOR, LORA_CODINGRATE,
LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
true, 0, 0, LORA_IQ_INVERSION_ON, 3000 );
Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,
0, true, 0, 0, LORA_IQ_INVERSION_ON, true );
#elif defined( USE_MODEM_FSK )
Radio.SetTxConfig( MODEM_FSK, TX_OUTPUT_POWER, FSK_FDEV, 0,
FSK_DATARATE, 0,
FSK_PREAMBLE_LENGTH, FSK_FIX_LENGTH_PAYLOAD_ON,
true, 0, 0, 0, 3000 );
Radio.SetRxConfig( MODEM_FSK, FSK_BANDWIDTH, FSK_DATARATE,
0, FSK_AFC_BANDWIDTH, FSK_PREAMBLE_LENGTH,
0, FSK_FIX_LENGTH_PAYLOAD_ON, 0, true,
0, 0,false, true );
#else
#error "Please define a frequency band in the compiler options."
#endif
Radio.Rx( RX_TIMEOUT_VALUE );
while( 1 )
{
switch( State )
{
case RX:
if( isMaster == true )
{
if( BufferSize > 0 )
{
if( strncmp( ( const char* )Buffer, ( const char* )PongMsg, 4 ) == 0 )
{
// Indicates on a LED that the received frame is a PONG
GpioWrite( &Led1, GpioRead( &Led1 ) ^ 1 );
// Send the next PING frame
Buffer[0] = 'P';
Buffer[1] = 'I';
Buffer[2] = 'N';
Buffer[3] = 'G';
// We fill the buffer with numbers for the payload
for( i = 4; i < BufferSize; i++ )
{
Buffer[i] = i - 4;
}
DelayMs( 1 );
Radio.Send( Buffer, BufferSize );
}
else if( strncmp( ( const char* )Buffer, ( const char* )PingMsg, 4 ) == 0 )
{ // A master already exists then become a slave
isMaster = false;
GpioWrite( &Led2, 1 ); // Set LED off
Radio.Rx( RX_TIMEOUT_VALUE );
}
else // valid reception but neither a PING or a PONG message
{ // Set device as master ans start again
isMaster = true;
Radio.Rx( RX_TIMEOUT_VALUE );
}
}
}
else
{
if( BufferSize > 0 )
{
if( strncmp( ( const char* )Buffer, ( const char* )PingMsg, 4 ) == 0 )
{
// Indicates on a LED that the received frame is a PING
GpioWrite( &Led1, GpioRead( &Led1 ) ^ 1 );
// Send the reply to the PONG string
Buffer[0] = 'P';
Buffer[1] = 'O';
Buffer[2] = 'N';
Buffer[3] = 'G';
// We fill the buffer with numbers for the payload
for( i = 4; i < BufferSize; i++ )
{
Buffer[i] = i - 4;
}
DelayMs( 1 );
Radio.Send( Buffer, BufferSize );
}
else // valid reception but not a PING as expected
{ // Set device as master and start again
isMaster = true;
Radio.Rx( RX_TIMEOUT_VALUE );
}
}
}
State = LOWPOWER;
break;
case TX:
// Indicates on a LED that we have sent a PING [Master]
// Indicates on a LED that we have sent a PONG [Slave]
GpioWrite( &Led2, GpioRead( &Led2 ) ^ 1 );
Radio.Rx( RX_TIMEOUT_VALUE );
State = LOWPOWER;
break;
case RX_TIMEOUT:
case RX_ERROR:
if( isMaster == true )
{
// Send the next PING frame
Buffer[0] = 'P';
Buffer[1] = 'I';
Buffer[2] = 'N';
Buffer[3] = 'G';
for( i = 4; i < BufferSize; i++ )
{
Buffer[i] = i - 4;
}
DelayMs( 1 );
Radio.Send( Buffer, BufferSize );
}
else
{
Radio.Rx( RX_TIMEOUT_VALUE );
}
State = LOWPOWER;
break;
case TX_TIMEOUT:
Radio.Rx( RX_TIMEOUT_VALUE );
State = LOWPOWER;
break;
case LOWPOWER:
default:
// Set low power
break;
}
TimerLowPowerHandler( );
}
}
static __INLINE IO_STATUS RtcReadIo(void)
{
return (IO_STATUS)GpioRead(DS1302_IO_PIN);
}
void LedToggle(Led_t led) {
GpioWrite(&(LedGpios[led]), GpioRead(&(LedGpios[led])) ^ 1);
}
