error_t CellStatus_InitCell(cell_t * cell) { cell->balance = FALSE; error_t retVal = Timer_Setup(&cell->relaxationTimer, NULL); cell->status = CELL_OK; cell->voltage = -1; return retVal; }
void main(void) { OSCCON = 0b11110010; // internal oscillator, 8MHz while(!OSCCONbits.IOFS); //Wait for OSC to become stable Interrupt_Setup(); Timer_Setup(); while(1) { } }
void main(void) { unsigned long left_wheel_total; unsigned long right_wheel_total; unsigned long left_wheel_comp; unsigned long right_wheel_comp; OSCCON = 0b11110010; // internal oscillator, 8MHz while(!OSCCONbits.IOFS); //Wait for OSC to become stable LATC=0; Interrupt_Setup(); Timer_Setup(); while(1) { // while(//rfid not read) // { // left_wheel_total=0xFFFF*left_wheel_overflow_counter + TMR5; //total number of counts of encoder will be number of overflows*0xFFFF + current tmr value // right_wheel_total=0xFFFF*right_wheel_overflow_counter + TMR1; // } // // left_wheel_overflow_counter=0; //reset all values // right_wheel_overflow_counter=0; // TMR1=0; // TMR5=0; // // while(//Go home) // { // left_wheel_comp=0xFFFF*left_wheel_overflow_counter + TMR5; //total number of counts of encoder will be number of overflows*0xFFFF + current tmr value // right_wheel_comp=0xFFFF*right_wheel_overflow_counter + TMR1; // // //PID control of wheels? // // //or relative proportion of each? // // } //may have to add additional direcional nuances (or ensure that they are always moving forwards } }
void BatteryController_Task(void) { SoftwareInit(); uint16_t i; timer_t balanceDoneTimer; Timer_Setup(&balanceDoneTimer, NULL); // Run this task forever. // todo: Update this to variable that disables on error while(1) { I2C_Update(); state_t state = GetState(); if ((state == CHARGE) || (state == CHARGE_BALANCE)) { for (i = 0; i < CELLS_IN_SERIES; i++) { // If any cell above maximum cell voltage if (cells[i].voltage >= MAX_CELL_VOLTAGE) { // If only charging, go to wait. If charge and balance, // go to balance. (state == CHARGE) ? SetState(WAIT) : SetState(BALANCE); } if (cells[i].voltage >= MAX_CELL_CRITICAL_VOLTAGE) { // Go into error state. // todo: Assert error SetState(ERROR); } } } if ((state == BALANCE) || (state == CHARGE_BALANCE)) { // todo: This probably needs changed. We will leave balancing // as soon as no cells are balancing but we should wait for // relaxation time before knowing for sure to leave this state Bool doneBalancing = TRUE; for (i = 0; i < CELLS_IN_SERIES; i++) { if (batteryController_NeedsBalanced(&cells[i])) { cells[i].balance = TRUE; doneBalancing = FALSE; } else { cells[i].balance = FALSE; } } if (doneBalancing) { /// No cells balancing. Start timer that will transition /// states if cell doesn't balance in #BALANCE_RELAXATION_TIME if (!Timer_IsActive(&balanceDoneTimer)) { Timer_Start(&balanceDoneTimer, BALANCE_RELAXATION_TIME); } } else { /// Cell still balancing. Stop balancer timeout timer. Timer_Stop(&balanceDoneTimer); } } if (state == WAIT) { //TEMPORARY uint8_t expanderInputPort0 = I2C_GetPortInput(PORT_0); uint8_t expanderInputPort1 = I2C_GetPortInput(PORT_1); uint16_t * testPtr = NULL; /// Update SPI outputs Uint16 i = 0; for (i = 0; i < DRV8860_IN_SERIES; i++) { /// Open all relays SPI_PushToQueue(0xFF, RELAYS); } SPI_SendTx(RELAYS); //SPI_DRV8860_GetFaults(testPtr, 1); if (expanderInputPort0 & START_BUTTON) { if (expanderInputPort0 & SWITCH_CHARGE_AND_BALANCE) { SetState(CHARGE_BALANCE); } else if (expanderInputPort0 & SWITCH_CHARGE) { // Set next state to CHARGE SetState(CHARGE); } else { // Balance only mode SetState(BALANCE); } } } } }
/** * \fn void Initialize(void) * \brief Initializes hardware and software parameters that required for this program. * \return TRUE if initialization routines executed successfully. */ BOOL Initialize(void) /* TODO: check following statements */ { DisableInterrupts; if (!CRG_SetupPLL(CONFIG_BUSCLK, CONFIG_OSCCLK, CONFIG_REFCLK)) { #ifndef NO_DEBUG DEBUG(__LINE__, ERR_CRGPLL_SETUP); #endif return bFALSE; } if (!EEPROM_Setup(CONFIG_OSCCLK, CONFIG_BUSCLK)) { #ifndef NO_DEBUG DEBUG(__LINE__, ERR_EEPROM_SETUP); #endif return bFALSE; } if (!Packet_Setup(CONFIG_SCI_BAUDRATE, CONFIG_BUSCLK)) { #ifndef NO_DEBUG DEBUG(__LINE__, ERR_PACKET_SETUP); #endif return bFALSE; } if (!CRG_SetupCOP(CONFIG_COP_RATE)) { #ifndef NO_DEBUG DEBUG(__LINE__, ERR_CRGCOP_SETUP); #endif return bFALSE; } if (ModConProtocolMode == 0xFFFF) { if (!EEPROM_Write16(&ModConProtocolMode, DEFAULT_MODCON_PROTOCOL_MODE)) { #ifndef NO_DEBUG DEBUG(__LINE__, ERR_EEPROM_WRITE); #endif return bFALSE; } } if (ModConNumber == 0xFFFF) { if (!EEPROM_Write16(&ModConNumber, DEFAULT_MODCON_NUMBER)) { #ifndef NO_DEBUG DEBUG(__LINE__, ERR_EEPROM_WRITE); #endif return bFALSE; } } if (ModConMode == 0xFFFF) { if (!EEPROM_Write16(&ModConMode, DEFAULT_MODCON_MODE)) { #ifndef NO_DEBUG DEBUG(__LINE__, ERR_EEPROM_WRITE); #endif return bFALSE; } } if (ModConAnalogInputChannelSwitch == 0xFFFF) { if (!EEPROM_Write16(&ModConAnalogInputChannelSwitch, DEFAULT_MODCON_ANALOG_INPUT_CHANNEL_SWITCH)) { #ifndef NO_DEBUG DEBUG(__LINE__, ERR_EEPROM_WRITE); #endif return bFALSE; } } if (ModConAnalogOutputChannelSwitch == 0xFFFF) { if (!EEPROM_Write16(&ModConAnalogOutputChannelSwitch, DEFAULT_MODCON_ANALOG_OUTPUT_CHANNEL_SWITCH)) { #ifndef NO_DEBUG DEBUG(__LINE__, ERR_EEPROM_WRITE); #endif return bFALSE; } } if (ModConAnalogSamplingRate == 0xFFFF) { if (!EEPROM_Write16(&ModConAnalogSamplingRate, DEFAULT_MODCON_ANALOG_SAMPLING_RATE)) { #ifndef NO_DEBUG DEBUG(__LINE__, ERR_EEPROM_WRITE); #endif return bFALSE; } } if (ModConDebug == 0xFFFF) { if (!EEPROM_Write16(&ModConDebug, DEFAULT_MODCON_DEBUG)) { #ifndef NO_DEBUG DEBUG(__LINE__, ERR_EEPROM_WRITE); #endif return bFALSE; } } Clock_Setup(CONFIG_RTI_PRESCALERATE, CONFIG_RTI_MODULUSCOUNT); Timer_Setup(); Timer_SetupPeriodicTimer(ModConAnalogSamplingRate, CONFIG_BUSCLK); Timer_AttachPeriodicTimerRoutine(&SampleAnalogInputChannels); Analog_Setup(CONFIG_BUSCLK); Timer_PeriodicTimerEnable(bTRUE); #ifndef NO_INTERRUPT EnableInterrupts; #endif return bTRUE; }
int main(void) { // Enable watchdog (restart avr if program hangs for 2 seconds) wdt_enable(WDTO_2S); Buttons buttons; DHT22sensor sensor; //uart_init(UART_BAUD_SELECT(USART_BAUDRATE, F_CPU)); extConnector.Init(); // Initialize all connected devices //alarm.Init(OnAlarmStarted, OnAlarmEnded); alarm.ClearAllFlags(); sevSegMenu.Init(); ledIndicators.Init(); buttons.Init(); sensor.Init(); sensorRefreshTimer.Init(); sensorRefreshTimer.SetCounterTop(DHT22_REFRESHTIME); timerHum.Init(); timerTemp.Init(); speaker.InitSpeaker(); speaker.PlayTone(); //sensorResultAverageTemperature.Init(); //sensorResultAverageHumidity.Init(); MULTIPLEX_Setup(); Timer_Setup(); //ReadDefaultSettings(); done in readsettings if needed ReadSettings(); triacTemp.InitPorts(&TRIAC_TEMP_PORT, &TRIAC_TEMP_DDR, TRIAC_TEMP_PIN, ®SettingsTemp.normallyClosed.variable); triacHum.InitPorts(&TRIAC_HUM_PORT, &TRIAC_HUM_DDR, TRIAC_HUM_PIN, ®SettingsHum.normallyClosed.variable); DHT22result sensorResult = {0,0}; sei(); //alarm.SetAlarmFlag(AlarmType_SOFTWARE_FAIL); //DHT22result tempResult = {0,0}; while (1) { wdt_reset(); uint8_t sendSensorDataOverUart = 0; if (!sensorRefreshTimer.IsRunning()) { SensorResult sr = sensor.ReadSensor(&sensorResult); switch(sr) { case SensorOK: alarm.ClearAlarmFlag(AlarmType_SENSOR_FAILURE); bootCompleted = 1; // Enable regulation updates sendSensorDataOverUart = 1; sensorRefreshTimer.ResetCounter(); //sensorAverage.ProcessValue(&sensorResult); break; default: alarm.SetAlarmFlag(AlarmType_SENSOR_FAILURE); sprintf_P(buffor, PSTR("E%u"), sr); // Newline gets added in SendAlarmInfo extConnector.uPuts(buffor); //uart_puts SendAlarmInfo(); case SensorBusy: sensorRefreshTimer.AddTicks(20); // Reduce the error flood break; } } // If alarm is because of bad regulation, show normal menu instead of error code sevSegMenu.SetAlarm(alarm.GetActiveCriticalFlags()); // Beep the speaker if buttons are pressed ButtonEvent currentButtonEvent = buttons.ProcessInputs(); if (currentButtonEvent > BUTTON_MULTIPLE && currentButtonEvent < BUTTON_LEFT_RAPID ) { speaker.PlayTone(); } sevSegMenu.MainMenuUpdate(currentButtonEvent, &sensorResult); ////////////////////////////////////////////////////////////////////////// // Regulation //_delay_ms(1); RegulationResult resTemp, resHum; resTemp = RegulationUpdate(AlarmType_TEMPERATURE_REGULATION, &sensorResult); resHum = RegulationUpdate(AlarmType_HUMIDITY_REGULATION, &sensorResult); ////////////////////////////////////////////////////////////////////////// // Repaint LEDs sevSegMenu.TurnOnMenuLeds(); if (alarm.GetActiveFlags()) { ledIndicators.TurnOn(LED_Alarm); } if (triacTemp.GetState() || triacHum.GetState()) { ledIndicators.TurnOn(LED_Praca); } ledIndicators.PushChanges(); ////////////////////////////////////////////////////////////////////////// // Update UART if (sendSensorDataOverUart) { //snprintf_P(buffor, UART_BUFFER_SIZE, PSTR("T%.3u.%u H%.3u.%u "), //extConnector.uPuts(buffor); //snprintf_P(buffor, UART_BUFFER_SIZE, PSTR("T%.3u.%u H%.3u.%u G%u N%u\r\n"), int8_t tempRemainder = sensorResult.temperature % 10; if (tempRemainder < 0) { tempRemainder *= -1; } sprintf_P(buffor, PSTR("T%i.%i H%u.%u G%u N%u"), // Newline at the end is added in SendAlarmInfo sensorResult.temperature / 10, tempRemainder, sensorResult.humidity / 10, sensorResult.humidity % 10, resTemp, resHum); extConnector.uPuts(buffor); SendAlarmInfo(); } ProcessUartInput(); if (saveSettingsQueued) { saveSettingsQueued = 0; SaveSettings(); } } }
void SPI_Init(void) { mRxBufferSize = 0; mLcdTxIndex = 0; mRelayTxIndex = 0; mDeviceInUse = NO_DEVICE; /// todo: Setup GPIO registers here EALLOW; // SPI Chip Select line #ifdef PE_BOARD GpioDataRegs.GPADAT.bit.GPIO11 = 1; //ensure CS is high GpioCtrlRegs.GPAMUX1.bit.GPIO11 = 0; // GPIO GpioCtrlRegs.GPADIR.bit.GPIO11 = 1; // output GpioCtrlRegs.GPAQSEL1.bit.GPIO11 = 0; //Synch to SYSCLKOUT only GpioCtrlRegs.GPAPUD.bit.GPIO11 = 1; //disable pull up GpioDataRegs.GPADAT.bit.GPIO11 = 1; //ensure CS is high #else GpioDataRegs.GPADAT.bit.GPIO15 = 1; //ensure CS is high GpioCtrlRegs.GPAMUX1.bit.GPIO15 = 0; // GPIO GpioCtrlRegs.GPADIR.bit.GPIO15 = 1; // output GpioCtrlRegs.GPAQSEL1.bit.GPIO15 = 0; //Synch to SYSCLKOUT only GpioCtrlRegs.GPAPUD.bit.GPIO15 = 1; //disable pull up GpioDataRegs.GPADAT.bit.GPIO15 = 1; //ensure CS is high #endif GpioCtrlRegs.GPAPUD.bit.GPIO24 = 0; // Enable pull-up on GPIO24 (SPISIMOB) #ifdef PE_BOARD GpioCtrlRegs.GPAPUD.bit.GPIO25 = 0; GpioCtrlRegs.GPAPUD.bit.GPIO26 = 0; #else GpioCtrlRegs.GPAPUD.bit.GPIO13 = 0; // Enable pull-up on GPIO13 (SPISOMIB) GpioCtrlRegs.GPAPUD.bit.GPIO14 = 0; // Enable pull-up on GPIO14 (SPICLKB) #endif //GpioCtrlRegs.GPAQSEL2.bit.GPIO24 = 3; // Asynch input GPIO24 (SPISIMOB) #ifdef PE_BOARD GpioCtrlRegs.GPAQSEL2.bit.GPIO25 = 3; //GpioCtrlRegs.GPAQSEL2.bit.GPIO26 = 3; #else GpioCtrlRegs.GPAQSEL1.bit.GPIO13 = 3; // Asynch input GPIO13 (SPISOMIB) GpioCtrlRegs.GPAQSEL1.bit.GPIO14 = 3; // Asynch input GPIO14 (SPICLKB) #endif GpioCtrlRegs.GPAMUX2.bit.GPIO24 = 3;// Configure GPIO24 as SPISIMOB #ifdef PE_BOARD GpioCtrlRegs.GPAMUX2.bit.GPIO25 = 3; GpioCtrlRegs.GPAMUX2.bit.GPIO26 = 3; #else GpioCtrlRegs.GPAMUX1.bit.GPIO13 = 3; // Configure GPIO13 as SPISOMIB GpioCtrlRegs.GPAMUX1.bit.GPIO14 = 3; // Configure GPIO14 as SPICLKB #endif GpioCtrlRegs.GPADIR.bit.GPIO24 = 1; #ifdef PE_BOARD GpioCtrlRegs.GPADIR.bit.GPIO26 = 1; #else GpioCtrlRegs.GPADIR.bit.GPIO14 = 1; #endif EDIS; SpibRegs.SPICCR.bit.SPISWRESET = 0; // Reset SPI SpibRegs.SPICCR.all = 0x0047; //8-bit no loopback //SpibRegs.SPICCR.bit.SPILBK = 1; // Loopback on temporarily for testing /// Master mode, TALK enabled, Interrupt Enable SpibRegs.SPICTL.all = 0x0007; // Reference: Hardware/Front-Panel/Calculations // Requires LSPCLK of SYSCLKOUT/6 SpibRegs.SPIBRR = 86; // SPIFFENA ON SpibRegs.SPIFFTX.all = 0xE040; SpibRegs.SPIFFRX.all = 0x6061; //SpibRegs.SPIPRI.bit.FREE = 1; // Set so breakpoints don't disturb xmission SpibRegs.SPICCR.bit.SPISWRESET = 1; Timer_Setup(&mDelayTimer, NULL); }