Ejemplo n.º 1
0
/*
 * Don't forget to call this function from the right interrupt vector.
 */
void InterruptServo() {
    if (INTCONbits.TMR0IE && INTCONbits.TMR0IF) {
        if (CurrentServo > 0) {
            // Set previous pin (CurrentServo - 1) to 0.
            PORTB &= ~(1 << (CurrentServo - 1));
        }

        if (CurrentServo < CountServo) {
            // Set current (CurrentServo) pin to 1.
            PORTB |= 1 << CurrentServo;

            WriteTimer0(65534 /* Max int */
                    /* Maximum width of 2.4ms. */
                    - AngleServo[CurrentServo] * 2 * ((2400 - 544) / 180)
                    /* Minimum width of 544µs. */
                    - 544 * 2 /* 2 = 8MHz / 4 (proc. freq) / 1µs  */
                    );
            // Between 0.9ms and 2.1ms.
        } else {
            WriteTimer0(65535 - 20000 * 2); // Minimum of 20ms between pulses.
        }

        CurrentServo++;
        if (CurrentServo > CountServo)
            CurrentServo = 0;
        // When CurrentServo == CountServo, the next interrupt sets every pin to 0.

        INTCONbits.TMR0IF = 0;
    }
}
Ejemplo n.º 2
0
void timer0_int_handler() {
    unsigned int val;
    int length, msgtype;
    LATBbits.LATB6 = !LATBbits.LATB6;
    // toggle an LED
    // LATBbits.LATB0 = !LATBbits.LATB0;
    // reset the timer
#if defined (MOTOR_PIC)
    WriteTimer0(TIMER0_START);
    ticks_right++;
    if ( executingEncode && ticks_right_C > 0)
        ticks_right_C--;
    
    if ( executingEncodeLong && ticks_right_C_Long > 0)
        ticks_right_C_Long--;

    if ( ticks_left_C  <= 1 && ticks_right_C <= 1 && executingEncode ) {
        if ( motor_state == RoverMsgMotorForward)
            RoverForward();
        else if ( motor_state == RoverMsgMotorLeft2 || motor_state == RoverMsgMotorRight2 ) {
            motor_encode_lthread(RoverMsgMotorForwardCMDelim+10);
        }
        else
            RoverStop();
         executingEncode = 0;
    }
    else if ( ticks_left_C_Long  <= 1 && ticks_right_C_Long <= 1 && executingEncodeLong ) {
        if ( motor_state == RoverMsgMotorLeft2 ) {
            motor_encode_lthread(RoverMsgMotorRight2);
        }
        else if ( motor_state == RoverMsgMotorRight2 )
        {
            motor_encode_lthread(RoverMsgMotorLeft2);
        }
        else {
            RoverStop();
        }
        
         motor_state = RoverMsgMotorStop;
         executingEncodeLong = 0;
    }
    
#else
    WriteTimer0(0);
#endif

    // try to receive a message and, if we get one, echo it back
    //length = FromMainHigh_recvmsg(sizeof(val), (unsigned char *)&msgtype, (void *) &val);
    //if (length == sizeof (val)) {
     //   ToMainHigh_sendmsg(sizeof (val), MSGT_TIMER0, (void *) &val);
    //}
}
Ejemplo n.º 3
0
void SendIRImpl(void)
{
    WORD t,wait;
    BYTE hilo;
    WORD pos;
    WORD byteOrWord; // 0:未設定

    WriteTimer0(0);
    INTCONbits.TMR0IF = 0;

    hilo = 1;
    pos = 0;
    byteOrWord = 0;
    while (1) {
        wait = ReadBuffer(&pos,&byteOrWord);
        if (wait==BUFF_EOF)
            break;
        if (wait==MAX_WAIT_CYCLE)
            break;
        do {
            LED1_PORT = hilo;
            IRLED_PORT = hilo;
            DelayIRFreqHi();
            t = ReadTimer0();
            if (t >= wait)
                break;
            LED1_PORT = 0;
            IRLED_PORT = 0;
            DelayIRFreqLo();
            t = ReadTimer0();
        } while(t < wait);

        WriteTimer0(0);
        hilo = !hilo;
        LED1_PORT = hilo;
        IRLED_PORT = hilo;
    }

    // wait 10msec [1cycle==0.083333333us]
    Delay10KTCYx(120);
    LED1_PORT = 0;
    IRLED_PORT = 0;

    PutsString("OK\r\n");

    LED1_PORT = 0;
    IRLED_PORT = 0;
}
Ejemplo n.º 4
0
/******************************************************************************
 * Function:        void UserInit(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        This routine should take care of all of the demo code
 *                  initialization that is required.
 *
 * Note:            
 *
 *****************************************************************************/
void UserInit(void)
{
	unsigned char i;
    
    initLEDs();

    // 	 Initialize the arrays
	for (i=0; i<sizeof(USB_Out_Buffer); i++)
    {
		USB_Out_Buffer[i] = 0;
    }
    
    ReadMessageFromEEPROM();

    testLEDs();
    
	NextUSBOut = 0;
	LastRS232Out = 0;
	lastTransmission = 0;
	nextProcessState = P_VERSION;
	RS232cp = 0;
	// POV
	space = 0;
	POV_curPos = 0;
	POV_curLetter = 0;
	
	OpenTimer0(TIMER_INT_ON & T0_8BIT & T0_SOURCE_INT & T0_PS_1_256);
    WriteTimer0(POV_TIMER);

}//end UserInit
Ejemplo n.º 5
0
void timer0_int_handler(unsigned char *adcbuffer) {
    WriteTimer0(0);
//    unsigned int val;
//    int length, msgtype;

    // toggle an LED
#ifdef __USE18F2680
    LATBbits.LATB0 = !LATBbits.LATB0;
#endif
    // reset the timer

    // try to receive a message and, if we get one, echo it back
//    length = FromMainHigh_recvmsg(sizeof(val), (unsigned char *)&msgtype, (void *) &val);
//    if (length == sizeof (val)) {
//        ToMainHigh_sendmsg(sizeof (val), MSGT_TIMER0, (void *) &val);
//    }


    ConvertADC();
    //while( BusyADC()) {
        //LATBbits.LATB1 = 1;
    //}
    //LATBbits.LATB1 = 0;


}
Ejemplo n.º 6
0
void TMR0_ISR(void)
{
  	/*
   	* Clears the TMR0 interrupt flag to stop the program from processing the
   	* same interrupt multiple times.
   	*/
  	INTCONbits.TMR0IF = 0;

	++heartBeatCount;
	++appUpdateCount;
	++keypadUpdate_count;
	++comUpdateCount;

	--timeStampUpdateCount;

	if( timeStampUpdateCount <= 0 )
	{
		AppTimestamp++;
		timeStampUpdateCount = TIMESTAMP_DURATION;
	}

	if(tmr[0].func != 0 )
		(*(tmr[0].func))();


	// Reload value for 1ms overflow
	WriteTimer0(tmr[0].reload);
}
Ejemplo n.º 7
0
void delay(unsigned int c)
{
	INTCONbits.TMR0IF = 0;
	WriteTimer0(c);
	while (INTCONbits.TMR0IF == 0)
		;
}
Ejemplo n.º 8
0
void timer0_isr(void)
{
    INTCON1bits.TMR0IF = 0;
    WriteTimer0(6);

    ms_ticks++;
}
Ejemplo n.º 9
0
void main(void)
{
	//timer vars
	int result;
	float final_result;

	Delay100TCYx(10); //let the device startup
	usart_init();
	i2c_init();
	printf("Starting\r\n");


	// let sonar initialize, delay 250 ms
	Delay1KTCYx(625);
	TRISBbits.TRISB3 = 1;	// data pin input
	
	while(1)
	{
		while(PORTBbits.RB3 == 0);
		// configure timer0
		OpenTimer0(TIMER_INT_OFF & T0_16BIT & T0_SOURCE_INT & T0_PS_1_1);
 		WriteTimer0( 0 );         // restart timer
		while(PORTBbits.RB3 == 1);
		//Delay1TCY();
		result = ReadTimer0();    // read timer
		printf("Timer is %u \r\n", result);
		final_result = (float)result / (float)(2.5*147);
		printf("X / (4*147) = %i \r\n", (int)final_result);
		
	}
	
}
Ejemplo n.º 10
0
void main(void) {
    TRISBbits.RB0 = 1; // KEY1 is input
    TRISBbits.RB1 = 1; // KEY2 is input
    
    SSEG_Init(); // Initialize SSEGs
    // Configure Timer0
    OpenTimer0(TIMER_INT_ON &  // Enable TIMER Interrupt
               T0_16BIT &      // Timer0 is configured as an 16-bit timer/counter
               T0_SOURCE_INT & // Internal instruction cycle clock (CLKO) acts as source of clock
               T0_PS_1_16);   // 1:16 Prescaler value
               
    WriteTimer0(TMR0_value); // Write Timer0 value to Timer0 to count

    INTCONbits.INT0E = 1; // Enable Interrupt 0 (RB0 as interrupt)
    INTCON2bits.INTEDG0 = 1; // Interrupt 0 occurs at rising edge
    INTCONbits.INT0F = 0; // Clear Interrupt 0 flag

    INTCON3bits.INT1E = 1; // Enable Interrupt 1 (RB1 as interrupt)
    INTCON2bits.INTEDG1 = 1; // Interrupt 1 occurs at rising edge
    INTCON3bits.INT1F = 0; // Clear Interrupt 0 flag

    INTCONbits.GIE = 1; // Enables all unmasked interrupts
    
    while(1) {
        Delayms(250);
        if(direction_flag == 0) {
            counter++; // Increase counter by one
            if(counter > 99) counter = 0;
        }
        else if (direction_flag == 1) {
            counter--;
            if(counter < 0) counter = 99;
        }
    }
}
Ejemplo n.º 11
0
void interrupt ISR(void) {
    
    if(INTCONbits.TMR0IF==1) { // if Timer0 Interrupt is occurred
        INTCONbits.TMR0IF = 0; // Clear the interrupt flag
        WriteTimer0(TMR0_value); // Update TMR0 value
        if(timer_flag == 0) { // if it is first 10ms
            SSEG_Print(1,counter%10); // Shows ones of counter at first sseg
            timer_flag = 1;
        }
        else { // if it is second 10ms
            SSEG_Print(2,counter/10); // Shows tens of counter at second sseg
            timer_flag = 0;
        }
    }    
    
    if(INTCONbits.INT0F == 1) { // if External Interrupt 0 is occurred (KEY1)
        INTCONbits.INT0F = 0;  // Clear Interrupt 0 Flag
        direction_flag = 1;
    }
    
    if(INTCON3bits.INT1F == 1) { // if External Interrupt 1 is occurred (KEY2)
        INTCON3bits.INT1F = 0;  // Clear Interrupt 1 Flag
        direction_flag = 0;
    }
}
Ejemplo n.º 12
0
void timer0_int_handler() {
    WriteTimer0(0);
//    unsigned int val;
//    int length, msgtype;

    // toggle an LED
#ifdef __USE18F2680
    LATBbits.LATB0 = !LATBbits.LATB0;
#endif
    // reset the timer
    
    // try to receive a message and, if we get one, echo it back
//    length = FromMainHigh_recvmsg(sizeof(val), (unsigned char *)&msgtype, (void *) &val);
//    if (length == sizeof (val)) {
//        ToMainHigh_sendmsg(sizeof (val), MSGT_TIMER0, (void *) &val);
//    }

    UART_timeout++;

    //unsigned char motorcomm[2] = {0x9F, 0x1F};
//    unsigned char motorcomm[2] = {0x00, 0x00};
//    uart_trans(2, motorcomm);
    //ConvertADC();
    //while( BusyADC()) {
        //LATBbits.LATB1 = 1;
    //}
    //LATBbits.LATB1 = 0;

    
}
Ejemplo n.º 13
0
void high_isr(void)
#else
#error "Invalid compiler selection for implemented ISR routines"
#endif

{
      
      /* Determine which flag generated the interrupt */
    if(INTCONbits.TMR0IF == 1) {    //Timer0
        Servo_Switch_Flag = 0;
        LED3 = 1;
        //PORTDbits.RD0 = 1;
        
        INTCONbits.TMR0IF = 0;
        WriteTimer0(SERVO_PERIOD);
        WriteTimer1(0xFFFF - Servo_Times[0]);
        Servo_Id = 0;
        //Todo: fix defines
        LATC = 0xFF;
        
        
        
    } else if(PIR1bits.TMR1IF == 1) {   //Timer1
        
        
        //Servo_Id = (Servo_Id++) % MAX_SERVOS;
        WriteTimer1(0xFFFF - Servo_Times[++Servo_Id]);
        
        //Todo: Properly define this in headers
        //Off by one because of critical interrupt stuff above
        switch(Servo_Id) {  
            case 1:
                LATC = LATC & ~(1 << SERVO_PIN_1);
                LED3 = 0;
                break;
            case 2:
                LATC = LATC & ~(1 << SERVO_PIN_2);
                break;
            case 3:
                LATC = LATC & ~(1 << SERVO_PIN_3);
                break;
            case 4:
                LATC = LATC & ~(1 << SERVO_PIN_4);
                break;
            case 5:
                LATC = LATC & ~(1 << SERVO_PIN_5);
                Servo_Switch_Flag = 1;
                break;
                
        }
        
        
        PIR1bits.TMR1IF = 0;
    } else {
          /* Unhandled interrupts */
     }


}
Ejemplo n.º 14
0
///////////////////////////////////////////////////////////////////////
// Hardware and variable init.
///////////////////////////////////////////////////////////////////////
void init(void) 
{
	
	// Oscillator selection
	OSCCONbits.IRCF0 = 1;
	OSCCONbits.IRCF1 = 1;
	OSCCONbits.IRCF2 = 1;

	// All digital pins on porta
	ADCON1 = 0x0F;
	
	// Set initial port state
	PORTA = 1;
	PORTB = 0;
	PORTC = 0x04;

	TRISA = PortAConfig;    
	TRISB = PortBConfig;
	TRISC = PortCConfig;
	
	// PortB pullups enable
	INTCON2bits.NOT_RBPU = 0;
	
	// Enable the main 1-sec timer that will interrupt every second
	OpenTimer0(TIMER_INT_ON & 
			T0_16BIT & 
			T0_SOURCE_INT & 
			T0_PS_1_32);	

	WriteTimer0(TMR0_VAL);		// Load initial timer value

	// Serial interface init (9600 @ 8 MHz, BRGH = 1 => 51)
	OpenUSART(USART_ASYNCH_MODE & 
			USART_TX_INT_OFF &
			USART_RX_INT_ON &
			USART_EIGHT_BIT & 
			USART_CONT_RX & 
			USART_BRGH_HIGH, 
			51);
	
	uart_state = IDLE;
	rx_pointer = 0;

	// Enable interrupts GIE and PEIE
	INTCON |= 0xC0;

	// Clear the clock
	clock_clear();
	
	// Clear possible existing interrupt flags
	INTCONbits.INT0IF = 0;
	INTCONbits.TMR0IF = 0;
	PIR1bits.TMR1IF = 0;
	
    output = 0;

	switchpoint_init();

}
Ejemplo n.º 15
0
// Timer0 interrupt handler
void timer0_int_handler() {

    // reset the timer
    WriteTimer0(0);

    // Send low priority message
    ToMainLow_sendmsg(0, MSGT_TIMER0, 0);
}
Ejemplo n.º 16
0
void interrupt ISR(void) {

    if(INTCONbits.TMR0IF==1) { // if Timer0 Interrupt is occurred
        INTCONbits.TMR0IF = 0; // Clear the interrupt flag
        WriteTimer0(TMR0_value); // Update TMR0 value
        flag = 1; 
    }
}
Ejemplo n.º 17
0
void ReadIR(void)
{
    WORD t;
    BYTE hilo;
    BYTE exit;
    WORD byteOrWord; // 0:未設定
    WORD pos;

    if (enableReadIR==0)
        return;

    if (IR_PORT == 1)
        return;

    // なにか信号があった

    WriteTimer0(0);
    INTCONbits.TMR0IF = 0;
    hilo = 0;

    pos = 0;
    byteOrWord = 0;
    exit = 0;
    while (exit==0) {
        LED1_PORT = !hilo;
        do {
            t = ReadTimer0();
            if (INTCONbits.TMR0IF || (t > MAX_WAIT_CYCLE)) {
                t = MAX_WAIT_CYCLE;
                INTCONbits.TMR0IF = 0;
                exit=1;
                break;
            }
        } while (IR_PORT == hilo);
        WriteTimer0(0);
        exit += WriteBuffer(t,&pos,&byteOrWord);
        hilo = !hilo;
    }
    LED1_PORT = 0;
    WriteEOF(pos);

    if (!WaitToReadySerial())
        return;
    PrintIRBuffer("received,");
}
Ejemplo n.º 18
0
void low_isr(void)
{
 
    if(INTCONbits.TMR0IE && INTCONbits.TMR0IF)
    {
        WriteTimer0(57724);
        led=led^1;
        INTCONbits.TMR0IF = 0;
    }
}
Ejemplo n.º 19
0
void pausa (unsigned int segundos)
{
    if (segundos <= 0) return;

    OpenTimer0( TIMER_INT_OFF &
                T0_16BIT &
                T0_PS_1_32 &
                T0_SOURCE_INT &
                T0_EDGE_FALL
              );
    //Enable TIMER Interrupt (Int_On)

    /* Calculo do Timer0
     *
     *  (1 seg * 8000000) / (4 * 32)   ... 32 = 1/32 prescaler
     *  8.000.000 / 128 = 62500
     *
     *  Timer0 = 65536 - 62500 = 3035 ou 0xBDB
     */

    WriteTimer0( 0xBDC );

    LED_AMAR=1;
    LED_VERM=0;

    T0CONbits.TMR0ON = 1;     // Ligue o Timer 0
    //T0CONbits.PSA = 0;      // Use valores atraves do Pre-Scaler
    //T0CONbits.T0CS=0;       // A fonte clock eh Interna (CLKO/FOSC) T0_SOURCE_INT

    // Sem Interrupcoes
    INTCONbits.GIE      = 0;    // Interrupcoes Globais desligadas
    INTCONbits.PEIE     = 0;    // Interrupcoes dos Perifericos desligadas
    INTCONbits.TMR0IE   = 0;    // Interrupcoes do Timer0 desligadas

    INTCONbits.TMR0IF   = 0;    // Zera o contador do Timer0

    while (segundos > 0)
    {
        while (!TMR0IF) ;       // enquando o Timer0 nao tiver overflow, espere

        LED_AMAR=~LED_AMAR;     // Led Amarelo pisca a cada segundo
        //segundos--;
        //WriteTimer0( 0xBDC );
        INTCONbits.TMR0IF=0;    // Zera o contador do Timer0
        segundos--;
    }

    CloseTimer0();              // Feche o Timer0
    //TMR0ON=0;

    LED_AMAR=0;
    LED_VERM=0;
    LED_VERD=0;
}
Ejemplo n.º 20
0
int main(void) {
    
    //--------------
    // Initialization 
    char LCDinit[] = {0x33,0x32,0x28,0x01,0x0c,0x06,0x00}; //Array holding initialization string for LCD
    char Msg1[] = {0x84,'C','U','N','T','\0'};
    char Msg2[] = {0xC5,'R','P','S','\0'};
    char Msg3[10];          // Msg for displaying RPS to LCD (size 10 in case dealing with large numbers)
    InitApp();              // Initialize Ports
    DisplayLCD(LCDinit,1);  // Initialize LCD

    //--------------
    // Message on LCD
    DisplayLCD(Msg1,0);     // Display message on LCD
    DisplayLCD(Msg2,0);     // Display message 2

    //--------------
    // Initialize encoder variables
    CHA = PORTBbits.RB5;    // Initialize channel A
    CHB = PORTBbits.RB4;    // Initialize channel B
    OLD_ROT = 0;            // Initialize state of rotation
    CCWTurn = 0;            // Initialize CCW count
    CWTurn = 0;             // Initialize CW count
    RPS = 0.0;              // Initialize RPS value
    CHAcount = 0;           // Channel A counter

    //--------------
    // Setup PWM cycle to motor
    PR2 = 0x9B;             // Open pwm1 at period = 1 ms
    CCP1CONbits.DC1B1 = 0;  // Set duty cycle of pwm1
    CCP1CONbits.DC1B0 = 0;  // ...
    CCPR1L = 0b00000100;    // ...

    //-------------
    // Set timer and interrupts
    TMR0count = 0;          // Set counter for TMR0
    WriteTimer0(EncoderCount);// Load Timer0
    InitInterrupts();       // Initialize timer interrupts for Port B encoder
    

    //--------------
    // Loop phase: Display RPS on LCD
    while(1)
    {
        WaitHalfSec();
        WriteLCD(0xC0,5,RPS,Msg3);      // Display RPS on LCD
    }


    //--------------
    // Exit main
    CloseTimer0();
    return (EXIT_SUCCESS);
}
Ejemplo n.º 21
0
/*
*------------------------------------------------------------------------------
* void TMR0_init(void)

* Summary	: Initialize timer0 for schedular base
*
* Input		: None
*
* Output	: None
*
*------------------------------------------------------------------------------
*/
void TMR0_init(UINT16 reload , void (*func)(void))
{
	// Enable the TMR0 interrupt,16bit counter
	// with internal clock,No prescalar.
   	OpenTimer0(TIMER_INT_ON & T0_SOURCE_INT & T0_16BIT & T0_PS_1_1);
	// Reload value for 5ms overflow
	WriteTimer0(reload);
	
	tmr[0].reload = reload;
	tmr[0].func = func;
}
void interrupt low_isr(void){
    /* Check if overflow interrupt for Timer 0 occures */
    if(INTCONbits.TMR0IF == 1){
        /* Cyclic change state from ON to OFF and so on */
        LED_2 = ~LED_2;
        /* Clear timer interrupt flage - it's necessary */
        INTCONbits.TMR0IF = 0;
        /* Upload default value to timer */
        WriteTimer0(TIMER0_DEF_VALUE);
    }
}
Ejemplo n.º 23
0
void startTimer0()
{
	// Setup the timer with a 1:1 prescaler with 16 bits resolution
	// Therefore the timer0 freq is 500 kHz / 4 / 4 = 31.250 kHz
	OpenTimer0( TIMER_INT_ON & T0_16BIT & T0_SOURCE_INT & T0_PS_1_4 );
	// Should take a little over 2 seconds to overflow the counter from TMR0 = 0
	// If you write in a different starting value for TMR0 it'll overflow sooner

	WriteTimer0(0);
	INTCONbits.TMR0IF = 0;
}	
Ejemplo n.º 24
0
void interrupt ISR(void) {

    if(INTCONbits.TMR0IF==1) { // if Timer0 Interrupt is occurred
        INTCONbits.TMR0IF = 0; // Clear the interrupt flag
        WriteTimer0(TMR0_value); // Update TMR0 value
        if(PORTBbits.RB0 == 0) { // if KEY1 is pressed
            while(PORTBbits.RB0 == 0); // Trap until KEY1 is released
            flag = 1; // Change flag to toogle LED1
        }
    }
}
void
InterruptHandlerHigh ()
{ //Every 0.026 secs
   if (INTCONbits.TMR0IF)
   { //check for TMR0 overflow
      INTCONbits.TMR0IF = 0; //clear interrupt flag
      WriteTimer0(0);
      //Code used by the interrupt goes here
   }
	printf("In interrupt handler \r\n");
}
Ejemplo n.º 26
0
void timer0_int_handler() {
    // Encoder count for motor 0.
    timer0Counter++;
    // Reset the timer
    WriteTimer0(0xCF);

    DEBUG_ON(TMR0_DBG);
    DEBUG_OFF(TMR0_DBG);

    if (ticks_flag) {
        // Reverse counter to prevent it from going a set distance.
        ticks0Counter++;
        // Going thru right hand turn
        if (ticks0Counter >= maxTickZero && postRight == 1) {
            postRight = 2;
            WriteUSART(0x00);
            // Turn right 90
            motorBuffer[0] = 0x01;
            motorBuffer[1] = 0x03;
            motorBuffer[2] = 0x04;
            motorBuffer[3] = 0x01;
            motorBuffer[4] = 0x0C;
            motorBuffer[5] = 0x09;

            ToMainHigh_sendmsg(MOTORLEN, MSGT_I2C_DATA, (void *) motorBuffer);
        } else if (ticks0Counter >= maxTickZero && postRight == 2) {
            // Move forward after right turn
            postRight = 0;

            motorBuffer[0] = 0x01;
            motorBuffer[1] = 0x03;
            motorBuffer[2] = 0x01;
            motorBuffer[3] = 0x01;
            motorBuffer[4] = 0x00;
            motorBuffer[5] = 0x00;

            ToMainHigh_sendmsg(MOTORLEN, MSGT_I2C_DATA, (void *) motorBuffer);
        } else if (ticks0Counter >= maxTickZero && postAlignFlag) {
            postAlignFlag = 0;
            motorBuffer[0] = 0x01;
            motorBuffer[1] = 0x03;
            motorBuffer[2] = 0x01;
            motorBuffer[3] = 0x01;
            motorBuffer[4] = 0x00;
            motorBuffer[5] = 0x00;

            ToMainHigh_sendmsg(MOTORLEN, MSGT_I2C_DATA, (void *) motorBuffer);
        } else if (ticks0Counter >= maxTickZero) {
            //Stops wheels after set number of ticks
            WriteUSART(0x00);
        }
    }
}
Ejemplo n.º 27
0
void InterruptHandlerLow (void)
{
    unsigned int t0;
    if(INTCONbits.TMR0IF)                   //check for TMR0 overflow interrupt flag
    {
        INTCONbits.TMR0IF = 0;              //clear interrupt flag
        t0=ReadTimer0();
        WriteTimer0(t0 +18661);             //Nastavi na 1.0 Sek
        UTicTac++;                          // Povecaj idle števec
        LATAbits.LATA3 = !LATAbits.LATA3;
    }
}
Ejemplo n.º 28
0
void timer0_int_handler() {
    unsigned int val;
    int length, msgtype;

    // toggle an LED
    LATBbits.LATB0 = !LATBbits.LATB0;
    // reset the timer
    WriteTimer0(0);
    // try to receive a message and, if we get one, echo it back
    length = FromMainHigh_recvmsg(sizeof(val), (unsigned char *)&msgtype, (void *) &val);
    if (length == sizeof (val)) {
        ToMainHigh_sendmsg(sizeof (val), MSGT_TIMER0, (void *) &val);
    }
}
Ejemplo n.º 29
0
void timer0_handler (void)
{
	INTCONbits.TMR0IF = 0;
	WriteTimer0( TIMER_START_SEC );
	if(LED==1) LED	= 0; else LED=1;
	transmit = 1;
/*	if(ledr==1){
 		LED	= 0;
		ledr=0; 
	} else {
		 LED=1;
		ledr=1;
	}*/
}
Ejemplo n.º 30
0
void tratar_high_interrupt(void)
{
	// Verifica se o motivo da chamada da interrupção foi o estouro(overflow) do Timer0
	if(INTCONbits.TMR0IF)
	{
		//Re-carrega valor inicial do contador do Timer0
		WriteTimer0(INICIO_TMR0);

        if(barra_up_debounce == 2) barra_up_debounce = 1;

		//Limpa flag da interrupção do Timer0
		INTCONbits.TMR0IF = 0;
	}
}