void initSymPWM1(uint16_t prescaler, _t_pwm_pol pol)
{
/* Override previous PWM init */
initTimer1(prescaler, TMR_CLK_RISE, PWM, CLKOSC, INT_OFF);
/* DC = 0%*/
pwm1Pins(pol);
}
int main() {
SYSTEMConfigPerformance(10000000); //Configures low-level system parameters for 10 MHz clock
enableInterrupts(); //This function is necessary to use interrupts.
//TODO: Write each initialization function
initLEDs();
initTimer1();
while(1) {
switch(state) {
case led1:
LATDbits.LATD0 = ON;
LATDbits.LATD1 = OFF;
LATDbits.LATD2 = OFF;
break;
case led2:
LATDbits.LATD0 = OFF;
LATDbits.LATD1 = ON;
LATDbits.LATD2 = OFF;
break;
case led3:
LATDbits.LATD0 = OFF;
LATDbits.LATD1 = OFF;
LATDbits.LATD2 = ON;
break;
}
}
return 0;
}
int main(void)
{
SYSTEMConfigPerformance(10000000);
initTimer1();
initSW2();
initLEDs();
enableInterrupts();
state = led1;
while(1)
{
//TODO: Using a finite-state machine, define the behavior of the LEDs
//Debounce the switch
switch(state) {
case led1:
turnOnLED(1);
stateNext = led2;
break;
case led2:
turnOnLED(2);
stateNext = led1;
break;
case deBounce1:
delayUs(10000);
break;
case deBounce2:
delayUs(10000);
break;
}
}
return 0;
}
int main() {
SYSTEMConfigPerformance(10000000); //Configures low-level system parameters for 10 MHz clock
enableInterrupts(); //This function is necessary to use interrupts.
initLEDs();
initTimer1();
while(1){
switch(state) {
case INIT:
next_state = LED_0;
break;
case LED_0:
turnOnLED(0);
next_state = LED_1;
break;
case LED_1:
turnOnLED(1);
next_state = LED_2;
break;
case LED_2:
turnOnLED(2);
next_state = LED_0;
break;
}
}
return 0;
}
int main() {
//SYSTEMConfigPerformance(10000000); //Configures low-level system parameters for 10 MHz clock
enableInterrupts(); //This function is necessary to use interrupts.
//TODO: Write each initialization function
initLEDs();
initTimer1();
while(1){
//TODO: Implement a state machine to create the desired functionality
switch(state){
case led1: //LED1 is on
LATDbits.LATD0 = ON;
LATDbits.LATD1 = OFF;
LATDbits.LATD2 = OFF;
break;
case led2: //LED2 is on
LATDbits.LATD0 = OFF;
LATDbits.LATD1 = ON;
LATDbits.LATD2 = OFF;
break;
case led3: //LED3 is on
LATDbits.LATD0 = OFF;
LATDbits.LATD1 = OFF;
LATDbits.LATD2 = ON;
break;
}
}
return 0;
}
//invoke initIO and initTimer1
void Rainbow::init(void)
{
initIO();
initTimer1();
//fill the color buffer with the first perset pic in flash
fillColorBuffer(presetMatrixColorData[0]);
}
void myTimerExec(void)
{
initClocks();
initTimer1();
T1TCR = 0x01;
for(;;);
}
UltraSon::UltraSon() : m_enable(false), m_top(TOP_TIMER1), m_nbrOvf(3), m_pulse(5),
m_diff(0), m_temporaire(0), m_bOK(false), m_cptOvfOutput(0), m_diffChanged(false),
m_cptOvfPWM(0), m_prescaler(250000), m_coeffConvMS(m_prescaler * 0.000001),
m_distance(1), m_distanceNew(1), m_realDistance(0)
{
initPorts();
initTimer1();
PRINTD("ctor us called");
}
int main() {
//This function is necessary to use interrupts.
enableInterrupts();
//initialize the switch, all three LEDs, and the main timer
initSwitch1();
initLEDs();
initTimer2();
initTimer1();
stateCurrent = wait; //set the starting state to no led's on
while(1){
if(PORTDbits.RD6 != 0){
TMR1 = 0;
T1CONbits.TON = 0;
if(status == 1){
status = 0;
stateCurrent = stateNext;
}
switch(stateCurrent){
case(wait):
turnOnLED(0);
stateNext = led1;
break;
case(led1):
turnOnLED(1);
stateNext = led2;
break;
case(led2):
turnOnLED(2);
stateNext = led3;
break;
case(led3):
turnOnLED(3);
stateNext = led1;
break;
default:
stateCurrent = led1;
break;
}
}
else if(PORTDbits.RD6 == 0){
if(status == 0){
T1CONbits.TON = 1;
status = PRESSED; //button was pressed
}
}
}
return 0;
}
//-----------------------------------------------------------------------------
// main
void main(void)
{
initPorts();
initTimer1();
initUART();
while(1)
{
updateDigits();
updateDisplay();
if(beepCounter<115) beepCounter++; // beeper off count
else
{
beepCounter = 0;
BEEP_BEEP_OFF;
}
if(secondCounter<1000) secondCounter++; // 1 second tasks
else
{
if(LATBbits.LATB0 == 0) COLON_ON; // blink colon once per second
else COLON_OFF;
secondCounter = 0;
}
if(lnetTimeoutCounter<14580) lnetTimeoutCounter++; // (lnet timeout 14.58 sec)
else // no overlap with 1 sec
{
LNET_OFF;
lnetConnected = FALSE;
PM_OFF;
lnetHours = 88;
lnetMinutes = 88;
}
// tasks that execute once per second are located in secTasks()
while(TMR1H < 0x09);
while(TMR1L < 0xC4); // wait for 1 ms to elapse
TMR1H = 0;
TMR1L = 0; // reset tmr1 registers
}
return;
}
int main(void)
{
initTimer0(); // Timer0 - Lys/Lyd
initTimer1(); // Timer1 - Lyd(OCR1A) og Delays
initTimer2(); // Timer2 - Motorstyring
initBackLEDPort();
initFrontLEDPort();
sei();
allLightsOn(); // Tænd alle lys
while(1)
{
do
{
ReflectionCount();
DriveForward1();
brakeLightOff();
if( antalRefleksbrik == 3 ) // Brems ved bakken.
{
Brake();
brakeLightOn();
}
if( antalRefleksbrik == 6 ) // Bremse og bak.
{
Brake();
_delay_us(5000000);
brakeLightOn();
Reverse();
}
if( antalRefleksbrik == 8 ) // Når den holder ved refleksbrik nr 5.
{
Brake();
_delay_us(5000000);
}
} while ( antalRefleksbrik >=0 && antalRefleksbrik <=11 );
Brake();
brakeLightNormal();
StopLevelComplete();
}
return 0;
}
int main(void)
{
initTimer0();
initTimer1();
initTimer2();
initSwitchPort();
sei();
//int antalRefleksbrik;
while(1)
{
do
{
ReflectionCount();
DriveForward1();
/*if( StartReflection() == 1 ) // True = 1.
{
DetekCoin();
}
*/
if( antal == 3 ) // Brems ved bakken.
{
Brake();
}
if( antal == 6 ) // Bremse og bak.
{
Brake();
_delay_us(5000000);
Reverse();
}
if( antal == 8 ) // Når den holder ved refleksbrik nr 5.
{
Brake();
_delay_us(5000000);
}
} while ( antal >=0 && antal <=11 );
Brake();
}
return 0;
}
int main() {
SYSTEMConfigPerformance(10000000); //Configures low-level system parameters for 10 MHz clock
enableInterrupts(); //This function is necessary to use interrupts.
//TODO: Write each initialization function
initLEDs();
initTimer1();
while(1){
//TODO: Implement a state machine to create the desired functionality
}
return 0;
}
int main(void) {
char byte;
uint16_t timerValue;
// -------- Inits --------- //
initUSART();
initTimer1();
LED_DDR = 0xff; /* all LEDs for output */
BUTTON_PORT |= (1 << BUTTON); /* enable internal pull-up */
printString("\r\nReaction Timer:\r\n");
printString("---------------\r\n");
printString("Press any key to start.\r\n");
// ------ Event loop ------ //
while (1) {
byte = receiveByte(); /* press any key */
printString("\r\nGet ready...");
randomDelay();
printString("\r\nGo!\r\n");
LED_PORT = 0xff; /* light LEDs */
TCNT1 = 0; /* reset counter */
if (bit_is_clear(BUTTON_PIN, BUTTON)) {
/* Button pressed _exactly_ as LEDs light up. Suspicious. */
printString("You're only cheating yourself.\r\n");
}
else {
// Wait until button pressed, save timer value.
loop_until_bit_is_clear(BUTTON_PIN, BUTTON);
timerValue = TCNT1 >> 4;
/* each tick is approx 1/16 milliseconds, so we bit-shift divide */
printMilliseconds(timerValue);
printComments(timerValue);
}
// Clear LEDs and start again.
LED_PORT = 0x00;
printString("Press any key to try again.\r\n");
} /* End event loop */
return (0); /* This line is never reached */
}
void init(void){
//MCUCR = (1<<PUD); //disable all pull ups
//d6,d7 - LEDs
DDRD = 0xC0; //set PD7:6 to outputs for LEDs
//PD2 as an input for switch
RED_ON; //Set PD7 high and PD6 low
//Switch
PORTD |= (1<<PD2); //set PD2 to high(pullup resistor) for switch
//EIMSK |= (1<<INT0); //turn on interrupt 0 (PD2)
//PCICR |= (1<<PCIE2); //Enable PCINT2
//PCMSK2 |= (1<<PCINT18); //Trigger on change of PCINT18 (PD2)
//sei(); //enable interrupts
//DDRB = 0X20; //all inputs except B5 output
//PORTB |= (1<<PB0); //pull up resistor on (PB0)
//DDRD = 0b11111011; // set PD2 to input
//ADC
//ADC clock must be between 50-200kHz to get maximum resolution
//8MHz/64 (div64) = 125,000
//pin, prescalar
initADC(ADC_PIN, ADC_DIV64);
//timer
// 8MHz/60Hz = 133,333.33333 cycles to count
// 133,333.33333 / 8 (div8) = 16666.666667 = 0x411B
//prescalar, mode, reload
//initTimer1(TIMER_DIV8, 4, 0x411B);
initTimer1(TIMER_DIV64, 4, 0xFFFF);
//opamp
//opamp is Powered Down when PD is low, initialize HIGH?
//250nS delay when powering up, 50nS delay when powering down (1/8MHz = 125nS)
WakeOpAmp();
}
// -------------------------------------------------------------------------------------
static void setup(void)
{
cli();
// adjust power saving modes
PRR = (0<<PRTIM0) | // enable timer0
(0<<PRTIM1) | // enable timer1
(1<<PRUSI) | // disable USI
(0<<PRADC); // enable ADC
initDiagLed();
initTimer0();
initTimer1();
initComparator();
pwmOff();
sei();
}
int main() {
//This function is necessary to use interrupts.
enableInterrupts();
//TODO: Write each initialization function
initSwitch1();
initLEDs();
initTimer2();
initTimer1();
while(1){
//TODO: Implement a state machine to create the desired functionality
}
return 0;
}
void __ISR(_CHANGE_NOTICE_VECTOR, IPL7SRS) _CNInterrupt() {
IFS1bits.CNDIF=0;
initTimer1();
int j;
j=PORTD;
if(PORTDbits.RD6==1 && time>=1)
{
up=1;
}
else if(PORTDbits.RD6==1)
{
switch1=1;
}
time=0;
}
int main(void){
SYSTEMConfigPerformance(40000000);
initTimer1();
initTimer3();
initPWM();
#ifdef PWM
setPwm3(100);
setPwm1(0);
delayUs(100000);
setPwm4(100);
setPwm2(0);
#endif
#ifdef run
initADC();
initLCD();
clearLCD();
writeLCD(0b00001111, 0, 50);
// enableInterrupts();
disableInterrupts();
while(1){
clearLCD();
IFS0bits.AD1IF = 0; // reset adc thing
while(AD1CON1bits.SSRC == 0 );
ADCBufferValue = ADC1BUF0; // get buffer value
printVoltage(ADCBufferValue);
delayUs(100000); // wait one second
leftMotorForward(50);
delayUs(100000); // wait one second
delayUs(100000); // wait one second
rightMotorForward(50);
delayUs(100000); // wait one second
}
#endif
return 0;
}
int main() {
// setup
initTimer1();
DDRA |= 0x3f;
_delay_ms(2000);
uint8_t temp = 0;
uint8_t hmdty = 0;
// loop
while(1) {
readDHT11(&temp, &hmdty);
PORTA = temp;
_delay_ms(1000);
PORTA = hmdty;
_delay_ms(2000);
}
return 0;
}
int main(void)
{
initDisplay();
initUSART();
initTimer1();
char *displayBuffer = (char * ) malloc(DISP_CAP);
//char *displayBufferB = (char * ) malloc(DISP_CAP);
char *inBuffer = (char * ) malloc(RX_CAP);
updateDisplay(displayBuffer,INIT_MSG,10);
int counter = 0;
while (1) {
//updateDisplay(displayBuffer,ACQ_MSG,10);
if (counter == 15) {
sendTestPacket();
updateInBuffer(inBuffer);
updateDisplay(displayBuffer,inBuffer,10);
_delay_ms(DISP_HOLD_TIME);
counter = 0;
} else {
updateInBuffer(inBuffer);
updateDisplay(displayBuffer,inBuffer,10);
_delay_ms(500);
}
counter++;
//int index = 0;
/*while (index < (strlen(inBuffer)-1)) {
getNextInput(inBuffer,index);
updateDisplay(displayBuffer,displayBufferB,10);
index += 32;
if (index < (strlen(inBuffer)-1)) {
_delay_ms(DISP_HOLD_TIME);
}
}*/
}
return 0;
}
int main(void)
{
OSCTUN = 0b0111; // Tune internal FRC: 9.7MHz+3% to have 10MHz => 20MIPS
initPWM();
initTimer2();
initADC();
initTimer1();
initLedOutputs();
initUART();
/* starting state */
send_ping = true;
/* Enable ADC */
ADCONbits.ADON = 1; /* Start the ADC module*/
/* Enable Timer 1 */
T1CONbits.TON = 1;
unsigned int fetched_RTT1_overflows, fetched_RTT2_overflows, fetched_RTT1_time, fetched_RTT2_time;
unsigned int i = 0;
unsigned int j = 0;
Point point;
point.x = 0;
point.y = 0;
point.z = 0;
while(1) {
// LATBbits.LATB2 = RTT1_received;
// LATBbits.LATB3 = RTT2_received;
IEC0bits.ADIE = 0;
fetched_RTT1_overflows = RTT1_overflows;
fetched_RTT2_overflows = RTT2_overflows;
fetched_RTT1_time = RTT1_time;
fetched_RTT2_time = RTT2_time;
IEC0bits.ADIE = 1;
++i;
// if (i == 65000) {
// ++j;
// i = 0;
// }
if (i == 5000) {
//LATBbits.LATB3 = !LATBbits.LATB3;
if (RTT1_received && RTT2_received) {
unsigned int RTT1 = fetched_RTT1_overflows*3277 + (fetched_RTT1_time/20) - 16000;
unsigned int RTT2 = fetched_RTT2_overflows*3277 + (fetched_RTT2_time/20) - 16000;
int error = track(RTT1, RTT2, &point);
if (error == 0) {
// send_debug("RTTs:");
// send_coord(RTT1, RTT2);
// send_debug("Point:");
int x = (int) point.x;
int y = (int) point.y;
send_coord(x, y);
// if (point.x < 0) {
//// send_debug("X NEGATIF");
//
// }
// send_coord(-1,-1);
} else {
// send_debug("BUG!");
// send_coord(error, 1);
}
}
i = 0;
}
}
}
int main() {
SYSTEMConfigPerformance(10000000); //Does something with assembly to set clock speed
enableInterrupts(); //Make interrupt work
initLEDs();
initTimer1();
initTimer2();
initTimer3();
initTimer4();
initSwitch();
porta = PORTA;
portd = PORTD;
initLCD();
delay(500);
//printCharLCD(0);
testLCD();
state = InitState;
nextState = InitState;
while (1) {
switch (state) {
case RUN:
#ifdef _DEBUG_
LATDbits.LATD0=0;
LATDbits.LATD1=0;
LATDbits.LATD2=1;
#endif
LATGbits.LATG14=LedOFF; //TRD1
LATGbits.LATG12=LedON; //TRD2
moveCursorLCD(0,0);
printStringLCD("Running...");
if(counterCN==1){ // If the counter changed...
printTimeLCD(counter);
counterCN = 0;
}
if(AllowChange == 0){
delay(5000);
delay(5000);
delay(5000);
delay(5000);
AllowChange = 1;
}
if((ReqChange==1) && (AllowChange==1)){
state=WAIT1;
ReqChange=0;
AllowChange=0;
// CNCONAbits.ON = 1;
}
break;
case STOP:
#ifdef _DEBUG_
LATDbits.LATD0=1;
LATDbits.LATD1=0;
LATDbits.LATD2=0;
#endif
LATGbits.LATG14=LedON;
LATGbits.LATG12=LedOFF;
moveCursorLCD(0,0);
printStringLCD("Stopped");
if(AllowChange == 0){
delay(5000);
delay(5000);
delay(5000);
delay(5000);
AllowChange = 1;
}
if(AllowReset == 0){
delay(5000);
delay(5000);
delay(5000);
delay(5000);
AllowReset = 1;
}
if((ReqReset==1) && (AllowReset==1)){
AllowReset = 0;
ReqReset = 0;
counter = 0;
printTimeLCD(counter);
}
if((ReqChange==1) && (AllowChange==1)){
state=WAIT2;
ReqChange=0;
AllowChange=0;
// CNCONAbits.ON = 1;
}
break;
case WAIT1:
#ifdef _DEBUG_
LATDbits.LATD0=0;
LATDbits.LATD1=1;
LATDbits.LATD2=1;
#endif
T1CONbits.ON = 0; // Turn off counter
if(AllowChange == 0){
delay(5000);
delay(5000);
delay(5000);
delay(5000);
AllowChange = 1;
}
if((ReqChange==1) && (AllowChange==1)){
state=STOP;
ReqChange=0;
AllowChange=0;
ReqReset = 0; // So we don't reset as soon as we stop...
AllowReset = 0; // See previous line
// CNCONAbits.ON = 1;
}
break;
case WAIT2:
#ifdef _DEBUG_
LATDbits.LATD0=1;
LATDbits.LATD1=1;
LATDbits.LATD2=0;
#endif
T1CONbits.ON = 1; // Turn on counter
if(AllowChange == 0){
delay(5000);// The sad part is this didn't even work.
delay(5000);
delay(5000);
delay(5000);
AllowChange = 1;
}
if((ReqChange==1) && (AllowChange==1)){ // Button Changed and De-bouncing period is done
state=RUN;
ReqChange=0;
AllowChange=0;
//CNCONAbits.ON = 1;
}
break;
case InitState:// Only happens once
state=STOP;
clearLCD();
counter = 0;
printTimeLCD(counter);
T1CONbits.ON = 0;
TMR1 = 0;
break;
default:// Should never happen. How did you get here?
state=InitState;
ReqChange = 0;
AllowChange=0;
break;
}
}
return 0;
}
void main(void)
{
PORTA=0x00;
DDRA=0x00;
PORTB=0x00;
DDRB=0x00;
PORTC=0x00;
DDRC=0x00;
PORTD=0x00;
DDRD=0x00;
PORTE=0x00;
DDRE=0x00;
PORTF=0x00;
DDRF=0x00;
PORTG=0x00;
DDRG=0x00;
initTimer0();
initTimer1();
initTimer2();
initTimer3();
enableTimers();
// External Interrupt(s) initialization
// INT0-INT7: Off
EICRA=0x00;
EICRB=0x00;
EIMSK=0x00;
// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
SFIOR=0x00;
// ====================== TRUE INITIALIZATION =============================
initLeds();
//initJumpers();
InitFans();
// configure Fans
FanSetPower(&fan1, 5);
FanSetPower(&fan2, 0);
FanSetPower(&fan3, 0);
FanSetPower(&fan4, 0); // max is 27
FanEnable(&fan2);
FanEnable(&fan3);
FanEnable(&fan4);
InitRailControl();
InitPsuControl();
InitPullDownControl();
//InitTemperature(); // no temperature-based control yet // depend on jumper J1
InitSignalControl();
InitADC();
InitBatChargeControl();
initPPC_State();
initUSART();
#asm("sei")
while(1)
{
// read jumpers
// read inputs
// update fans
// update outputs
// enter sleep
/*
// test fan speed debug
if (getTicksDelta(lastFanStepTickCount) > FAN_STEP_INTERVAL)
{
lastFanStepTickCount = getTickCount();
debug_fan_power_step++;
if (debug_fan_power_step > PWR_FAN_MAX)
debug_fan_power_step = PWR_FAN_MIN;
FanSetPower(&fan1, debug_fan_power_step);
};
*/
BatChargeUpdate();
//batChargeState.all_batteries_charged = 1; // !!!
SignalsIndicateCharged(batChargeState.all_batteries_charged);
#if 1
SignalReadUpdate();
switch (ppcState.mode)
{
case(PPC_MODE_WAITING):
{
if (InputsTransientHigh(SIGNAL_INDEX_SPINT_POWER))
{
setPPC_Mode(PPC_MODE_STARTING);
};
break;
}; // waiting mode state
case(PPC_MODE_STARTING):
{
FanEnable(&fan1);
switch(ppcState.stage)
{
case(0):
PsuSet(0,0,1,0);
PsuUpdateOutput();
PORTA = railState.port_value | psuState.port_value | pullDownState.portA_value;
delay_ms(200);
break;
case(1):
PsuSet(1,0,1,0);
PsuUpdateOutput();
PORTA = railState.port_value | psuState.port_value | pullDownState.portA_value;
delay_ms(200);
break;
case(2):
PsuSet(1,0,1,1);
PsuUpdateOutput();
PORTA = railState.port_value | psuState.port_value | pullDownState.portA_value;
delay_ms(200);
break;
case(3):
RailSet(1,0);
RailUpdateOutput();
PORTA = railState.port_value | psuState.port_value | pullDownState.portA_value;
delay_ms(200);
break;
case(4):
RailSet(1,1);
RailUpdateOutput();
PORTA = railState.port_value | psuState.port_value | pullDownState.portA_value;
delay_ms(1000);
break;
case(5):
PullDownSet(1,0,0);
PullDownUpdateOutput();
PORTA = railState.port_value | psuState.port_value | pullDownState.portA_value;
delay_ms(100);
break;
case(6):
PullDownSet(0,0,0);
PullDownUpdateOutput();
PORTA = railState.port_value | psuState.port_value | pullDownState.portA_value;
delay_ms(100);
break;
default:
setPPC_Mode(PPC_MODE_ACTIVE);
break;
};
ppcState.stage++;
break;
}; // starting mode state
case(PPC_MODE_ACTIVE):
{
FanEnable(&fan1);
if (signalState.current_signal_state[SIGNAL_INDEX_SPINT_POWER] == 0)
{
setPPC_Mode(PPC_MODE_PARKING);
};
//if (InputsTransientLow(SIGNAL_INDEX_SPINT_POWER))
break;
}; // acitve mode state
case(PPC_MODE_PARKING):
{
FanDisable(&fan1);
switch(ppcState.stage)
{
case(0): // turn off PSU power
PsuSet(0,0,0,0);
PsuUpdateOutput();
PORTA = railState.port_value | psuState.port_value | pullDownState.portA_value;
delay_ms(200);
break;
case(1): // park computer (pull-in)
PullDownSet(1,0,0);
PullDownUpdateOutput();
PORTA = railState.port_value | psuState.port_value | pullDownState.portA_value;
delay_ms(100);
break;
case(2): // park computer (pull-out)
PullDownSet(0,0,0);
PullDownUpdateOutput();
PORTA = railState.port_value | psuState.port_value | pullDownState.portA_value;
delay_ms(1000); // wait before clamping power rail
break;
case(3): // turn-off rails
RailSet(0,0);
RailUpdateOutput();
PORTA = railState.port_value | psuState.port_value | pullDownState.portA_value;
delay_ms(200);
break;
default:
setPPC_Mode(PPC_MODE_WAITING);
break;
};
ppcState.stage++;
break;
}; // Parking mode state
}; // MODE Switch
// This function locks for 0.2 second minimum
// This must be read in the end of control loop
/*
TemperatureReadUpdate();
if (temperatureState.temperature1 != 0)
{
if (temperatureState.temperature1 <= 30)
{
FanDisable(&fan1);
}
else
{
FanEnable(&fan1);
FanSetPower(&fan1,(unsigned char)(PWR_FAN_MIN + ((signed int)(PWR_FAN_MAX - PWR_FAN_MIN))*temperatureState.temperature1/60));
};
}
else
{
FanDisable(&fan1);
};
*/
RailUpdateOutput();
PsuUpdateOutput();
PullDownUpdateOutput();
networkUpdate();
PORTA = railState.port_value | psuState.port_value | pullDownState.portA_value;
#endif
/*
if (ppcState.mode == PPC_MODE_WAITING)
{
#asm("sleep")
}
*/
}
} // main
int main() {
//Create current LED placeholders
int currLED = 1;
//This function is necessary to use interrupts.
//enableInterrupts();
//Initialize SW1
initSwitch1();
//Initialize all LEDs
initLEDs();
//Initialize Timer 2
initTimer2();
//Initialize Timer 1
initTimer1();
//Turn on LED 1 before starting the state machine
turnOnLED(1);
while (1) {
//See state descriptions above
switch (state) {
case wait:
if (SW1 == PRESSED) {
startTimer1();
state = debouncePress;
}
break;
case debouncePress:
delayMs(100);
state = wait2;
break;
case wait2:
if (IFS0bits.T1IF == FLAGUP){
stopTimer1();
state = debounceRelease2;
}
if (SW1 == RELEASED) {
stopTimer1();
state = debounceRelease;
}
break;
case debounceRelease:
delayMs(100);
if (currLED == 1) {
state = led2;
} else if (currLED == 2) {
state = led3;
} else if (currLED == 3) {
state = led1;
}
break;
case debounceRelease2:
if (SW1 == RELEASED) {
delayMs(100);
if (currLED == 1) {
state = led3;
} else if (currLED == 2) {
state = led1;
} else if (currLED == 3) {
state = led2;
}
}
break;
case led1:
turnOnLED(1);
turnOffLED(currLED);
currLED = 1;
state = wait;
break;
case led2:
turnOnLED(2);
turnOffLED(currLED);
currLED = 2;
state = wait;
break;
case led3:
turnOnLED(3);
turnOffLED(currLED);
currLED = 3;
state = wait;
break;
}
}
return 0;
}
int main() {
//This function is necessary to use interrupts.
enableInterrupts();
//TODO: Write each initialization function
initSwitch1();
initLEDs();
//initTimer2();
initTimer1();
int led;
int i;
while(1) {
switch(state)
{
//init case
case init:
led = 0;
turnOnLED(0);//turn the top LED on
state = waitPush;//move on to the next state
break;
//waitPush state
case waitPush:
if(PORTDbits.RD6 == 0)//check if the switch is pushed
{
//for(i=0;i<10000;i++);
TMR1CLR = 0xFFFF;; // Clear the timer interrupt flag
state = waitRelease;
T1CONbits.TON = 1;//enable timer
IFS0bits.T1IF = 0;//put the flag down
}
else state = waitPush;//stay in waitPush if the switch is not pushed
break;
//waitRelease state
case waitRelease:
if(PORTDbits.RD6 == 1)//check if the switch is pushed
{
if(IFS0bits.T1IF == 1)//check if the flag is on
{
state = prevLED;//move to the previous state if the flag is on when hold more than 2 seconds
T1CONbits.TON = 0;//clear the timer when not in use
}
else {
state = nextLED;//move to the next state
T1CONbits.TON = 0;//clear the timer when not in use
}
}
else {
state = waitRelease;//move to waitRelease
}
break;
//go back to previous LED state
case prevLED:
if(led == 0)led=2;
else if(led == 1)led=0;
else if(led == 2)led=1;
turnOnLED(led);
IFS0bits.T1IF = 0;
state = waitPush;
T1CONbits.TON = 0;
break;
//go to next LED state
case nextLED:
if(led==0) led=1;
else if(led == 1)led=2;
else if (led == 2) led=0;
turnOnLED(led);
IFS0bits.T1IF = 0;
state = waitPush;
T1CONbits.TON = 0;
break;
default:
break;
}
}
return 0;
}
void initSystem(void){
initPorts();
initOLED();
initTimer1();
sei();
}
int main() {
//This function is necessary to use interrupts.
enableInterrupts();
state = led1;
//TODO: Write each initialization function
initSwitch1();
initLEDs();
initTimer2();
initTimer1();
//This 2 lines stop the timer 1 and reset it, so at the start of the FSM it's equal to 0
T1CONbits.TON = 0; //Turn the timer 1 OFF
IFS0bits.T1IF = 0; //Put the flag down
while (1) {
//TODO: Implement a state machine to create the desired functionality
switch (state) {
case led1: //Turn on Led1, and changes state when the button is pressed
turnOnLED(1);
if(SW1 == PRESSED) {
state = debouncePress;
}
break;
case led2: //Turn on Led2, and changes state when the button is pressed
turnOnLED(2);
if (SW1 == PRESSED) {
state = debouncePress;
}
break;
case led3: //Turn on Led3, and changes state when the button is pressed
turnOnLED(3);
if (SW1 == PRESSED) {
state = debouncePress;
}
break;
case timer: //Wait until the button is released and based on the timer
// it either goes to debounceRelease or debounceRelease2;
if ((SW1 == RELEASED) && (IFS0bits.T1IF == 0)) {
state = debounceRelease;
IFS0bits.T1IF = 0; //Put the flag down
T1CONbits.TON = 0; //Turn the timer 1 OFF
}
if ((SW1 == RELEASED) && (IFS0bits.T1IF == 1)) {
state = debounceRelease2;
IFS0bits.T1IF = 0; //Put the flag down
T1CONbits.TON = 0; //Turn the timer 1 OFF
}
break;
case debouncePress: //Debounces for 20ms , reset and start timer 1
delayMs(20);
state = timer;
TMR1 = 0; //Clear the timer 1
T1CONbits.TON = 1; //Turn the timer 1 ON
break;
case debounceRelease: //Debounces for 20ms, and depending on the led that is on
delayMs(20); //it changes state to the next one
if (LATDbits.LATD0 == ON) {
state = led2;
}
if (LATDbits.LATD1 == ON) {
state = led3;
}
if (LATDbits.LATD2 == ON) {
state = led1;
}
break;
case debounceRelease2: //Debounces for 20ms, and depending on the led that is on
delayMs(20); //it changes state to the next one (going backwards)
if (LATDbits.LATD0 == ON) {
state = led3;
}
if (LATDbits.LATD1 == ON) {
state = led1;
}
if (LATDbits.LATD2 == ON) {
state = led2;
}
break;
}
}
return 0;
}
Timer1::Timer1(void) {
initTimer1();
}
/**@brief Chiamabile più volte per inizializzare moduli A e B */
void initCompare1 (uint16_t comp_val, _t_compare_sel comp, uint16_t prescaler, _t_edge edge, _t_timer_clock clock, uint8_t timer_int)
{
initTimer1(prescaler, edge, COMPARE_MATCH, clock, timer_int);
switch (comp)
{
case COMP_A_TOGGLE:
sbi(TCCR1A, COM1A0);
cbi(TCCR1A, COM1A1);
sbi(DDRB, DDB1);
write16bit(comp_val, &OCR1AH, &OCR1AL);
OCR1A = comp_val;
break;
case COMP_A_CLEAR:
cbi(TCCR1A, COM1A0);
sbi(TCCR1A, COM1A1);
sbi(DDRB, DDB1);
write16bit(comp_val, &OCR1AH, &OCR1AL);
break;
case COMP_A_SET:
sbi(TCCR1A, COM1A0);
sbi(TCCR1A, COM1A1);
sbi(DDRB, DDB1);
write16bit(comp_val, &OCR1AH, &OCR1AL);
break;
case COMP_B_TOGGLE:
sbi(TCCR1A, COM1B0);
cbi(TCCR1A, COM1B1);
sbi(DDRB, DDB2);
write16bit(comp_val, &OCR1BH, &OCR1BL);
break;
case COMP_B_CLEAR:
cbi(TCCR1A, COM1B0);
sbi(TCCR1A, COM1B1);
sbi(DDRB, DDB2);
write16bit(comp_val, &OCR1BH, &OCR1BL);
break;
case COMP_B_SET:
sbi(TCCR1A, COM1B0);
sbi(TCCR1A, COM1B1);
sbi(DDRB, DDB2);
write16bit(comp_val, &OCR1BH, &OCR1BL);
break;
case COMP_A_DISCONNECT:
cbi(TCCR1A, COM1A0);
cbi(TCCR1A, COM1A1);
write16bit(comp_val, &OCR1AH, &OCR1AL);
break;
case COMP_B_DISCONNECT:
cbi(TCCR1A, COM1B0);
cbi(TCCR1A, COM1B1);
write16bit(comp_val, &OCR1BH, &OCR1BL);
break;
default:
/* lascia OCnx sconnesso come lo è da initTimer0*/
cbi(TCCR1A, COM1B0);
cbi(TCCR1A, COM1B1);
cbi(TCCR1A, COM1A0);
cbi(TCCR1A, COM1A1);
break;
}
switch (timer_int)
{
case INT_ON:
/* Non devo chiamare questa funzione se uso il normale */
if ((comp == COMP_A_CLEAR) || (comp == COMP_A_SET) ||(comp == COMP_A_TOGGLE)||(comp == COMP_A_DISCONNECT))
{
sbi(TIMSK1, OCIE1A);
}
if ((comp == COMP_B_CLEAR) || (comp == COMP_B_SET) ||(comp == COMP_B_TOGGLE)||(comp == COMP_B_DISCONNECT))
{
sbi(TIMSK1, OCIE1B);
}
break;
case INT_OFF:
if ((comp == COMP_A_CLEAR) || (comp == COMP_A_SET) ||(comp == COMP_A_TOGGLE)||(comp == COMP_A_DISCONNECT))
{
cbi(TIMSK1, OCIE1A);
}
if ((comp == COMP_B_CLEAR) || (comp == COMP_B_SET) ||(comp == COMP_B_TOGGLE)||(comp == COMP_B_DISCONNECT))
{
cbi(TIMSK1, OCIE1B);
}
break;
default:
cbi(TIMSK1, OCIE1A);
cbi(TIMSK1, OCIE1B);
break;
}
}
