/****************************************************************************
Function:
bool DRV_SPI_Initialize(SpiChannel chn, SpiOpenFlags oFlags, unsigned int fpbDiv)
Summary:
This function initializes the SPI channel and also sets the brg register.
Description:
This function initializes the SPI channel and also sets the brg register.
The SPI baudrate BR is given by: BR=Fpb/(2*(SPIBRG+1))
The input parametes fpbDiv specifies the Fpb divisor term (2*(SPIBRG+1)),
so the BRG is calculated as SPIBRG=fpbDiv/2-1.
Precondition:
None
Parameters:
chn - the channel to set
oFlags - a SpiOpenFlags or __SPIxCONbits_t structure that sets the module behavior
fpbDiv - Fpb divisor to extract the baud rate: BR=Fpb/fpbDiv.
Returns:
true if success
false otherwise
Remarks:
- The baud rate is always obtained by dividing the Fpb to an even number
between 2 and 1024.
- When selecting the number of bits per character, SPI_OPEN_MODE32 has the highest priority.
If SPI_OPEN_MODE32 is not set, then SPI_OPEN_MODE16 selects the character width.
- The SPI_OPEN_SSEN is taken into account even in master mode. If it is set the library
will properly se the SS pin as an digital output.
***************************************************************************/
bool DRV_SPI_Initialize(SpiChannel chn, SpiOpenFlags oFlags, unsigned int fpbDiv)
{
#if defined (__C32__)
SpiChnOpen(chn, oFlags, fpbDiv);
#elif defined (__C30__)
volatile uint16_t con1 = 0;
uint16_t con2 = 0;
uint16_t con3 = 0;
uint8_t i;
if((SYS_CLK_PeripheralClockGet()/fpbDiv) > 10000000ul)
{
SYS_ASSERT(false, "Requested SPI frequency is not supported!");
return false;
// the SPI clock is selected more than 10MHz.
// Select the frequency as per the data sheet of the particular 16bit device.
}
for(i = 0; i < SPI_CLK_TBL_ELEMENT_COUNT; i++)
{
if((SYS_CLK_PeripheralClockGet()/fpbDiv) <= SpiClkTbl[i].clock)
{
con1 = SpiClkTbl[i].scale;
break;
}
}
con1 |= oFlags;
con3 |= SPI_EN;
switch(chn)
{
case 1:
OpenSPI1(con1,con2,con3);
break;
case 2:
SPI2STAT &= 0x7FFF;
OpenSPI2(con1,con2,con3);
break;
default:
SYS_ASSERT(false, "Requested SPI channel is not supported!");
return false;
}
#endif
return true;
}
bool USART_INIT(SYS_MODULE_ID port_id, uint32_t baud_rate) {
USART_MODULE_CTRL *pusart_module_ctrl;
USART_MODULE_ID module_id;
if(port_id == SYS_MODULE_UART_1)
module_id = USART1_ID;
else if(port_id == SYS_MODULE_UART_2)
module_id = USART2_ID;
// else if(port_id == SYS_MODULE_UART_3)
// module_id = USART_ID_3;
// else if(port_id == SYS_MODULE_UART_4)
// module_id = USART_ID_4;
// else if(port_id == SYS_MODULE_UART_5)
// module_id = USART_ID_5;
// else if(port_id == SYS_MODULE_UART_6)
// module_id = USART_ID_6;
else
return false;
pusart_module_ctrl = &usart_module_ctrl[module_id];
*(pusart_module_ctrl->UxBRG) = (((SYS_CLK_PeripheralClockGet())/(baud_rate)/_USART_BAUD_RATE_FACTOR) - 1);
*(pusart_module_ctrl->UxMODE) = 0;
((USART_MODE_CTRL*)(pusart_module_ctrl->UxMODE))->BRGH = 1;
*(pusart_module_ctrl->UxSTA) = 0;
((USART_MODE_CTRL*)(pusart_module_ctrl->UxMODE))->UARTEN = 1;
((USART_MODE_CTRL*)(pusart_module_ctrl->UxMODE))->STSEL = 0;
((USART_STAT_CTRL*)(pusart_module_ctrl->UxSTA))->UTXEN = 1;
#if defined (__PIC32MX__)
((USART_STAT_CTRL*)(pusart_module_ctrl->UxSTA))->URXEN = 1;
#endif
((USART_STAT_CTRL*)(pusart_module_ctrl->UxSTA))->OERR = 0;
return true;
}
void XEEInit(void)
{
EEPROM_CS_IO = 1;
EEPROM_CS_TRIS = 0; // Drive SPI EEPROM chip select pin
EEPROM_SCK_TRIS = 0; // Set SCK pin as an output
EEPROM_SDI_TRIS = 1; // Make sure SDI pin is an input
EEPROM_SDO_TRIS = 0; // Set SDO pin as an output
ClearSPIDoneFlag();
#if defined(__C30__)
EEPROM_SPICON1 = PROPER_SPICON1; // See PROPER_SPICON1 definition above
EEPROM_SPICON2 = 0;
EEPROM_SPISTAT = 0; // clear SPI
EEPROM_SPISTATbits.SPIEN = 1;
#elif defined(__C32__)
EEPROM_SPIBRG = (SYS_CLK_PeripheralClockGet()-1ul)/2ul/EEPROM_MAX_SPI_FREQ;
EEPROM_SPICON1 = PROPER_SPICON1;
#endif
}
/*****************************************************************************
Function:
void SPIFlashInit(void)
Description:
Initializes SPI Flash module.
Precondition:
None
Parameters:
None
Returns:
None
Remarks:
This function is only called once during the lifetime of the application.
Internal:
This function sends WRDI to clear any pending write operation, and also
clears the software write-protect on all memory locations.
***************************************************************************/
void SPIFlashInit(void)
{
uint8_t i;
volatile uint8_t Dummy;
uint8_t vSPIONSave;
#if defined(__C30__)
uint16_t SPICON1Save;
#elif defined(__C32__)
uint32_t SPICON1Save;
#endif
SPIFLASH_CS_IO = 1;
SPIFLASH_CS_TRIS = 0; // Drive SPI Flash chip select pin
SPIFLASH_SCK_TRIS = 0; // Set SCK pin as an output
SPIFLASH_SDI_TRIS = 1; // Make sure SDI pin is an input
SPIFLASH_SDO_TRIS = 0; // Set SDO pin as an output
// Save SPI state (clock speed)
SPICON1Save = SPIFLASH_SPICON1;
vSPIONSave = SPI_ON_BIT;
// Configure SPI
SPI_ON_BIT = 0;
SPIFLASH_SPICON1 = PROPER_SPICON1;
SPI_ON_BIT = 1;
ClearSPIDoneFlag();
#if defined(__C30__)
SPIFLASH_SPICON2 = 0;
SPIFLASH_SPISTAT = 0; // clear SPI
SPIFLASH_SPISTATbits.SPIEN = 1;
#elif defined(__C32__)
SPIFLASH_SPIBRG = (SYS_CLK_PeripheralClockGet()-1ul)/2ul/SPIFLASH_MAX_SPI_FREQ;
#endif
// Read Device ID code to determine supported device capabilities/instructions
{
// Activate chip select
SPIFLASH_CS_IO = 0;
ClearSPIDoneFlag();
// Send instruction
SPIFLASH_SSPBUF = RDID;
WaitForDataByte();
Dummy = SPIFLASH_SSPBUF;
// Send 3 byte address (0x000000), discard Manufacture ID, get Device ID
for(i = 0; i < 5; i++)
{
SPIFLASH_SSPBUF = 0x00;
WaitForDataByte();
Dummy = SPIFLASH_SSPBUF;
}
// Deactivate chip select
SPIFLASH_CS_IO = 1;
// Decode Device Capabilities Flags from Device ID
deviceCaps.v = 0x00;
switch(Dummy)
{
case 0x43: // SST25LF020(A) (2 Mbit) 0xAF, 14us, AAI Byte
case 0x48: // SST25VF512(A) (512 Kbit) 0xAF, 14us, AAI Byte
case 0x49: // SST25VF010A (1 Mbit) 0xAF, 14us, AAI Byte
deviceCaps.bits.bWriteByteStream = 1;
break;
case 0x4B: // SST25VF064C (64 Mbit) 0x02, 1.5ms/256 byte page, no AAI
deviceCaps.bits.bPageProgram = 1;
break;
//case 0x01: // SST25WF512 (512 Kbit) 0xAD, 50us, AAI Word
//case 0x02: // SST25WF010 (1 Mbit) 0xAD, 50us, AAI Word
//case 0x03: // SST25WF020 (2 Mbit) 0xAD, 50us, AAI Word
//case 0x04: // SST25WF040 (4 Mbit) 0xAD, 50us, AAI Word
//case 0x05: // SST25WF080 (8 Mbit) 0xAD, 14us, AAI Word
//case 0x41: // SST25VF016B (16 Mbit) 0xAD, 7us, AAI Word
//case 0x4A: // SST25VF032B (32 Mbit) 0xAD, 7us, AAI Word
//case 0x8C: // SST25VF020B (2 Mbit) 0xAD, 7us, AAI Word
//case 0x8D: // SST25VF040B (4 Mbit) 0xAD, 7us, AAI Word
//case 0x8E: // SST25VF080B (8 Mbit) 0xAD, 7us, AAI Word
// Assume AAI Word programming is supported for the above commented
// devices and unknown devices.
default:
deviceCaps.bits.bWriteWordStream = 1;
}
}
// Clear any pre-existing AAI write mode
// This may occur if the PIC is reset during a write, but the Flash is
// not tied to the same hardware reset.
_SendCmd(WRDI);
// Execute Enable-Write-Status-Register (EWSR) instruction
_SendCmd(EWSR);
// Clear Write-Protect on all memory locations
SPIFLASH_CS_IO = 0;
SPIFLASH_SSPBUF = WRSR;
WaitForDataByte();
Dummy = SPIFLASH_SSPBUF;
SPIFLASH_SSPBUF = 0x00; // Clear all block protect bits
WaitForDataByte();
Dummy = SPIFLASH_SSPBUF;
SPIFLASH_CS_IO = 1;
// Restore SPI state
SPI_ON_BIT = 0;
SPIFLASH_SPICON1 = SPICON1Save;
SPI_ON_BIT = vSPIONSave;
}
