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);
}
