void systemInit(bool overclock)
{
#ifdef STM32F303xC
// start fpu
SCB->CPACR = (0x3 << (10*2)) | (0x3 << (11*2));
#endif
#ifdef STM32F303xC
SetSysClock();
#endif
#ifdef STM32F10X_MD
// Configure the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers
// Configure the Flash Latency cycles and enable prefetch buffer
SetSysClock(overclock);
#endif
// Configure NVIC preempt/priority groups
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
#ifdef STM32F10X_MD
// Turn on clocks for stuff we use
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
#endif
RCC_ClearFlag();
enableGPIOPowerUsageAndNoiseReductions();
#ifdef STM32F10X_MD
// Turn off JTAG port 'cause we're using the GPIO for leds
#define AFIO_MAPR_SWJ_CFG_NO_JTAG_SW (0x2 << 24)
AFIO->MAPR |= AFIO_MAPR_SWJ_CFG_NO_JTAG_SW;
#endif
ledInit();
beeperInit();
// Init cycle counter
cycleCounterInit();
// SysTick
SysTick_Config(SystemCoreClock / 1000);
#ifdef CC3D
spiInit(SPI1);
spiInit(SPI2);
#endif
#ifndef CC3D
// Configure the rest of the stuff
i2cInit(I2C2);
#endif
// sleep for 100ms
delay(100);
}
void systemInit(void)
{
// Init cycle counter
cycleCounterInit();
// SysTick
SysTick_Config(SystemCoreClock / 1000);
///////////////////////////////////
checkFirstTime(false);
readEEPROM();
if (eepromConfig.receiverType == SPEKTRUM)
checkSpektrumBind();
checkResetType();
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); // 2 bits for pre-emption priority, 2 bits for subpriority
initMixer();
ledInit();
cliInit();
BLUE_LED_ON;
delay(20000); // 20 sec total delay for sensor stabilization - probably not long enough.....
adcInit();
batteryInit();
gpsInit();
i2cInit(I2C1);
i2cInit(I2C2);
pwmEscInit(eepromConfig.escPwmRate);
pwmServoInit(eepromConfig.servoPwmRate);
rxInit();
spiInit(SPI2);
spiInit(SPI3);
telemetryInit();
timingFunctionsInit();
initFirstOrderFilter();
initGPS();
initMax7456();
initPID();
GREEN_LED_ON;
initMPU6000();
initMag(HMC5883L_I2C);
initPressure(MS5611_I2C);
}
int main()
{
while(true){
Reset();
systickInit();
gpioInit();
adcInit();
lcdInit();
tsInit();
welcomeScreen();
#ifdef DEBUG
ledInit();
#endif
spiInit();
while(!IsRebootRequired()){
if(IsSynchronizationRequired()){
AssertGoBusIRQ();
}
#ifdef DEBUG
GPIO_ToggleBits(GPIOC, GPIO_Pin_13);
delay(5);
#endif
}
}
}
void zg_init()
{
unsigned char clr;
spiInit();
clr = SPSR;
clr = SPDR;
intr_occured = 0;
intr_valid = 0;
zg_drv_state = DRV_STATE_INIT;
zg_conn_status = 0;
tx_ready = 0;
rx_ready = 0;
cnf_pending = 0;
// zg_buf = MyNetworkBuffer;
// zg_buf_len = NETWORK_BUFSIZE;
zg_buf = mmalloc(150);
zg_buf_len = 150;
zg_chip_reset();
zg_interrupt2_reg();
zg_interrupt_reg(0xff, 0);
zg_interrupt_reg(0x80|0x40, 1);
ssid_len = (unsigned char)strlen(ssid);
security_passphrase_len = (unsigned char)strlen(security_passphrase);
}
/**
* Set the SPI clock rate.
*
* \param[in] sckRateID A value in the range [0, 6].
*
* 0 = 8 MHz
* 1 = 4 MHz
* 2 = 2 MHz
* 3 = 1 MHz
* 4 = 500 kHz
* 5 = 125 kHz
* 6 = 63 kHz
*
* The SPI clock will be set to F_CPU/pow(2, 1 + sckRateID). The maximum
* SPI rate is F_CPU/2 for \a sckRateID = 0 and the minimum rate is F_CPU/128
* for \a scsRateID = 6.
*
* \return The value one, true, is returned for success and the value zero,
* false, is returned for an invalid value of \a sckRateID.
*/
uint8_t Sd2Card::setSckRate(uint8_t sckRateID) {
#ifdef USE_TEENSY3_SPI
spiInit(sckRateID);
return true;
#else
if (sckRateID > 6) sckRateID = 6;
// see avr processor datasheet for SPI register bit definitions
if ((sckRateID & 1) || sckRateID == 6) {
SPSR &= ~(1 << SPI2X);
} else {
SPSR |= (1 << SPI2X);
}
SPCR &= ~((1 <<SPR1) | (1 << SPR0));
SPCR |= (sckRateID & 4 ? (1 << SPR1) : 0)
| (sckRateID & 2 ? (1 << SPR0) : 0);
#ifdef SPI_HAS_TRANSACTION
switch (sckRateID) {
case 0: settings = SPISettings(8000000, MSBFIRST, SPI_MODE0); break;
case 1: settings = SPISettings(4000000, MSBFIRST, SPI_MODE0); break;
case 2: settings = SPISettings(2000000, MSBFIRST, SPI_MODE0); break;
case 3: settings = SPISettings(1000000, MSBFIRST, SPI_MODE0); break;
case 4: settings = SPISettings(500000, MSBFIRST, SPI_MODE0); break;
case 5: settings = SPISettings(250000, MSBFIRST, SPI_MODE0); break;
default: settings = SPISettings(125000, MSBFIRST, SPI_MODE0);
}
#endif
return true;
#endif
}
// hardware SPI
void HAL::spiBegin()
{
// Configre SPI pins
PIO_Configure(
g_APinDescription[SCK_PIN].pPort,
g_APinDescription[SCK_PIN].ulPinType,
g_APinDescription[SCK_PIN].ulPin,
g_APinDescription[SCK_PIN].ulPinConfiguration);
PIO_Configure(
g_APinDescription[MOSI_PIN].pPort,
g_APinDescription[MOSI_PIN].ulPinType,
g_APinDescription[MOSI_PIN].ulPin,
g_APinDescription[MOSI_PIN].ulPinConfiguration);
PIO_Configure(
g_APinDescription[MISO_PIN].pPort,
g_APinDescription[MISO_PIN].ulPinType,
g_APinDescription[MISO_PIN].ulPin,
g_APinDescription[MISO_PIN].ulPinConfiguration);
// set master mode, peripheral select, fault detection
SPI_Configure(SPI0, ID_SPI0, SPI_MR_MSTR |
SPI_MR_MODFDIS | SPI_MR_PS);
SPI_Enable(SPI0);
PIO_Configure(
g_APinDescription[SPI_PIN].pPort,
g_APinDescription[SPI_PIN].ulPinType,
g_APinDescription[SPI_PIN].ulPin,
g_APinDescription[SPI_PIN].ulPinConfiguration);
spiInit(1);
}
/**
* @brief HAL initialization.
*/
void halInit(void) {
hal_lld_init();
#if CH_HAL_USE_PAL
palInit(&pal_default_config);
#endif
#if CH_HAL_USE_ADC
adcInit();
#endif
#if CH_HAL_USE_CAN
canInit();
#endif
#if CH_HAL_USE_MAC
macInit();
#endif
#if CH_HAL_USE_PWM
pwmInit();
#endif
#if CH_HAL_USE_SERIAL
sdInit();
#endif
#if CH_HAL_USE_SPI
spiInit();
#endif
#if CH_HAL_USE_MMC_SPI
mmcInit();
#endif
}
void spi(){
uint8_t data;
spiInit();
uint8_t status = spiTransmit(data);
status = spiReceive();
}
void spiTest() {
int i, j;
csInit (); // Initialize chip select PC03
spiInit (SPI1);
for (i = 0; i < 8; i++) {
for (j = 0; j < 4; j++)
txbuf [j] = i*4 + j;
GPIO_WriteBit (GPIOE , GPIO_Pin_3 , 0);
spiReadWrite (SPI1 , rxbuf , txbuf , 4, SPI_SLOW );
GPIO_WriteBit (GPIOE , GPIO_Pin_3 , 1);
for (j = 0; j < 4; j++)
if (rxbuf [j] != txbuf [j])
assert_failed (__FILE__ , __LINE__ );
}
for (i = 0; i < 8; i++) {
for (j = 0; j < 4; j++)
txbuf16 [j] = i*4 + j + (i << 8);
GPIO_WriteBit (GPIOE , GPIO_Pin_3 , 0);
spiReadWrite16 (SPI1 , rxbuf16 , txbuf16 , 4, SPI_SLOW );
GPIO_WriteBit (GPIOE , GPIO_Pin_3 , 1);
for (j = 0; j < 4; j++)
if ( rxbuf16 [j] != txbuf16 [j])
assert_failed (__FILE__ , __LINE__ );
}
}
uint8_t u8g_com_HAL_DUE_shared_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
switch(msg) {
case U8G_COM_MSG_STOP:
break;
case U8G_COM_MSG_INIT:
u8g_SetPILevel_DUE_hw_spi(u8g, U8G_PI_CS, 1);
u8g_SetPILevel_DUE_hw_spi(u8g, U8G_PI_A0, 1);
u8g_SetPIOutput_DUE_hw_spi(u8g, U8G_PI_CS);
u8g_SetPIOutput_DUE_hw_spi(u8g, U8G_PI_A0);
u8g_Delay(5);
spiBegin();
#ifndef SPI_SPEED
#define SPI_SPEED SPI_FULL_SPEED // use same SPI speed as SD card
#endif
spiInit(2);
break;
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
u8g_SetPILevel_DUE_hw_spi(u8g, U8G_PI_A0, arg_val);
break;
case U8G_COM_MSG_CHIP_SELECT:
u8g_SetPILevel_DUE_hw_spi(u8g, U8G_PI_CS, (arg_val ? 0 : 1));
break;
case U8G_COM_MSG_RESET:
break;
case U8G_COM_MSG_WRITE_BYTE:
spiSend((uint8_t)arg_val);
break;
case U8G_COM_MSG_WRITE_SEQ: {
uint8_t *ptr = (uint8_t*) arg_ptr;
while (arg_val > 0) {
spiSend(*ptr++);
arg_val--;
}
}
break;
case U8G_COM_MSG_WRITE_SEQ_P: {
uint8_t *ptr = (uint8_t*) arg_ptr;
while (arg_val > 0) {
spiSend(*ptr++);
arg_val--;
}
}
break;
}
return 1;
}
/**
* @brief HAL initialization.
* @details This function invokes the low level initialization code then
* initializes all the drivers enabled in the HAL. Finally the
* board-specific initialization is performed by invoking
* @p boardInit() (usually defined in @p board.c).
*
* @init
*/
void halInit(void) {
hal_lld_init();
#if HAL_USE_TM || defined(__DOXYGEN__)
tmInit();
#endif
#if HAL_USE_PAL || defined(__DOXYGEN__)
palInit(&pal_default_config);
#endif
#if HAL_USE_ADC || defined(__DOXYGEN__)
adcInit();
#endif
#if HAL_USE_CAN || defined(__DOXYGEN__)
canInit();
#endif
#if HAL_USE_EXT || defined(__DOXYGEN__)
extInit();
#endif
#if HAL_USE_GPT || defined(__DOXYGEN__)
gptInit();
#endif
#if HAL_USE_I2C || defined(__DOXYGEN__)
i2cInit();
#endif
#if HAL_USE_ICU || defined(__DOXYGEN__)
icuInit();
#endif
#if HAL_USE_MAC || defined(__DOXYGEN__)
macInit();
#endif
#if HAL_USE_PWM || defined(__DOXYGEN__)
pwmInit();
#endif
#if HAL_USE_SERIAL || defined(__DOXYGEN__)
sdInit();
#endif
#if HAL_USE_SDC || defined(__DOXYGEN__)
//KL All in Kl_sdc sdcInit();
#endif
#if HAL_USE_SPI || defined(__DOXYGEN__)
spiInit();
#endif
#if HAL_USE_UART || defined(__DOXYGEN__)
uartInit();
#endif
#if HAL_USE_USB || defined(__DOXYGEN__)
usbInit();
#endif
#if HAL_USE_MMC_SPI || defined(__DOXYGEN__)
mmcInit();
#endif
#if HAL_USE_SERIAL_USB || defined(__DOXYGEN__)
sduInit();
#endif
#if HAL_USE_RTC || defined(__DOXYGEN__)
rtcInit();
#endif
}
int main(void)
{
lcdInit();
spiInit();
lcdWriteChar(spiFullDuplexRdWr('D'),LINE2);
while(1);
return 0;
}
// functions
void spiflashInit(void)
{
// initialize spi
spiInit();
// initialize chip select
SPIFLASH_RELEASE_CS;
SPIFLASH_CONFIG_CS;
}
void mmcInit(void)
{
// initialize SPI interface
spiInit();
// release chip select
sbi(MMC_CS_DDR, MMC_CS_PIN);
sbi(MMC_CS_PORT,MMC_CS_PIN);
}
int main(void)
{
spiInit();
SystemCoreClockUpdate();
spiInit();
serialDebugInit();
userButtonInit();
userLedsInit();
printf("STM32F429 TFT - program v1.0 - rozpoczecie programu\n");
//ledRedOn();
//ledGreenOff();
/**
* IMPORTANT NOTE!
* The symbol VECT_TAB_SRAM
*
* needs to be defined when building the project
* if code has been located to RAM and interrupts are used.
* Otherwise the interrupt table located in flash will be used.
* See also the <system_*.c> file and how the SystemInit() function updates
* SCB->VTOR register.
* E.g. SCB->VTOR = 0x20000000;
*/
//STM_EVAL_LEDInit(LED3);
//STM_EVAL_LEDInit(LED4);
// STM_EVAL_LEDOn(LED3);
// STM_EVAL_LEDOn(LED4);
/* Infinite loop */
while (1)
{
printf("1\n");
_delay_ms(200);
printf("2\n");
_delay_ms(200);
// while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
// USART1->DR = 'p';
//printf(" p \n");
}
}
static void calculations_heading(void *pvParameters)
{
UARTInit(3, 115200); /* baud rate setting */
printf("Maintask: Running\n");
CLKPWR_ConfigPPWR(CLKPWR_PCONP_PCGPIO, ENABLE);
spiInit();
gyroInit();
for (;;)
{
/*Block waiting for the semaphore to become available. */
if (xSemaphoreTake( xSemaphore, 0xffff ) == pdTRUE)
{
/* It is time to execute. */;
/* Turn the LED off if it was on, and on if it was off. */
LPC_GPIO1->FIOSET = (1 << 1);
static Bool initDone = TRUE;
if (initDone)
{
static uint16_t initIteration = 0;
if (initIteration++ == 33)//not 32 since first value is dummy =0,0
{
initDone = FALSE;
imuInit_2();
}
else
imuInit_1();
}
else
{
Matrix_update();
Normalize();
Drift_correction();
Euler_angles();
calculations_motor();
static uint16_t counter = 0;
counter++;
if (counter == 4)
{
counter = 0;
xSemaphoreGive(xSemaphoreTerminal);
}
}
LPC_GPIO1->FIOCLR = (1 << 1);
}
}
}
void mmcInit(void)
{
// initialize SPI interface
spiInit();
// configure pin as output
sbi(MMC_CS_DDR, MMC_CS_PIN);
// release chip select
sbi(MMC_CS_PORT,MMC_CS_PIN);
}
void HAL::spiBegin()
{
#if MOTHERBOARD == 500 || MOTHERBOARD == 501
if (spiInitMaded == false)
{
#endif // Configre SPI pins
PIO_Configure(
g_APinDescription[SCK_PIN].pPort,
g_APinDescription[SCK_PIN].ulPinType,
g_APinDescription[SCK_PIN].ulPin,
g_APinDescription[SCK_PIN].ulPinConfiguration);
PIO_Configure(
g_APinDescription[MOSI_PIN].pPort,
g_APinDescription[MOSI_PIN].ulPinType,
g_APinDescription[MOSI_PIN].ulPin,
g_APinDescription[MOSI_PIN].ulPinConfiguration);
PIO_Configure(
g_APinDescription[MISO_PIN].pPort,
g_APinDescription[MISO_PIN].ulPinType,
g_APinDescription[MISO_PIN].ulPin,
g_APinDescription[MISO_PIN].ulPinConfiguration);
// set master mode, peripheral select, fault detection
SPI_Configure(SPI0, ID_SPI0, SPI_MR_MSTR |
SPI_MR_MODFDIS | SPI_MR_PS);
SPI_Enable(SPI0);
#if MOTHERBOARD == 500 || MOTHERBOARD == 501
SET_OUTPUT(DAC0_SYNC);
#if NUM_EXTRUDER > 1
SET_OUTPUT(DAC1_SYNC);
WRITE(DAC1_SYNC, HIGH);
#endif
SET_OUTPUT(SPI_EEPROM1_CS);
SET_OUTPUT(SPI_EEPROM2_CS);
SET_OUTPUT(SPI_FLASH_CS);
WRITE(DAC0_SYNC, HIGH);
WRITE(SPI_EEPROM1_CS, HIGH );
WRITE(SPI_EEPROM2_CS, HIGH );
WRITE(SPI_FLASH_CS, HIGH );
WRITE(SDSS , HIGH );
#endif// MOTHERBOARD == 500 || MOTHERBOARD == 501
PIO_Configure(
g_APinDescription[SPI_PIN].pPort,
g_APinDescription[SPI_PIN].ulPinType,
g_APinDescription[SPI_PIN].ulPin,
g_APinDescription[SPI_PIN].ulPinConfiguration);
spiInit(1);
#if (MOTHERBOARD==500) || (MOTHERBOARD==501)
spiInitMaded = true;
}
#endif
}
void spiTest2() {
csInit ();
spiInit(SPI1);
while(1){
GPIOE->BSRRH |= GPIO_Pin_3; // set PE3 (CS) low
SPI1_send(0xAA); // transmit data
received_val = SPI1_send(0x00); // transmit dummy byte and receive data
GPIOE->BSRRL |= GPIO_Pin_3; // set PE3 (CS) high
}
}
void ACC_Init(uint8 task_id){
ACC_TaskID= task_id;
spiInit(SPI_MASTER);
accInit();
uartInit( HAL_UART_BR_57600 );
osal_set_event( ACC_TaskID, start_acc );
}
int main(void){
//Disable Watchdog
WDTCTL = WDTPW + WDTHOLD;
// Set up 1MHz Clock
BCSCTL1 = CALBC1_1MHZ;
DCOCTL = CALDCO_1MHZ;
// Setup GPIO
P1DIR |= BIT0 + BIT3;
P1OUT = 0;
P1DIR &= ~( BTN_INC_SECONDS + BTN_INC_MINUTES + BTN_INC_HOURS
+ BTN_ALT_DECREMENT);
P1IE |= ( BTN_INC_SECONDS + BTN_INC_MINUTES + BTN_INC_HOURS);
P1IES |= ( BTN_INC_SECONDS + BTN_INC_MINUTES + BTN_INC_HOURS);
P1IFG &= ~( BTN_INC_SECONDS + BTN_INC_MINUTES + BTN_INC_HOURS);
P1OUT |= ( BTN_INC_SECONDS + BTN_INC_MINUTES + BTN_INC_HOURS
+ BTN_ALT_DECREMENT);
P1REN |= ( BTN_INC_SECONDS + BTN_INC_MINUTES + BTN_INC_HOURS
+ BTN_ALT_DECREMENT);
// Initialize Peripherals & Interrupts
spiInit();
timerInit();
_BIS_SR(GIE);
// Initialize Variables
uint8_t i = 0;
uint8_t sendByteBitMask = 1;
// SUPER LOOP
while(1){
// Futz with Bit Masking
sendByteBitMask = (sendByteBitMask << 1);
if (sendByteBitMask >= 0x80){
sendByteBitMask =1;
}
// Send bytes to shift register
for(i = 0; i < NUM_SHIFT_REGISTERS; i++){
spiSendChar((rtcState[i] & sendByteBitMask) << 1);
}
latch595();
}
}
/////////////////////////////////////////////
// http://www.lxtronic.com/index.php/basic-spi-simple-read-write
/////////////////////////////////////////////
void spiTestMems ()
{
csInit ();
spiInit(SPI1);
int8_t data;
mySPI_SendData(0x20, 0xC0); //LIS302D Config
while(1)
{
data = mySPI_GetData(0x29);
}
}
/**
* Set the SPI clock rate.
*
* \param[in] sckRateID A value in the range [0, 6].
*
* 0 = 8 MHz
* 1 = 4 MHz
* 2 = 2 MHz
* 3 = 1 MHz
* 4 = 500 kHz
* 5 = 125 kHz
* 6 = 63 kHz
*
* The SPI clock will be set to F_CPU/pow(2, 1 + sckRateID). The maximum
* SPI rate is F_CPU/2 for \a sckRateID = 0 and the minimum rate is F_CPU/128
* for \a scsRateID = 6.
*
* \return The value one, true, is returned for success and the value zero,
* false, is returned for an invalid value of \a sckRateID.
*/
uint8_t Sd2Card::setSckRate(uint8_t sckRateID) {
#ifdef USE_TEENSY3_SPI
spiInit(sckRateID);
return true;
#elif defined(__AVR_XMEGA__)
SPI.setBitOrder(MSBFIRST);
SPI.setDataMode(SPI_MODE0);
switch (sckRateID) {
case 0: SPI.setClockDivider(SPI_CLOCK_DIV2); break;
case 1: SPI.setClockDivider(SPI_CLOCK_DIV4); break;
case 2: SPI.setClockDivider(SPI_CLOCK_DIV8); break;
case 3: SPI.setClockDivider(SPI_CLOCK_DIV16); break;
case 4: SPI.setClockDivider(SPI_CLOCK_DIV32); break;
case 5: SPI.setClockDivider(SPI_CLOCK_DIV64); break;
default: SPI.setClockDivider(SPI_CLOCK_DIV128);
}
SPI.begin();
return true;
#else
if (sckRateID > 6) sckRateID = 6;
// see avr processor datasheet for SPI register bit definitions
if ((sckRateID & 1) || sckRateID == 6) {
SPSR &= ~(1 << SPI2X);
} else {
SPSR |= (1 << SPI2X);
}
SPCR &= ~((1 <<SPR1) | (1 << SPR0));
SPCR |= (sckRateID & 4 ? (1 << SPR1) : 0)
| (sckRateID & 2 ? (1 << SPR0) : 0);
#ifdef SPI_HAS_TRANSACTION
switch (sckRateID) {
case 0: settings = SPISettings(8000000, MSBFIRST, SPI_MODE0); break;
case 1: settings = SPISettings(4000000, MSBFIRST, SPI_MODE0); break;
case 2: settings = SPISettings(2000000, MSBFIRST, SPI_MODE0); break;
case 3: settings = SPISettings(1000000, MSBFIRST, SPI_MODE0); break;
case 4: settings = SPISettings(500000, MSBFIRST, SPI_MODE0); break;
case 5: settings = SPISettings(250000, MSBFIRST, SPI_MODE0); break;
default: settings = SPISettings(125000, MSBFIRST, SPI_MODE0);
}
#endif
return true;
#endif
}
int main(int argc, char* argv[])
{
csInit ();
spiInit(SPI1);
mySPI_SendData(Ctrl_Reg1, 0x40); //0x40 = 0100000, 0xC0 = 11000000 = 400 Hz output data rate), active
uart_open(myUSART, 9600, 0);
uint8_t ri;
cmdi = 0;
timInit();
// Infinite loop
while (1)
{
}
uart_close(myUSART);
}
uint8_t RFM69_init()
{
mrtDelay(12);
//Configure SPI
spiInit(LPC_SPI0,24,0);
mrtDelay(100);
// Set up device
uint8_t i;
for (i = 0; CONFIG[i][0] != 255; i++)
spiWrite(CONFIG[i][0], CONFIG[i][1]);
RFM69_setMode(_mode);
// Clear TX/RX Buffer
_bufLen = 0;
return 1;
}
//Disks initialization
int StorageInit(void){
FRESULT res; // FatFs function common result code
u08 fr_res_buf[50]; //buffer for error text message
u08* frame = fr_res_buf; //buffer for received frame (same as above)
u08 logname[30];
wait_ms(1);
spiInit();
wait_s(1);
//SD initializing
res = StorageSdInit();
if(res !=FR_OK){
debug_msg("Storage: SD Card Error!");
//here can try again and if three probes fail,
//then below
fsDispFRESULT(res, fr_res_buf);
//while(1) wait_s(120); //never ending loop
}else{
debug_msg("Storage: SD Card Initialized");
}
}
// Functions
u08 ads7870Init(void)
{
// initialize spi interface
spiInit();
// switch to f/4 bitrate
cbi(SPCR, SPR0);
cbi(SPCR, SPR1);
//sbi(SPSR, SPI2X);
// setup chip select
sbi(ADS7870_CS_PORT, ADS7870_CS_PIN);
sbi(ADS7870_CS_DDR, ADS7870_CS_PIN);
// check ID register
if(ads7870ReadReg(ADS7870_ID) != ADS7870_ID_VALUE)
return 0;
// setup reference and buffer
ads7870WriteReg(ADS7870_REFOSC, ADS7870_REFOSC_OSCE | ADS7870_REFOSC_REFE | ADS7870_REFOSC_BUFE);
// return success
return 1;
}
void init(void)
{
#ifdef USE_HAL_DRIVER
HAL_Init();
#endif
printfSupportInit();
initEEPROM();
ensureEEPROMContainsValidData();
readEEPROM();
systemState |= SYSTEM_STATE_CONFIG_LOADED;
systemInit();
//i2cSetOverclock(masterConfig.i2c_overclock);
// initialize IO (needed for all IO operations)
IOInitGlobal();
debugMode = masterConfig.debug_mode;
#ifdef USE_HARDWARE_REVISION_DETECTION
detectHardwareRevision();
#endif
// Latch active features to be used for feature() in the remainder of init().
latchActiveFeatures();
#ifdef ALIENFLIGHTF3
ledInit(hardwareRevision == AFF3_REV_1 ? false : true);
#else
ledInit(false);
#endif
LED2_ON;
#ifdef USE_EXTI
EXTIInit();
#endif
#if defined(BUTTONS)
gpio_config_t buttonAGpioConfig = {
BUTTON_A_PIN,
Mode_IPU,
Speed_2MHz
};
gpioInit(BUTTON_A_PORT, &buttonAGpioConfig);
gpio_config_t buttonBGpioConfig = {
BUTTON_B_PIN,
Mode_IPU,
Speed_2MHz
};
gpioInit(BUTTON_B_PORT, &buttonBGpioConfig);
// Check status of bind plug and exit if not active
delayMicroseconds(10); // allow GPIO configuration to settle
if (!isMPUSoftReset()) {
uint8_t secondsRemaining = 5;
bool bothButtonsHeld;
do {
bothButtonsHeld = !digitalIn(BUTTON_A_PORT, BUTTON_A_PIN) && !digitalIn(BUTTON_B_PORT, BUTTON_B_PIN);
if (bothButtonsHeld) {
if (--secondsRemaining == 0) {
resetEEPROM();
systemReset();
}
delay(1000);
LED0_TOGGLE;
}
} while (bothButtonsHeld);
}
#endif
#ifdef SPEKTRUM_BIND
if (feature(FEATURE_RX_SERIAL)) {
switch (masterConfig.rxConfig.serialrx_provider) {
case SERIALRX_SPEKTRUM1024:
case SERIALRX_SPEKTRUM2048:
// Spektrum satellite binding if enabled on startup.
// Must be called before that 100ms sleep so that we don't lose satellite's binding window after startup.
// The rest of Spektrum initialization will happen later - via spektrumInit()
spektrumBind(&masterConfig.rxConfig);
break;
}
}
#endif
delay(100);
timerInit(); // timer must be initialized before any channel is allocated
#if !defined(USE_HAL_DRIVER)
dmaInit();
#endif
#if defined(AVOID_UART1_FOR_PWM_PPM)
serialInit(&masterConfig.serialConfig, feature(FEATURE_SOFTSERIAL),
feature(FEATURE_RX_PPM) || feature(FEATURE_RX_PARALLEL_PWM) ? SERIAL_PORT_USART1 : SERIAL_PORT_NONE);
#elif defined(AVOID_UART2_FOR_PWM_PPM)
serialInit(&masterConfig.serialConfig, feature(FEATURE_SOFTSERIAL),
feature(FEATURE_RX_PPM) || feature(FEATURE_RX_PARALLEL_PWM) ? SERIAL_PORT_USART2 : SERIAL_PORT_NONE);
#elif defined(AVOID_UART3_FOR_PWM_PPM)
serialInit(&masterConfig.serialConfig, feature(FEATURE_SOFTSERIAL),
feature(FEATURE_RX_PPM) || feature(FEATURE_RX_PARALLEL_PWM) ? SERIAL_PORT_USART3 : SERIAL_PORT_NONE);
#else
serialInit(&masterConfig.serialConfig, feature(FEATURE_SOFTSERIAL), SERIAL_PORT_NONE);
#endif
mixerInit(masterConfig.mixerMode, masterConfig.customMotorMixer);
#ifdef USE_SERVOS
servoMixerInit(masterConfig.customServoMixer);
#endif
uint16_t idlePulse = masterConfig.motorConfig.mincommand;
if (feature(FEATURE_3D)) {
idlePulse = masterConfig.flight3DConfig.neutral3d;
}
if (masterConfig.motorConfig.motorPwmProtocol == PWM_TYPE_BRUSHED) {
featureClear(FEATURE_3D);
idlePulse = 0; // brushed motors
}
#ifdef USE_QUAD_MIXER_ONLY
motorInit(&masterConfig.motorConfig, idlePulse, QUAD_MOTOR_COUNT);
#else
motorInit(&masterConfig.motorConfig, idlePulse, mixers[masterConfig.mixerMode].motorCount);
#endif
#ifdef USE_SERVOS
if (isMixerUsingServos()) {
//pwm_params.useChannelForwarding = feature(FEATURE_CHANNEL_FORWARDING);
servoInit(&masterConfig.servoConfig);
}
#endif
#ifndef SKIP_RX_PWM_PPM
if (feature(FEATURE_RX_PPM)) {
ppmRxInit(&masterConfig.ppmConfig, masterConfig.motorConfig.motorPwmProtocol);
} else if (feature(FEATURE_RX_PARALLEL_PWM)) {
pwmRxInit(&masterConfig.pwmConfig);
}
pwmRxSetInputFilteringMode(masterConfig.inputFilteringMode);
#endif
mixerConfigureOutput();
#ifdef USE_SERVOS
servoConfigureOutput();
#endif
systemState |= SYSTEM_STATE_MOTORS_READY;
#ifdef BEEPER
beeperInit(&masterConfig.beeperConfig);
#endif
/* temp until PGs are implemented. */
#ifdef INVERTER
initInverter();
#endif
#ifdef USE_BST
bstInit(BST_DEVICE);
#endif
#ifdef USE_SPI
#ifdef USE_SPI_DEVICE_1
spiInit(SPIDEV_1);
#endif
#ifdef USE_SPI_DEVICE_2
spiInit(SPIDEV_2);
#endif
#ifdef USE_SPI_DEVICE_3
#ifdef ALIENFLIGHTF3
if (hardwareRevision == AFF3_REV_2) {
spiInit(SPIDEV_3);
}
#else
spiInit(SPIDEV_3);
#endif
#endif
#ifdef USE_SPI_DEVICE_4
spiInit(SPIDEV_4);
#endif
#endif
#ifdef VTX
vtxInit();
#endif
#ifdef USE_HARDWARE_REVISION_DETECTION
updateHardwareRevision();
#endif
#if defined(NAZE)
if (hardwareRevision == NAZE32_SP) {
serialRemovePort(SERIAL_PORT_SOFTSERIAL2);
} else {
serialRemovePort(SERIAL_PORT_USART3);
}
#endif
#if defined(SPRACINGF3) && defined(SONAR) && defined(USE_SOFTSERIAL2)
if (feature(FEATURE_SONAR) && feature(FEATURE_SOFTSERIAL)) {
serialRemovePort(SERIAL_PORT_SOFTSERIAL2);
}
#endif
#if defined(SPRACINGF3MINI) || defined(OMNIBUS) || defined(X_RACERSPI)
#if defined(SONAR) && defined(USE_SOFTSERIAL1)
if (feature(FEATURE_SONAR) && feature(FEATURE_SOFTSERIAL)) {
serialRemovePort(SERIAL_PORT_SOFTSERIAL1);
}
#endif
#endif
#ifdef USE_I2C
#if defined(NAZE)
if (hardwareRevision != NAZE32_SP) {
i2cInit(I2C_DEVICE);
} else {
if (!doesConfigurationUsePort(SERIAL_PORT_USART3)) {
i2cInit(I2C_DEVICE);
}
}
#elif defined(CC3D)
if (!doesConfigurationUsePort(SERIAL_PORT_USART3)) {
i2cInit(I2C_DEVICE);
}
#else
i2cInit(I2C_DEVICE);
#endif
#endif
#ifdef USE_ADC
drv_adc_config_t adc_params;
adc_params.enableVBat = feature(FEATURE_VBAT);
adc_params.enableRSSI = feature(FEATURE_RSSI_ADC);
adc_params.enableCurrentMeter = feature(FEATURE_CURRENT_METER);
adc_params.enableExternal1 = false;
#ifdef OLIMEXINO
adc_params.enableExternal1 = true;
#endif
#ifdef NAZE
// optional ADC5 input on rev.5 hardware
adc_params.enableExternal1 = (hardwareRevision >= NAZE32_REV5);
#endif
adcInit(&adc_params);
#endif
initBoardAlignment(&masterConfig.boardAlignment);
#ifdef DISPLAY
if (feature(FEATURE_DISPLAY)) {
displayInit(&masterConfig.rxConfig);
}
#endif
#ifdef USE_RTC6705
if (feature(FEATURE_VTX)) {
rtc6705_soft_spi_init();
current_vtx_channel = masterConfig.vtx_channel;
rtc6705_soft_spi_set_channel(vtx_freq[current_vtx_channel]);
rtc6705_soft_spi_set_rf_power(masterConfig.vtx_power);
}
#endif
#ifdef OSD
if (feature(FEATURE_OSD)) {
osdInit();
}
#endif
if (!sensorsAutodetect(&masterConfig.sensorAlignmentConfig,
masterConfig.acc_hardware,
masterConfig.mag_hardware,
masterConfig.baro_hardware,
masterConfig.mag_declination,
masterConfig.gyro_lpf,
masterConfig.gyro_sync_denom)) {
// if gyro was not detected due to whatever reason, we give up now.
failureMode(FAILURE_MISSING_ACC);
}
systemState |= SYSTEM_STATE_SENSORS_READY;
LED1_ON;
LED0_OFF;
LED2_OFF;
for (int i = 0; i < 10; i++) {
LED1_TOGGLE;
LED0_TOGGLE;
delay(25);
if (!(getBeeperOffMask() & (1 << (BEEPER_SYSTEM_INIT - 1)))) BEEP_ON;
delay(25);
BEEP_OFF;
}
LED0_OFF;
LED1_OFF;
#ifdef MAG
if (sensors(SENSOR_MAG))
compassInit();
#endif
imuInit();
mspFcInit();
mspSerialInit();
#ifdef USE_CLI
cliInit(&masterConfig.serialConfig);
#endif
failsafeInit(&masterConfig.rxConfig, masterConfig.flight3DConfig.deadband3d_throttle);
rxInit(&masterConfig.rxConfig, masterConfig.modeActivationConditions);
#ifdef GPS
if (feature(FEATURE_GPS)) {
gpsInit(
&masterConfig.serialConfig,
&masterConfig.gpsConfig
);
navigationInit(
&masterConfig.gpsProfile,
¤tProfile->pidProfile
);
}
#endif
#ifdef SONAR
if (feature(FEATURE_SONAR)) {
sonarInit(&masterConfig.sonarConfig);
}
#endif
#ifdef LED_STRIP
ledStripInit(masterConfig.ledConfigs, masterConfig.colors, masterConfig.modeColors, &masterConfig.specialColors);
if (feature(FEATURE_LED_STRIP)) {
ledStripEnable();
}
#endif
#ifdef TELEMETRY
if (feature(FEATURE_TELEMETRY)) {
telemetryInit();
}
#endif
#ifdef USB_CABLE_DETECTION
usbCableDetectInit();
#endif
#ifdef TRANSPONDER
if (feature(FEATURE_TRANSPONDER)) {
transponderInit(masterConfig.transponderData);
transponderEnable();
transponderStartRepeating();
systemState |= SYSTEM_STATE_TRANSPONDER_ENABLED;
}
#endif
#ifdef USE_FLASHFS
#ifdef NAZE
if (hardwareRevision == NAZE32_REV5) {
m25p16_init(IO_TAG_NONE);
}
#elif defined(USE_FLASH_M25P16)
m25p16_init(IO_TAG_NONE);
#endif
flashfsInit();
#endif
#ifdef USE_SDCARD
bool sdcardUseDMA = false;
sdcardInsertionDetectInit();
#ifdef SDCARD_DMA_CHANNEL_TX
#if defined(LED_STRIP) && defined(WS2811_DMA_CHANNEL)
// Ensure the SPI Tx DMA doesn't overlap with the led strip
#if defined(STM32F4) || defined(STM32F7)
sdcardUseDMA = !feature(FEATURE_LED_STRIP) || SDCARD_DMA_CHANNEL_TX != WS2811_DMA_STREAM;
#else
sdcardUseDMA = !feature(FEATURE_LED_STRIP) || SDCARD_DMA_CHANNEL_TX != WS2811_DMA_CHANNEL;
#endif
#else
sdcardUseDMA = true;
#endif
#endif
sdcard_init(sdcardUseDMA);
afatfs_init();
#endif
if (masterConfig.gyro_lpf > 0 && masterConfig.gyro_lpf < 7) {
masterConfig.pid_process_denom = 1; // When gyro set to 1khz always set pid speed 1:1 to sampling speed
masterConfig.gyro_sync_denom = 1;
}
setTargetPidLooptime((gyro.targetLooptime + LOOPTIME_SUSPEND_TIME) * masterConfig.pid_process_denom); // Initialize pid looptime
#ifdef BLACKBOX
initBlackbox();
#endif
if (masterConfig.mixerMode == MIXER_GIMBAL) {
accSetCalibrationCycles(CALIBRATING_ACC_CYCLES);
}
gyroSetCalibrationCycles();
#ifdef BARO
baroSetCalibrationCycles(CALIBRATING_BARO_CYCLES);
#endif
// start all timers
// TODO - not implemented yet
timerStart();
ENABLE_STATE(SMALL_ANGLE);
DISABLE_ARMING_FLAG(PREVENT_ARMING);
#ifdef SOFTSERIAL_LOOPBACK
// FIXME this is a hack, perhaps add a FUNCTION_LOOPBACK to support it properly
loopbackPort = (serialPort_t*)&(softSerialPorts[0]);
if (!loopbackPort->vTable) {
loopbackPort = openSoftSerial(0, NULL, 19200, SERIAL_NOT_INVERTED);
}
serialPrint(loopbackPort, "LOOPBACK\r\n");
#endif
// Now that everything has powered up the voltage and cell count be determined.
if (feature(FEATURE_VBAT | FEATURE_CURRENT_METER))
batteryInit(&masterConfig.batteryConfig);
#ifdef DISPLAY
if (feature(FEATURE_DISPLAY)) {
#ifdef USE_OLED_GPS_DEBUG_PAGE_ONLY
displayShowFixedPage(PAGE_GPS);
#else
displayResetPageCycling();
displayEnablePageCycling();
#endif
}
#endif
#ifdef CJMCU
LED2_ON;
#endif
// Latch active features AGAIN since some may be modified by init().
latchActiveFeatures();
motorControlEnable = true;
fcTasksInit();
systemState |= SYSTEM_STATE_READY;
}
void systemInit(bool overclock)
{
//RCC_ClocksTypeDef rccClocks;
int i;
// start fpu
SCB->CPACR = (0x3 << (10 * 2)) | (0x3 << (11 * 2));
/* Reset the RCC clock configuration to the default reset state ------------*/
/* Set HSION bit */
RCC->CR |= (uint32_t)0x00000001;
/* Reset CFGR register */
RCC->CFGR = 0x00000000;
/* Reset HSEON, CSSON and PLLON bits */
RCC->CR &= (uint32_t)0xFEF6FFFF;
/* Reset PLLCFGR register */
RCC->PLLCFGR = 0x24003010;
/* Reset HSEBYP bit */
RCC->CR &= (uint32_t)0xFFFBFFFF;
/* Disable all interrupts */
RCC->CIR = 0x00000000;
#ifdef DATA_IN_ExtSRAM
SystemInit_ExtMemCtl();
#endif /* DATA_IN_ExtSRAM */
/* Configure the System clock source, PLL Multiplier and Divider factors,
AHB/APBx prescalers and Flash settings ----------------------------------*/
SetSysClock();
#define VECT_TAB_OFFSET 0x00 /*!< Vector Table base offset field.
/* Configure the Vector Table location add offset address ------------------*/
#ifdef VECT_TAB_SRAM
SCB->VTOR = SRAM_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal SRAM */
#else
SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal FLASH */
#endif
// Init cycle counter
cycleCounterInit();
// SysTick
SysTick_Config(SystemCoreClock / 1000);
// RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div256); // 72 MHz divided by 256 = 281.25 kHz
// Turn on peripherial clocks
// RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_ADC12, ENABLE);
// RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE); // USART1, USART2
// RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE); // ADC2
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
// RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); // PWM Out + PWM RX
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); // PWM Out
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE); // PWM Out + PWM RX
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C3, ENABLE); // i2c
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5, ENABLE); //
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM8, ENABLE); //
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM10, ENABLE); //
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM11, ENABLE); //
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM12, ENABLE); //
// RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM7, ENABLE); //
//
// PPM + PWM RX
// RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM8, ENABLE); //
// RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM15, ENABLE); // PWM Out
// RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM16, ENABLE); // PWM Out
// RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM17, ENABLE); // PWM Out
// RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); // Telemetry
// RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); // GPS
// RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE); // Spektrum RX
RCC_ClearFlag();
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); // 2 bits for pre-emption priority, 2 bits for subpriority
gpioStart();
spiInit();
// if feature(FEATURE_I2C)
// i2cInit(I2C2);
for (i = 0; i < 10; i++) {
LED0_TOGGLE
delay(25);
BEEP_ON
delay(25);
BEEP_OFF
}
LED0_OFF
}
void PlayStationInit(void)
{
spiInit();
}