//=====================================
u8 sx1278_LoRaRxPacket(void)
//=====================================
{
u8 i;
u8 addr;
u8 packet_size;
if(Get_NIRQ())
{
for(i=0;i<32;i++)
RxData[i] = 0x00;
addr = SPIRead(LR_RegFifoRxCurrentaddr); //last packet addr
SPIWrite(LR_RegFifoAddrPtr,addr); //RxBaseAddr -> FiFoAddrPtr
if(sx1278SpreadFactorTable[Lora_Rate_Sel]==6) //When SpreadFactor is six£¬will used Implicit Header mode(Excluding internal packet length)
packet_size=21;
else
packet_size = SPIRead(LR_RegRxNbBytes); //Number for received bytes
SPIBurstRead(0x00, RxData, packet_size);
SPIWrite(LR_RegIrqFlags,LoRa_ClearIRQ_Value);
for(i=0;i<17;i++)
{
if(RxData[i]!=sx1278Data[i])
break;
}
if(i>=17) //Rx success
return(1);
else
return(0);
}
else
return(0);
}
/* SPIWrite2Bytes: Wirte one byte to denstination register.
*
*/
void SPIWrite2Bytes(uint8_t reg, uint32_t data){
// digitalWrite(SLAVE_CS, LOW);
SPIWrite(reg);
SPIWrite((data>>8)&0xff);
SPIWrite(data&0xff);
// digitalWrite(SLAVE_CS, HIGH);
}
/*************************************************
Function: SPIWrite
Description:
Input:
Output:
Return:
Others:
*************************************************/
void SPIWriteByte(unsigned char Addr, unsigned char Data)
{
CLR_SPI_CS;
SPIWrite(Addr);
SPIWrite(Data);
SET_SPI_CS;
}
/** @brief SPIReset: Reset the AD7796 chip, write 4 0xff.
*/
void SPIReset(void){
// digitalWrite(SLAVE_CS, LOW);
SPIWrite(0xff);
SPIWrite(0xff);
SPIWrite(0xff);
SPIWrite(0xff);
// digitalWrite(SLAVE_CS, HIGH);
}
/******************************************************************************
**Name: SI4432_Standby
**Function: config SI4432 module into Standby mode
**Input: none
**Output: none
******************************************************************************/
void SI4432_Standby(void)
{
SPIWrite(0x0803); //Clr FIFO
SPIWrite(0x0800);
SPIRead(0x03); //Clr nIRQ
SPIRead(0x04);
SPIWrite(0x0701); //Standby
}
/******************************************************************************
**Name: SI4432_Sleep
**Function: config SI4432 module into sleep
**Input: none
**Output: none
******************************************************************************/
void SI4432_Sleep(void)
{
SPIWrite(0x0803); //Clr FIFO
SPIWrite(0x0800);
SPIRead(0x03); //Clr nIRQ
SPIRead(0x04);
SPIWrite(0x0700); //Sleep
}
/******************************************************************************
**Name: SI4432_TestConfig
**Function: initialization module Test mode
**Input: none
**Output: none
******************************************************************************/
void SI4432_TestConfig(void)
{
SI4432_Config();
SPIWrite(0x0500);
SPIWrite(0x0600);
SPIWrite(0x0C10); //0C GPIO1 RfData RF Output Tx
SPIWrite(0x3000);
SPIWrite(0x7102); //Direct Mode
}
/* SPIWriteByte: Wirte one byte to denstination register.
*
*/
void SPIWriteByte(uint8_t reg, uint8_t data){
if (selectedShieldVersion < 4){
digitalWrite(CS, LOW);
}
SPIWrite(reg);
SPIWrite(data);
if (selectedShieldVersion < 4){
digitalWrite(CS, HIGH);
}
}
/** @brief SPIWrite2Bytes: Wirte one byte to denstination register.
* @param reg : register
* @param data
*/
void SPIWrite2Bytes(uint8_t reg, uint32_t data){
if (selectedShieldVersion < 4){
digitalWrite(CS, LOW);
}
SPIWrite(reg);
SPIWrite((data>>8)&0xff);
SPIWrite(data&0xff);
if (selectedShieldVersion < 4){
digitalWrite(CS, HIGH);
}
}
/** @brief SPIReset: Reset the AD7794 chip, write 4 0xff.
*/
void SPIReset(void){
if (selectedShieldVersion < 4){
digitalWrite(CS, LOW);
}
SPIWrite(0xff);
SPIWrite(0xff);
SPIWrite(0xff);
SPIWrite(0xff);
if (selectedShieldVersion < 4){
digitalWrite(CS, HIGH);
}
}
static u16 WriteMacBuffer(u08 * bytBuffer,u16 ui_len)
{
u08 bytOpcode;
u16 len;
bytOpcode = WBM_OP;
SEL_MAC(TRUE); // ENC CS low
SPIWrite(&bytOpcode,1); // Tx opcode
len = SPIWrite(bytBuffer, ui_len); // read bytes into buffer
SEL_MAC(FALSE); // release CS
return len;
}
//=====================================
u8 sx1278_LoRaEntryRx(void)
//=====================================
{
u8 addr,temp;
ANT_EN_L();
ANT_CTRL_RX();
sx1278_Config(); //setting base parameter
SPIWrite(REG_LR_PADAC,0x84); //Normal and Rx
SPIWrite(LR_RegHopPeriod,0xFF); //RegHopPeriod NO FHSS
SPIWrite(REG_LR_DIOMAPPING1,0x01); //DIO0=00, DIO1=00, DIO2=00, DIO3=01 Valid header
SPIWrite(LR_RegIrqFlagsMask,0x3F); //Open RxDone interrupt & Timeout
SPIWrite(LR_RegIrqFlags,LoRa_ClearIRQ_Value);
SPIWrite(LR_RegPayloadLength,21); //RegPayloadLength 21byte(this register must difine when the data long of one byte in SF is 6)
addr = SPIRead(LR_RegFifoRxBaseAddr); //Read RxBaseAddr
SPIWrite(LR_RegFifoAddrPtr,addr); //RxBaseAddr -> FiFoAddrPtr¡¡
SPIWrite(LR_RegOpMode,0x8d); //Continuous Rx Mode//Low Frequency Mode
//SPIWrite(LR_RegOpMode,0x05); //Continuous Rx Mode//High Frequency Mode
SysTime = 0;
while(1)
{
if((SPIRead(LR_RegModemStat)&0x04)==0x04) //Rx-on going RegModemStat
break;
if(SysTime>=3)
return 0; //over time for error
}
}
static u08 SetBitField(u08 bytAddress, u08 bytData)
{
if (bytAddress > 0x1f)
{
return FALSE;
}
bytAddress |= BFS_OP; // Set opcode
SEL_MAC(TRUE); // ENC CS low
SPIWrite(&bytAddress,1); // Tx opcode and address
SPIWrite(&bytData,1); // Tx data
SEL_MAC(FALSE);
return TRUE;
}
// Read 10 bits from the MCP3004 ADC converter
unsigned int GetADC (unsigned char channel)
{
unsigned int adc;
// initialize the SPI port to read the MCP3004 ADC attached to it.
SSIG=1;
SPCR=SPE|MSTR|CPOL|CPHA|SPR1|SPR0; // Mode (1,1): see figure 6--2 of MCP3004 datasheet.
P1_4=0; // Activate the MCP3004 ADC.
SPIWrite(0x01); // Send the start bit.
SPIWrite((channel*0x10)|0x80); // Send single/diff* bit, D2, D1, and D0 bits.
adc=((SPDR & 0x03)*0x100); // SPDR has the 2--most significant bits of volt.
SPIWrite(0x55); // It doesn't matter what we send now.
adc+=SPDR; // SPDR contains the low part of the result.
P1_4=1; // Deactivate the MCP3004 ADC.
return adc;
}
int copy_raw(const uint32_t src_addr,
const uint32_t dst_addr,
const uint32_t size)
{
// require regions to be aligned
if (src_addr & 0xfff != 0 ||
dst_addr & 0xfff != 0) {
return 1;
}
const uint32_t buffer_size = FLASH_SECTOR_SIZE;
uint8_t buffer[buffer_size];
uint32_t left = ((size+buffer_size-1) & ~(buffer_size-1));
uint32_t saddr = src_addr;
uint32_t daddr = dst_addr;
while (left) {
if (SPIEraseSector(daddr/buffer_size)) {
return 2;
}
if (SPIRead(saddr, buffer, buffer_size)) {
return 3;
}
if (SPIWrite(daddr, buffer, buffer_size)) {
return 4;
}
saddr += buffer_size;
daddr += buffer_size;
left -= buffer_size;
}
return 0;
}
/***************************************************************************
*
* Function : set_coulomb_counter_calibration_mode
*
* IN : param, a value to write to the regiter CoulombCounterControl
* OUT :
*
* RET : Return the value of register CoulombCounterControl
*
* Notes : From register 0x0C00, bits 3:3
*
**************************************************************************/
unsigned char set_coulomb_counter_calibration_mode( enum calibration_enable param )
{
unsigned char value = 0;
unsigned char old_value;
old_value = SPIRead(COULOMB_COUNTER_CONTROL_REG);
/*
* 0: doesn't set ADconverter in calibration mode.
* 1: set ADconverter in calibration mode
*/
switch( param )
{
case CALIBRATION_ENABLE_E:
value = old_value | CALIBRATION_ENABLE_PARAM_MASK;
break;
case CALIBRATION_DISABLE_E:
value = old_value & ~ CALIBRATION_ENABLE_PARAM_MASK;
break;
}
SPIWrite(COULOMB_COUNTER_CONTROL_REG, value);
return old_value;
}
/***************************************************************************
*
* Function : set_coulomb_counter_reset_accumlator
*
* IN : param, a value to write to the regiter CoulombCounterControl
* OUT :
*
* RET : Return the value of register CoulombCounterControl
*
* Notes : From register 0x0C00, bits 1:1
*
**************************************************************************/
unsigned char set_coulomb_counter_reset_accumlator( enum reset_accumlator_enable param )
{
unsigned char value = 0;
unsigned char old_value;
old_value = SPIRead(COULOMB_COUNTER_CONTROL_REG);
/*
* (auto-cleared)
* 0: inactive
* 1: allow to reset Accumulator and SampleConversion
* counters when a reading is done.r
*/
switch( param )
{
case RESET_E:
value = old_value | RESET_ACCUMLATOR_ENABLE_PARAM_MASK;
break;
case UN_RESET_E:
value = old_value & ~ RESET_ACCUMLATOR_ENABLE_PARAM_MASK;
break;
}
SPIWrite(COULOMB_COUNTER_CONTROL_REG, value);
return old_value;
}
/***************************************************************************
*
* Function : set_coulomb_counter_mux_offset
*
* IN : param, a value to write to the regiter CoulombCounterControl
* OUT :
*
* RET : Return the value of register CoulombCounterControl
*
* Notes : From register 0x0C00, bits 7:7
*
**************************************************************************/
unsigned char set_coulomb_counter_mux_offset( enum select param )
{
unsigned char value = 0;
unsigned char old_value;
old_value = SPIRead(COULOMB_COUNTER_CONTROL_REG);
/*
* 0: select offset from CC_Offset register.
* 1: select internal average offset
*/
switch( param )
{
case SELECT_FROM_OFFSET_REGISTER_E:
value = old_value | SELECT_PARAM_MASK;
break;
case SELECT_INTERNAL_E:
value = old_value & ~ SELECT_PARAM_MASK;
break;
}
SPIWrite(COULOMB_COUNTER_CONTROL_REG, value);
return old_value;
}
char IMURead(char adress,char Device)
{
char TempData=0;
char Result=0;
TempData = (adress | 0b10000000); //set RW bit, and adress (clipped to 7 bits)
if(Device==ACCEL_ID) // select the right CS to assert according to device selection
ACCEL_SPI_CS = 0;
else if(Device==GYRO_ID)
GYRO_SPI_CS = 0;
else if(Device==MAGNET_ID)
MAGNET_SPI_CS=0;
SPIWrite(TempData);
Result = SPIRead(0);
ACCEL_SPI_CS = 1;
GYRO_SPI_CS = 1;
MAGNET_SPI_CS= 1;
return Result;
}
/***************************************************************************
*
* Function : set_data_connect_detection_enable
*
* IN : param, a value to write to the regiter UsbPhyMmanagement3
* OUT :
*
* RET : Return the value of register UsbPhyMmanagement3
*
* Notes : From register 0x0583, bits 7:7
*
**************************************************************************/
unsigned char set_data_connect_detection_enable( enum data_connect_detection_enable param )
{
unsigned char value = 0;
unsigned char old_value;
old_value = SPIRead(USB_PHY_MMANAGEMENT_3_REG);
/*
* 0: inactive
* 1: force 60 Mhz PLL on
*/
switch( param )
{
case DATA_CONNECT_DETECTION_ENABLE_E:
value = old_value | DATA_CONNECT_DETECTION_ENABLE_PARAM_MASK;
break;
case DATA_CONNECT_DETECTION_DISABLE_E:
value = old_value & ~ DATA_CONNECT_DETECTION_ENABLE_PARAM_MASK;
break;
}
SPIWrite(USB_PHY_MMANAGEMENT_3_REG, value);
return old_value;
}
/***************************************************************************
*
* Function : set_comlomb_reset_bit_data
*
* IN : param, a value to write to the regiter CoulombDataManagement
* OUT :
*
* RET : Return the value of register CoulombDataManagement
*
* Notes : From register 0x0C11, bits 0:0
*
**************************************************************************/
unsigned char set_comlomb_reset_bit_data( enum bit_data_reset param )
{
unsigned char value = 0;
unsigned char old_value;
old_value = SPIRead(COULOMB_DATA_MANAGEMENT_REG);
/*
* allows to reset the 21bits accumulator data
*/
switch( param )
{
case BIT_DATA_RESET_E:
value = old_value | BIT_DATA_RESET_PARAM_MASK;
break;
case BIT_DATA_UN_RESET_E:
value = old_value & ~ BIT_DATA_RESET_PARAM_MASK;
break;
}
SPIWrite(COULOMB_DATA_MANAGEMENT_REG, value);
return old_value;
}
/***************************************************************************
*
* Function : set_pwm_out1_enable
*
* IN : param, a value to write to the regiter PwmOutManagement5
* OUT :
*
* RET : Return the value of register PwmOutManagement5
*
* Notes : From register 0x1066, bits 0:0
*
**************************************************************************/
unsigned char set_pwm_out1_enable( enum pwm_out1_enable param )
{
unsigned char value = 0;
unsigned char old_value;
old_value = SPIRead(PWM_OUT_MANAGEMENT_5_REG);
/*
* 0: Disable PWMOut1 generator
* 1: Enable PWMOut1 generator
*/
switch( param )
{
case PWM_OUT_1_ENABLE_E:
value = old_value | PWM_OUT_1_ENABLE_PARAM_MASK;
break;
case PWM_OUT_1_DISABLE_E:
value = old_value & ~ PWM_OUT_1_ENABLE_PARAM_MASK;
break;
}
SPIWrite(PWM_OUT_MANAGEMENT_5_REG, value);
return old_value;
}
/***************************************************************************
*
* Function : set_coulomb_counter_read_enable
*
* IN : param, a value to write to the regiter CoulombCounterControl
* OUT :
*
* RET : Return the value of register CoulombCounterControl
*
* Notes : From register 0x0C00, bits 0:0
*
**************************************************************************/
unsigned char set_coulomb_counter_read_enable( enum read_enable param )
{
unsigned char value = 0;
unsigned char old_value;
old_value = SPIRead(COULOMB_COUNTER_CONTROL_REG);
/*
* (auto-cleared)
* 0: inactive
* 1: allows to transfer the accumulator data,
* SampleConversion and SampleCounter data to the associated
* registers
*/
switch( param )
{
case READ_ENABLE_E:
value = old_value | READ_ENABLE_PARAM_MASK;
break;
case READ_DISABLE_E:
value = old_value & ~ READ_ENABLE_PARAM_MASK;
break;
}
SPIWrite(COULOMB_COUNTER_CONTROL_REG, value);
return old_value;
}
/***************************************************************************
*
* Function : set_coulomb_counter_offset_computation
*
* IN : param, a value to write to the regiter CoulombCounterControl
* OUT :
*
* RET : Return the value of register CoulombCounterControl
*
* Notes : From register 0x0C00, bits 4:4
*
**************************************************************************/
unsigned char set_coulomb_counter_offset_computation( enum computation_enable param )
{
unsigned char value = 0;
unsigned char old_value;
old_value = SPIRead(COULOMB_COUNTER_CONTROL_REG);
/*
* (auto-cleared)
* 0: disable offset average computation.
* 1: enable offset average computation
*/
switch( param )
{
case COMPUTATION_ENABLE_E:
value = old_value | COMPUTATION_ENABLE_PARAM_MASK;
break;
case COMPUTATION_DISABLE_E:
value = old_value & ~ COMPUTATION_ENABLE_PARAM_MASK;
break;
}
SPIWrite(COULOMB_COUNTER_CONTROL_REG, value);
return old_value;
}
/***************************************************************************
*
* Function : set_data_connect_source_enable
*
* IN : param, a value to write to the regiter UsbPhyMmanagement3
* OUT :
*
* RET : Return the value of register UsbPhyMmanagement3
*
* Notes : From register 0x0583, bits 6:6
*
**************************************************************************/
unsigned char set_data_connect_source_enable( enum data_connect_source_enable param )
{
unsigned char value = 0;
unsigned char old_value;
old_value = SPIRead(USB_PHY_MMANAGEMENT_3_REG);
/*
* 0: Data Connect source is disabled
* 1:Data Connect source is enable
*/
switch( param )
{
case DATA_CONNECT_SOURCE_ENABLE_E:
value = old_value | DATA_CONNECT_SOURCE_ENABLE_PARAM_MASK;
break;
case DATA_CONNECT_SOURCE_DISABLE_E:
value = old_value & ~ DATA_CONNECT_SOURCE_ENABLE_PARAM_MASK;
break;
}
SPIWrite(USB_PHY_MMANAGEMENT_3_REG, value);
return old_value;
}
/***************************************************************************
*
* Function : set_coulomb_counter_number_of_convertion
*
* IN : param, a value to write to the regiter CoulombCounterControl
* OUT :
*
* RET : Return the value of register CoulombCounterControl
*
* Notes : From register 0x0C00, bits 6:5
*
**************************************************************************/
unsigned char set_coulomb_counter_number_of_convertion( enum number_convertion param )
{
unsigned char value = 0;
unsigned char old_value;
old_value = SPIRead(COULOMB_COUNTER_CONTROL_REG);
/*
* 00: 4
* 01: 8
* 10: 16
*/
value = old_value & ~NUMBER_CONVERTION_PARAM_MASK ;
switch( param )
{
case NUMBER_CONVERTION_4_E:
value = value | (NUMBER_CONVERTION_4 << 0x5);
break;
case NUMBER_CONVERTION_8_E:
value = value | (NUMBER_CONVERTION_8 << 0x5);
break;
case NUMBER_CONVERTION_16_E:
value = value | (NUMBER_CONVERTION_16 << 0x5);
break;
}
SPIWrite(COULOMB_COUNTER_CONTROL_REG, value);
return old_value;
}
/***************************************************************************
*
* Function : set_sdm_src_switch
*
* IN : param, a value to write to the regiter UsbPhyMmanagement3
* OUT :
*
* RET : Return the value of register UsbPhyMmanagement3
*
* Notes : From register 0x0583, bits 3:3
*
**************************************************************************/
unsigned char set_sdm_src_switch( enum sdm_src_switch_opened param )
{
unsigned char value = 0;
unsigned char old_value;
old_value = SPIRead(USB_PHY_MMANAGEMENT_3_REG);
/*
* 0: SDM_SRC USB switch is opened
* 1: SDM_SRC USB switch is closed
*/
switch( param )
{
case SDM_SRC_SWITCH_OPEN_E:
value = old_value | SDM_SRC_SWITCH_OPENED_PARAM_MASK;
break;
case SDM_SRC_SWITCH_CLOSE_E:
value = old_value & ~ SDM_SRC_SWITCH_OPENED_PARAM_MASK;
break;
}
SPIWrite(USB_PHY_MMANAGEMENT_3_REG, value);
return old_value;
}
/***************************************************************************
*
* Function : set_comlomb_data_transfert
*
* IN : param, a value to write to the regiter CoulombDataManagement
* OUT :
*
* RET : Return the value of register CoulombDataManagement
*
* Notes : From register 0x0C11, bits 1:1
*
**************************************************************************/
unsigned char set_comlomb_data_transfert( enum data_transfert param )
{
unsigned char value = 0;
unsigned char old_value;
old_value = SPIRead(COULOMB_DATA_MANAGEMENT_REG);
/*
* allows to transfer the accumulator data to the NconAccu
* registers
*/
switch( param )
{
case NOT_TRANSFERT_TO_NCONACCU_E:
value = old_value | DATA_TRANSFERT_PARAM_MASK;
break;
case TRANSFERT_TO_NCONACCU_E:
value = old_value & ~ DATA_TRANSFERT_PARAM_MASK;
break;
}
SPIWrite(COULOMB_DATA_MANAGEMENT_REG, value);
return old_value;
}
static void ResetMac(void)
{
u08 bytOpcode = RESET_OP;
SEL_MAC(TRUE); // ENC CS low
SPIWrite(&bytOpcode,1); // Tx opcode and address
SEL_MAC(FALSE);
}
/******************************************************************************
**Name: SI4432_Reset
**Function: Software Reset SI4432 module
**Input: none
**Output: none
******************************************************************************/
void SI4432_Reset(void)
{
SPIWrite(0x0708); //Software reset
while (nIRQ); // Wait for chip ready
SPIRead(0x03); //Clr nIRQ
SPIRead(0x04);
}
