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);
}
static void i2c_er_handler(void)
{
// Read the I2Cx status register
uint32_t SR1Register = I2Cx->SR1;
if (SR1Register & 0x0F00) { // an error
error = true;
}
// If AF, BERR or ARLO, abandon the current job and commence new if there are jobs
if (SR1Register & 0x0700) {
(void)I2Cx->SR2; // read second status register to clear ADDR if it is set (note that BTF will not be set after a NACK)
I2C_ITConfig(I2Cx, I2C_IT_BUF, DISABLE); // disable the RXNE/TXE interrupt - prevent the ISR tailchaining onto the ER (hopefully)
if (!(SR1Register & 0x0200) && !(I2Cx->CR1 & 0x0200)) { // if we dont have an ARLO error, ensure sending of a stop
if (I2Cx->CR1 & 0x0100) { // We are currently trying to send a start, this is very bad as start, stop will hang the peripheral
// TODO - busy waiting in highest priority IRQ. Maybe only set flag and handle it from main loop
while (I2Cx->CR1 & 0x0100) { ; } // wait for any start to finish sending
I2C_GenerateSTOP(I2Cx, ENABLE); // send stop to finalise bus transaction
while (I2Cx->CR1 & 0x0200) { ; } // wait for stop to finish sending
i2cInit(I2Cx_index); // reset and configure the hardware
} else {
I2C_GenerateSTOP(I2Cx, ENABLE); // stop to free up the bus
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, DISABLE); // Disable EVT and ERR interrupts while bus inactive
}
}
}
I2Cx->SR1 &= ~0x0F00; // reset all the error bits to clear the interrupt
busy = 0;
}
int main(void)
{
// (Using SDA1 and SCL1
// Configure I2C Port
i2cInit(1,157);
delay_ms(500);
while(1)
{
// Start bit + Address + read or write bit
i2c1StartAddress(I2Caddr, 0); //(7-seg address, write (0))
// Data + Ack
i2c1WriteByte(clrDisplay);
i2c1WriteByte('1');
i2c1WriteByte('2');
i2c1WriteByte('3');
i2c1WriteByte('4');
// Stop Bit
i2c1Stop();
delay_ms(1000);
// Start bit + Address + read or write bit
i2c1StartAddress(I2Caddr, 0); //(7-seg address, write (0))
// Data + Ack
i2c1WriteByte(clrDisplay);
i2c1WriteByte('a');
i2c1WriteByte('5');
i2c1WriteByte('d');
i2c1WriteByte('b');
// Stop Bit
i2c1Stop();
delay_ms(1000);
}
return (EXIT_SUCCESS);
}
error_t smb380Init(void)
{
error_t error;
uint8_t value;
//Debug message
TRACE_INFO("Initializing SMB380...\r\n");
//I2C initialization
i2cInit();
//Read chip ID
error = smb380ReadReg(SMB380_REG_CHIP_ID, &value);
//Any error to report?
if(error) return error;
//Verify chip identifier
if((value & CHIP_ID_MASK) != CHIP_ID_VERSION_2)
return ERROR_INVALID_VERSION;
//Read version register
error = smb380ReadReg(SMB380_REG_VERSION, &value);
//Any error to report?
if(error) return error;
//Select +/-2g range and 25Hz bandwidth
value = CTRL3_RANGE_2G | CTRL3_BANDWIDTH_25HZ;
//Write configuration to SMB380 device
error = smb380WriteReg(SMB380_REG_CTRL3, value);
//Any error to report?
if(error) return error;
//Successful initialization
return NO_ERROR;
}
int
main(void)
{
uint16_t ui1;
LCD_init();
i2cInit();
Timer_Init();
KbdInit();
LCD_busy
LCD_CLRSCR
LCD_WR_LINE(0, 0, "Starting!!!");
for (ui1=0; ui1<0x3F; ui1++)
LCD_busy;
LCD_WR_LINE(0, 0, "Press any key!!!");
LCD_WR_LINE(1, 0, "Shall displayed!");
KBD_RESET_KEY;
while (1) {
KBD_GET_KEY;
LCD_POS(1, 0);
LCD_WR("Scan Code : ");
LCD_PUT_UINT8X(KbdData);
for (ui1=0; ui1<0xFF; ui1++)
{}
KBD_RESET_KEY;
}
return 0;
}
int
main(void)
{
struct ds1307_t rtc_tm;
static const char infostring[] PROGMEM = "Demo - DS1307 RTC\r\n";
char buffer[BUFFER_SIZE];
uartInit(BAUDRATE);
i2cInit(I2C_STD_MODE);
sei();
ds1307Init();
ds1307SetTime(SYS_HOUR, SYS_MINS, SYS_SECS);
ds1307SetDate(SYS_DAY, SYS_MONTH, SYS_YEAR);
uartPutString_P(infostring);
while (1) {
/* Read Current Time from DS1307 and output to UART */
ds1307GetTime(&rtc_tm);
sprintf(buffer, "RTC: [%02d:%02d:%02d] - [%02d.%02d.%02d]\r\n",
rtc_tm.hours, rtc_tm.minutes, rtc_tm.seconds, rtc_tm.day,
rtc_tm.month, rtc_tm.year);
uartPutString(buffer);
_delay_ms(1000);
}
/* never reached */
return (0);
}
// Any PIC initialization that is necessary goes here
void Initialise()
{
FLAG = 0; // Clear everything first
beginPWM(); // initialize PWM associated registers
setPWM(0); // Set PWM to 0 until Arduino say otherwise
i2cInit(I2C_ADDRESS); // initialize I2C
PEIE = 1; // generic peripheral interrupts enabled
PIE1 = 0b00001000; // I2C interrupts enabled
SSPIF = 0; // Clear I2C flag
GIE = 1; // Enable all interrupts
beginEncoder(); // initialize encoder registers (TMR0 & TMR1)
PIE2 = 0; // other peripherals disabled
// Clear and Initate TIMER registers
TMR1 = 0;
TMR0 = 61; // Preset TMR0 so that it will overflow every 10 ms
// Configure interrupts
RBIE = 1; // PORTB interrupts enabled
T0IE = 1; // TMR0 interrupts enabled
TMR1IE = 1; // TMR1 interrupts enabled
// Clear flags
RBIF = 0;
T0IF = 0;
TMR1IF = 0;
// Turn on I/Os
TRISB = 0b11110111;
PORTBbits.RB3 = FORWARD; // default to forward
TRISD = 0;
PORTD = 0;
PORTCbits.RC1 = 0;
}
void ds1307Init(void)
{
i2cInit();
ds1307EnableOscillator();
ds1307SetHourMode(kDS1307Mode24HR);
ds1307SetSquarewaveOutput(DS1307_SQUAREWAVE_ENABLE, DS1307_RATE_1HZ);
}
isl12022mError_t isl12022mInit(void)
{
isl12022mError_t error = ISL12022M_ERROR_OK;
uint8_t buffer[1];
// Initialise I2C
if (i2cInit(I2CMASTER) == false)
{
return ISL12022M_ERROR_I2C_INIT; /* Fatal error */
}
// Make sure write is enabled on the ISL12202M (factory default = disabled)
error = isl12022mReadBuffer(ISL12022M_RTC_ADDRESS, ISL12022M_REG_CSR_INT, buffer, sizeof(buffer));
if (!error)
{
if (!(buffer[0] & ISL12022M_INT_WRITEENABLE))
{
// Write is not enabled on the RTC ... enable it now
error = isl12022mWrite8(ISL12022M_RTC_ADDRESS, ISL12022M_REG_CSR_INT, buffer[0] | ISL12022M_INT_WRITEENABLE);
}
_isl12022mInitialised = true;
}
return error;
}
bool i2cRead(I2C_TypeDef *I2C, uint8_t addr_, uint8_t reg_, uint8_t len, uint8_t *buf)
{
uint32_t timeout = I2C_DEFAULT_TIMEOUT;
I2Cx = I2C;
addr = addr_ << 1;
reg = reg_;
writing = 0;
reading = 1;
read_p = buf;
write_p = buf;
bytes = len;
busy = 1;
if (!(I2Cx->CR2 & I2C_IT_EVT)) // If we are restarting the driver
{
if (!(I2Cx->CR1 & I2C_CR1_START)) // Ensure sending a start
{
while (I2Cx->CR1 & I2C_CR1_STOP) { ; } // Wait for any stop to finish sending
I2C_GenerateSTART(I2Cx, ENABLE); // Send the start for the new job
}
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, ENABLE); // Allow the interrupts to fire off again
}
while (busy && --timeout > 0);
if (timeout == 0) {
if (I2Cx == I2C1) i2c1ErrorCount++;
if (I2Cx == I2C2) i2c2ErrorCount++;
i2cInit(I2Cx); // Reinit peripheral + clock out garbage
return false;
}
return true;
}
void I2C_ER_Handler(void)
{
volatile uint32_t SR1Register, SR2Register;
SR1Register = I2Cx->SR1; // Read the I2Cx status register
if (SR1Register & (I2C_SR1_AF |
I2C_SR1_ARLO |
I2C_SR1_BERR )) // If AF, BERR or ARLO, abandon the current job and commence new if there are jobs
{
SR2Register = I2Cx->SR2; // Read second status register to clear ADDR if it is set (note that BTF will not be set after a NACK)
I2C_ITConfig(I2Cx, I2C_IT_BUF, DISABLE); // Disable the RXNE/TXE interrupt - prevent the ISR tailchaining onto the ER (hopefully)
if (!(SR1Register & I2C_SR1_ARLO) && !(I2Cx->CR1 & I2C_CR1_STOP)) // If we dont have an ARLO error, ensure sending of a stop
{
if (I2Cx->CR1 & I2C_CR1_START) // We are currently trying to send a start, this is very bad as start,stop will hang the peripheral
{
while (I2Cx->CR1 & I2C_CR1_START); // Wait for any start to finish sending
I2C_GenerateSTOP(I2Cx, ENABLE); // Send stop to finalise bus transaction
while (I2Cx->CR1 & I2C_CR1_STOP); // Wait for stop to finish sending
i2cInit(I2Cx); // Reset and configure the hardware
} else
{
I2C_GenerateSTOP(I2Cx, ENABLE); // Stop to free up the bus
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, DISABLE); // Disable EVT and ERR interrupts while bus inactive
}
}
}
I2Cx->SR1 &= ~(I2C_SR1_OVR |
I2C_SR1_AF |
I2C_SR1_ARLO |
I2C_SR1_BERR ); // Reset all the error bits to clear the interrupt
busy = 0;
}
void HardwareI2C::begin()
{
/* set as master */
if (this->i2c_d == _I2C1) afio_remap(AFIO_MAPR_I2C1_REMAP);
i2cInit(this->i2c_d, I2C_400KHz_SPEED);
delay(I2CDELAY);
}
static void i2c_er_handler(I2CDevice device) {
I2C_TypeDef *I2Cx;
I2Cx = i2cHardwareMap[device].dev;
i2cState_t *state;
state = &(i2cState[device]);
// Read the I2C1 status register
volatile uint32_t SR1Register = I2Cx->SR1;
if (SR1Register & 0x0F00) // an error
state->error = true;
// If AF, BERR or ARLO, abandon the current job and commence new if there are jobs
if (SR1Register & 0x0700) {
(void)I2Cx->SR2; // read second status register to clear ADDR if it is set (note that BTF will not be set after a NACK)
I2C_ITConfig(I2Cx, I2C_IT_BUF, DISABLE); // disable the RXNE/TXE interrupt - prevent the ISR tailchaining onto the ER (hopefully)
if (!(SR1Register & I2C_SR1_ARLO) && !(I2Cx->CR1 & I2C_CR1_STOP)) { // if we dont have an ARLO error, ensure sending of a stop
if (I2Cx->CR1 & I2C_CR1_START) { // We are currently trying to send a start, this is very bad as start, stop will hang the peripheral
while (I2Cx->CR1 & I2C_CR1_START) {; } // wait for any start to finish sending
I2C_GenerateSTOP(I2Cx, ENABLE); // send stop to finalise bus transaction
while (I2Cx->CR1 & I2C_CR1_STOP) {; } // wait for stop to finish sending
i2cInit(device); // reset and configure the hardware
}
else {
I2C_GenerateSTOP(I2Cx, ENABLE); // stop to free up the bus
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, DISABLE); // Disable EVT and ERR interrupts while bus inactive
}
}
}
I2Cx->SR1 &= ~0x0F00; // reset all the error bits to clear the interrupt
state->busy = 0;
}
ublox5Error_e ublox5Init(void)
{
unsigned char dat;
int ix;
ublox5Error_e response_error= ublox5Error_OK;
// Initialise I2C
if (i2cInit(I2CMODE_MASTER) == FALSE)
{
return ublox5Error_I2CINIT; /* Fatal error */
}
//Init the GPS structure so it is obvious if we don't have a lock
gps_gga.fix = 0;
gps_gga.lat = 99;
gps_gga.lon = 99;
gps_gga.alt = 99;
gps_gga.sat = 99;
gps_gga.utc = 99;
gps_gga.latitude = 99.0;
gps_gga.longitude = 99.0;
gps_gga.altitude = 99.0;
gps_gga.newdata = 0;
if (response_error == ublox5Error_OK)
{
gps_init = 1;
} else {
gps_init = 0;
}
return response_error;
}
void initI2c( void )
{
// Address pins
palSetPadMode( ADDR_PORT, ADDR_0_PIN, PAL_MODE_INPUT );
palSetPadMode( ADDR_PORT, ADDR_1_PIN, PAL_MODE_INPUT );
palSetPadMode( ADDR_PORT, ADDR_2_PIN, PAL_MODE_INPUT );
palSetPadMode( GPIOB, 6, PAL_MODE_STM32_ALTERNATE_OPENDRAIN );
palSetPadMode( GPIOB, 7, PAL_MODE_STM32_ALTERNATE_OPENDRAIN );
chThdSleepMilliseconds( 100 );
i2cInit();
//chThdSleepMilliseconds( 100 );
i2cStart( &I2CD1, &i2cfg1 );
//chThdSleepMilliseconds( 200 );
// Initial values for IOs.
int16_t i;
for ( i=0; i<I2C_SLAVES_CNT; i++ )
{
outs[i] = 0;
pendOuts[i] = 0;
ins[i] = 0;
}
// Initializing mutex.
chMtxInit( &mutex );
// Creating thread.
chThdCreateStatic( waI2c, sizeof(waI2c), NORMALPRIO, i2cThread, NULL );
}
static bool i2cHandleHardwareFailure(I2CDevice device)
{
i2cErrorCount++;
// reinit peripheral + clock out garbage
i2cInit(device);
return false;
}
static bool i2cHandleHardwareFailure(void)
{
i2cErrorCount++;
// reinit peripheral + clock out garbage
i2cInit(I2Cx_index);
return false;
}
error_t pn532_bus_HWInit(void)
{
#ifdef PN532_DEBUGMODE
PN532_DEBUG("Initialising I2C%s", CFG_PRINTF_NEWLINE);
#endif
i2cInit(I2CMASTER);
// Set reset pin as output and reset device
GPIOSetDir(CFG_PN532_RSTPD_PORT, CFG_PN532_RSTPD_PIN, 1);
#ifdef PN532_DEBUGMODE
PN532_DEBUG("Resetting the PN532%s", CFG_PRINTF_NEWLINE);
#endif
LPC_GPIO->CLR[CFG_PN532_RSTPD_PORT] = (1 << CFG_PN532_RSTPD_PIN);
systickDelay(400);
LPC_GPIO->SET[CFG_PN532_RSTPD_PORT] = (1 << CFG_PN532_RSTPD_PIN);
// Wait for the PN532 to finish booting
systickDelay(100);
// Ping the I2C device first to see if it exists!
if (i2cCheckAddress(PN532_I2C_ADDRESS) == false)
{
#ifdef PN532_DEBUGMODE
PN532_DEBUG("Can't find PN532 on the I2C bus%s", CFG_PRINTF_NEWLINE);
#endif
return ERROR_I2C_DEVICENOTFOUND;
}
// Set IRQ pin to input
GPIOSetDir(CFG_PN532_I2C_IRQPORT, CFG_PN532_I2C_IRQPIN, 0);
return ERROR_NONE;
}
static void i2c_er_handler(void)
{
volatile uint32_t SR1Register, SR2Register;
/* Read the I2C1 status register */
SR1Register = I2Cx->SR1;
if (SR1Register & 0x0F00) { //an error
error = true;
// I2C1error.error = ((SR1Register & 0x0F00) >> 8); //save error
// I2C1error.job = job; //the task
}
/* If AF, BERR or ARLO, abandon the current job and commence new if there are jobs */
if (SR1Register & 0x0700) {
SR2Register = I2Cx->SR2; //read second status register to clear ADDR if it is set (note that BTF will not be set after a NACK)
SR2Register = SR2Register;
I2C_ITConfig(I2Cx, I2C_IT_BUF, DISABLE); //disable the RXNE/TXE interrupt - prevent the ISR tailchaining onto the ER (hopefully)
if (!(SR1Register & 0x0200) && !(I2Cx->CR1 & 0x0200)) { //if we dont have an ARLO error, ensure sending of a stop
if (I2Cx->CR1 & 0x0100) { //We are currently trying to send a start, this is very bad as start,stop will hang the peripheral
while (I2Cx->CR1 & 0x0100); //wait for any start to finish sending
I2C_GenerateSTOP(I2Cx, ENABLE); //send stop to finalise bus transaction
while (I2Cx->CR1 & 0x0200); //wait for stop to finish sending
i2cInit(I2Cx); //reset and configure the hardware
} else {
I2C_GenerateSTOP(I2Cx, ENABLE); //stop to free up the bus
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, DISABLE); //Disable EVT and ERR interrupts while bus inactive
}
}
}
I2Cx->SR1 &= ~0x0F00; //reset all the error bits to clear the interrupt
busy = 0;
}
error_t tcs34725Init(void)
{
uint8_t id = 0;
/* Initialise I2C */
i2cInit(I2CMASTER);
/* Ping the I2C device first to see if it exists! */
ASSERT(i2cCheckAddress(TCS34725_ADDRESS), ERROR_I2C_DEVICENOTFOUND);
/* Make sure we have the right IC (0x44 = TCS34725 and TCS34721) */
ASSERT_STATUS(tcs34725Read8(TCS34725_ID, &id));
ASSERT(id == 0x44, ERROR_DEVICENOTINITIALISED);
/* Enable the device */
ASSERT_STATUS(tcs34725Enable());
/* Ready to go ... set the initialised flag */
_tcs34725Initialised = true;
/* This needs to take place after the initialisation flag! */
ASSERT_STATUS(tcs34725SetIntegrationTime(TCS34725_INTEGRATIONTIME_2_4MS));
ASSERT_STATUS(tcs34725SetGain(TCS34725_GAIN_60X));
return ERROR_NONE;
}
void setup() {
configPins();
initDisplay();
detectInputMode();
menuInit();
i2cInit();
}
bool i2cRead(uint8_t addr_, uint8_t reg_, uint8_t len, uint8_t* buf)
{
uint32_t timeout = I2C_DEFAULT_TIMEOUT;
addr = addr_ << 1;
reg = reg_;
writing = 0;
reading = 1;
read_p = buf;
write_p = buf;
bytes = len;
busy = 1;
error = false;
if (!(I2Cx->CR2 & I2C_IT_EVT)) { //if we are restarting the driver
if (!(I2Cx->CR1 & 0x0100)) { // ensure sending a start
while (I2Cx->CR1 & 0x0200) { ; } //wait for any stop to finish sending
I2C_GenerateSTART(I2Cx, ENABLE); //send the start for the new job
}
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, ENABLE); //allow the interrupts to fire off again
}
while (busy && --timeout > 0);
if (timeout == 0) {
i2cErrorCount++;
// reinit peripheral + clock out garbage
i2cInit(I2Cx);
return false;
}
return !error;
}
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);
}
/**
* @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
}
void initI2Cmodule(void) {
print("Starting I2C module\r\n");
i2cInit();
i2cStart(&I2CD1, &i2cfg);
efiSetPadMode("I2C clock", EFI_I2C_SCL_BRAIN_PIN, PAL_MODE_ALTERNATE(EFI_I2C_AF) | PAL_STM32_OTYPE_OPENDRAIN);
efiSetPadMode("I2C data", EFI_I2C_SDA_BRAIN_PIN, PAL_MODE_ALTERNATE(EFI_I2C_AF) | PAL_STM32_OTYPE_OPENDRAIN);
}
void spyglassInit(void)
{
i2cInit();
i2cSetBitrate(100);
PcfCtrlData = (SPYGLASS_LED0 | SPYGLASS_LED1 | SPYGLASS_BEEPER);
spyglassSetLeds(0);
spyglassSetBeeper(0);
}
void boardInit(void)
{
SIM_SCGC5 |= 0x00000400; //enable Port B clock
SIM_SCGC5 |= 0x00000200; //enable Port A clock
SIM_SCGC5 |= 0x00001000; //enable Port D clock
PORTB_PCR19 |= (uint32_t)0x00000100; //Configure portB19 as GPIO (GREEN)
GPIOB_PDDR |= (uint32_t)0x00080000; //Configure portB19 as output
PORTA_PCR12 |= (uint32_t)0x000A0102; //Configure portA12 as GPIO with falling edge interrupt and pullup enabled.
GPIOA_PDDR &= ~(uint32_t)(1<<12); //Configure portA12 as input.
PORTB_PCR18 |= (uint32_t)0x00000100; //Configure portB18 as GPIO (RED)
GPIOB_PSOR |= (uint32_t)0x00040000;
GPIOB_PDDR |= (uint32_t)0x00040000; //Configure portB18 as output
PORTD_PCR1 |= (uint32_t)0x00000100; //Configure portD1 as GPIO (BLUE)
FGPIOD_PSOR |= (uint32_t)0x00000002;
FGPIOD_PDDR |= (uint32_t)0x00000002; //Configure portD1 as output
//SIM_SCGC6 |= (uint8_t) 0x00800000; // Enable PIT clock
SIM_SOPT2 |= 0x01000000; // Set TPM to use the MCGFLLCLK as a clock source
// MCGFLLCLK is either 24MHz or 23 986 176Hz
SIM_SCGC6 |= 0x01000000; // Enable TPM0 clock
uart0Config();
uart0Enable();
llwuConfigure();
vllsEnable();
vllsConfigure(1);
PMC_REGSC = 0x08;
systickConfigure();
interruptSetPriority(30,0); //Port A ISR
interruptEnable(30);
interruptSetPriority(7,0); // Configure LLWU interrupt as highest priority.
interruptEnable(7); //Enable LLWU interrupt.
systickEnable();
rtcInit();
rtcStart();
interruptSetPriority(21,0); // Configure RTC Seconds interrupt as highest priority.
interruptEnable(21); //Enable RTC Seconds interrupt.
i2cInit();
interruptSetPriority(9,3); // Configure I2C interrupt as Lowest priority.
interruptEnable(9); //Enable I2C interrupt.
interruptSetPriority(22,3); // Configure PIT interrupt as Lowest priority.
interruptEnable(9); //Enable PIT interrupt.
}
void systemInit(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
uint8_t i;
gpio_config_t gpio_cfg[] = {
{ LED0_GPIO, LED0_PIN, GPIO_Mode_Out_PP }, // PB3 (LED)
{ LED1_GPIO, LED1_PIN, GPIO_Mode_Out_PP }, // PB4 (LED)
#ifndef FY90Q
{ BEEP_GPIO, BEEP_PIN, GPIO_Mode_Out_OD }, // PA12 (Buzzer)
#endif
};
uint8_t gpio_count = sizeof(gpio_cfg) / sizeof(gpio_cfg[0]);
// Turn on clocks for stuff we use
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2 | RCC_APB1Periph_TIM3 | RCC_APB1Periph_TIM4 | RCC_APB1Periph_I2C2, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_TIM1 | RCC_APB2Periph_ADC1 | RCC_APB2Periph_USART1, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
RCC_ClearFlag();
// Make all GPIO in by default to save power and reduce noise
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_Init(GPIOC, &GPIO_InitStructure);
// Turn off JTAG port 'cause we're using the GPIO for leds
GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);
// Configure gpio
for (i = 0; i < gpio_count; i++) {
GPIO_InitStructure.GPIO_Pin = gpio_cfg[i].pin;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = gpio_cfg[i].mode;
GPIO_Init(gpio_cfg[i].gpio, &GPIO_InitStructure);
}
LED0_OFF;
LED1_OFF;
BEEP_OFF;
// Init cycle counter
cycleCounterInit();
// SysTick
SysTick_Config(SystemCoreClock / 1000);
// Configure the rest of the stuff
adcInit();
#ifndef FY90Q
i2cInit(I2C2);
#endif
// sleep for 100ms
delay(100);
}
void rtcInit(void)
{
i2cInit();
i2cStart();
i2cWrite(0xD0); // Address the RTC to write
i2cWrite(0x07);
i2cWrite(0x00);
i2cStop();
}
void Daisy23::begin() {
DDRC |= 0b00010011;
PORTC = 0b00110000; // Pull-ups on I2C Bus
i2cInit();
mpr_config();
mpr_lcd_init();
delay(100);
mpr_config();
}
