//Interrupt handler to void __ISR(_TIMER_3_VECTOR, ipl3) _Timer3Handler(void) { //Reset the flag mT3ClearIntFlag(); }
/** * @fn void __ISR( _TIMER_3_VECTOR, IPL2SOFT ) Timer3Handler( void ) * @brief Vecteur d'interruption du timer 3 */ void __ISR( _TIMER_3_VECTOR, IPL2SOFT ) Timer3Handler(void){ // On baisse le flag mT3ClearIntFlag(); // Début de traitement flagTraitement = 1; }
// Interrupt Service Routine for TIMER 3. This is used to switch between the // buzzing and quiet periods when ON_CYCLES or OFF_CYCLES are reached. extern "C" void __ISR (_TIMER_3_VECTOR, ipl5) T3_IntHandler (void) { alarm--; if (alarm == 0) { buzzing = !buzzing; if (is_buzzer_on && buzzing) { switch(BUZZER_PIN) { case 9: OpenOC4(OC_ON | OC_TIMER3_SRC | OC_PWM_FAULT_PIN_DISABLE, DUTY_CYCLE, 0); break; case 10: OpenOC5(OC_ON | OC_TIMER3_SRC | OC_PWM_FAULT_PIN_DISABLE, DUTY_CYCLE, 0); break; } alarm = ON_CYCLES; } else { switch(BUZZER_PIN) { case 9: CloseOC4(); break; case 10: CloseOC5(); break; } alarm = OFF_CYCLES; pin_write(BUZZER_PIN, LOW); } } // Clear interrupt flag // This will break other interrupts and millis() (read+clear+write race condition?) // IFS0bits.T3IF = 0; // DON'T!! // Instead: mT3ClearIntFlag(); }
// 20Hz ISR void initTimer3Interrupt(void) { OpenTimer3(T3_ON | T3_PS_1_256, 15625); mT3SetIntPriority(1); mT3ClearIntFlag(); mT3IntEnable(1); }
// timer3 ISR // Read the encoder, and send over the data desired by printMode void __ISR( _TIMER_3_VECTOR, ipl1) T3Interrupt( void) { timesec++; int counterval1; int counterval2; if(!start) { // read_7366(MOT, CNTR, readbuf); // counterval1 = (((int)(readbuf[0]))<<8) | ((int)(readbuf[1])); // // read_7366(MAG1, CNTR, readbuf); // counterval2 = (((int)(readbuf[0]))<<8) | ((int)(readbuf[1])); counterval1 = (int)(atan2(((float)ACC1X-505.0),((float)ACC1Y-530.0))*180.0/3.1416); counterval2 = (int)(atan2(((float)ACC2X-505.0),((float)ACC2Y-530.0))*180.0/3.1416); sprintf(RS232_Out_Buffer,"%i %i %i %i %i\r\n", counterval1, counterval2, delay1,delay2, delay3); WriteString(UART3, RS232_Out_Buffer); } else { counterval1 = GYRO1HI; counterval2 = GYRO2HI; sprintf(RS232_Out_Buffer,"%i %i\r\n", counterval1, counterval2); WriteString(UART3, RS232_Out_Buffer); } // clear interrupt flag and exit mT3ClearIntFlag(); }
//============================================= // Configure the Timer 3 interrupt handler //============================================= void __ISR(_TIMER_3_VECTOR, T3_INTERRUPT_PRIORITY) Timer3InterruptHandler(void) { // Increment the number of overflows from this timer. Used primarily by Input Capture Timer.Var.nOverflows[2]++; mT3ClearIntFlag(); }
void __T3_ISR _T3Interrupt(void) { // Clear flag #ifdef __PIC32MX__ mT3ClearIntFlag(); #else IFS0bits.T3IF = 0; #endif TouchProcessTouch(); }
void __T3_ISR _T3Interrupt(void) { TMR3 = 0; // Clear flag #ifdef __PIC32MX__ mT3ClearIntFlag(); #else IFS0bits.T3IF = 0; #endif TouchDetectPosition(); }
void __ISR(_TIMER_3_VECTOR, ipl3) Timer3Handler(void) { mT3ClearIntFlag(); printf("timeout\n"); //printf("mspeed %d\n",motor_command(500)); //waitabit(1000); //printf("angle %f\n",get_AHRS_angle()); //waitabit(1000); // printf("speed %f\n", get_AHRS_rate()); //waitabit(500000); //works with 1000000 and 500000 //printf("mspeed %d\n\n", motor_command(500)); printf("duty cycle %d\n", PWM_GetDutyCycle(PWM_PORTY04)); motor_command(300); //MDBSS ^= 1; }
// h/w clock ASK emulator - initialise data pointers for ISR and start timer 2 // args: clock pulsewidth (NOT period!), data as array of 0/1, repeat void write_ASK_HW_clock(unsigned int pulse, BYTE *data, unsigned int tpb, unsigned int repeat) { // convert to ticks pulse= CONVERT_TO_TICKS(pulse); // we only need to tick once per bit pulse *= (unsigned long) tpb; // point globals at data for ISR EMU_ThisBit= *data; EMU_Data= data + 1; EMU_Reset_Data= data; EMU_DataBitRate= 1; EMU_SubCarrier_T0= 1; EMU_Repeat= repeat; // if we're manchester or bi-phase encoding, we want to clock twice as fast so we can toggle on half-bit if(RFIDlerConfig.Manchester || RFIDlerConfig.BiPhase) { pulse /= 2; EMU_SubCarrier_T0 *= 2; EMU_DataBitRate *= 2; } // make sure no clock is running stop_HW_clock(); // set mode EmulationMode= MOD_MODE_ASK_OOK; // make sure nobody's using our timer CloseTimer3(); // tri-state on, clock low READER_CLOCK_ENABLE_ON(); CLOCK_COIL= LOW; // emulator mode COIL_MODE_EMULATOR(); // this is also a semaphore so the rest of the code knows we're running mLED_Emulate_On(); // start timer - ISR will send data OpenTimer3( T3_ON | T3_PS_1_1 | T3_SOURCE_INT, pulse - 1L); mT3SetIntPriority(6); mT3ClearIntFlag(); mT3IntEnable(TRUE); }
/************************************************************************************************** Timer 3 interrupt. Used to generate the horiz and vert sync pulse under control of the state machine ***************************************************************************************************/ void __ISR(_TIMER_3_VECTOR, IPL7SOFT) T3Interrupt(void) { static int *VPtr; static unsigned char AlternateField = 0; // used to count odd/even fields in composite video static unsigned int LineCnt = 1; switch ( VState) { // vertical state machine case SV_PREEQ: // 0 // prepare for the new horizontal line VPtr = VideoBuf; LineCnt = 1; break; case SV_SYNC: // 1 /* if(!vga) { // if the video is composite P_VID_OC_REG = SvSyncT; // start the vertical sync pulse for composite VCount += AlternateField; // in composite video the alternative field has one extra line AlternateField ^= 1; } */ P_VERT_SET_LO; // start the vertical sync pulse for vga break; case SV_POSTEQ: // 2 //if(!vga) P_VID_OC_REG = C_HSYNC_T; // end of the vertical sync pulse for composite P_VERT_SET_HI; // end of the vertical sync pulse for vga break; case SV_LINE: // 3 P_SPI_INPUT = 0; // preload the SPI with 4 zero bytes to pad the start of the video //if(vga) DCH1SSA = KVA_TO_PA((void*) (VPtr)); // update the DMA1 source address (DMA1 is used for VGA data) //else // DCH0SSA = KVA_TO_PA((void*) (VPtr - 1)); // update the DMA0 source address (DMA0 is used for composite data) if(!Display24Lines || LineCnt++ % 3) VPtr += HBuf/32; // move the pointer to the start of the next line DmaChnEnable(1); // arm the DMA transfer break; } if (--VCount == 0) { // count down the number of lines VCount = VC[VState&3]; // set the new count VState = VS[VState&3]; // and advance the state machine } mT3ClearIntFlag(); // clear the interrupt flag }
void initPIC() { SYSTEMConfig(SYS_FREQ, SYS_CFG_ALL); initLEDs(); initSerialNU32v2(); // Setup and turn off electromagnets EMAG1 = 0; EMAG2 = 0; TRISEbits.TRISE7 = 0; TRISCbits.TRISC1 = 0; // Direction Output DIR = 1; TRISAbits.TRISA9 = 0; setup_counters(); CloseADC10(); #define PARAM1 ADC_MODULE_ON | ADC_FORMAT_INTG | ADC_CLK_AUTO | ADC_AUTO_SAMPLING_ON #define PARAM2 ADC_VREF_AVDD_AVSS | ADC_OFFSET_CAL_DISABLE | ADC_SCAN_ON | ADC_SAMPLES_PER_INT_16 | ADC_ALT_BUF_OFF | ADC_ALT_INPUT_OFF #define PARAM3 ADC_CONV_CLK_INTERNAL_RC | ADC_SAMPLE_TIME_31 #define PARAM4 ENABLE_AN0_ANA | ENABLE_AN1_ANA | ENABLE_AN2_ANA | ENABLE_AN3_ANA | ENABLE_AN5_ANA | ENABLE_AN15_ANA OpenADC10(PARAM1, PARAM2, PARAM3, PARAM4, 0); EnableADC10(); // 20kHz PWM signal, duty from 0-1000, pin D3 OpenTimer2(T2_ON | T2_PS_1_4, MAX_DUTY); OpenOC4(OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0); SetDCOC4PWM(0); // 200 Hz ISR OpenTimer3(T3_ON | T3_PS_1_256, (6250/4 - 1)); //OpenTimer3(T3_ON | T3_PS_1_256, (62500 - 1)); mT3SetIntPriority(1); mT3ClearIntFlag(); mT3IntEnable(1); INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR); INTEnableSystemMultiVectoredInt(); }
// h/w clock PSK emulator - initialise data pointers for ISR and start timer 2 // args: clock period, data as array of 0/1, fc per bit, sub-carrier ticks, repeat void write_PSK1_HW_clock(unsigned int period, BYTE *data, unsigned int fcpb, unsigned int c0, unsigned int repeat) { // convert to ticks period= CONVERT_TO_TICKS(period); // for psk we want a full clock cycle, not a tick period *= 2; // point globals at data for ISR EMU_ThisBit= *data; EMU_Data= data + 1; EMU_Reset_Data= data; EMU_DataBitRate= fcpb; EMU_SubCarrier_T0= c0; EMU_Repeat= repeat; // set mode EmulationMode= MOD_MODE_PSK1; // make sure no clock is running stop_HW_clock(); // make sure nobody's using our timers CloseTimer3(); // tri-state on, clock low READER_CLOCK_ENABLE_ON(); CLOCK_COIL= LOW; // emulator mode COIL_MODE_EMULATOR(); // this is also a semaphore so the rest of the code knows we're running mLED_Emulate_On(); // start timer - ISR will send data OpenTimer3( T3_ON | T3_PS_1_1 | T3_SOURCE_INT, period / 2L - 1L); mT3SetIntPriority(6); mT3ClearIntFlag(); mT3IntEnable(TRUE); }
// h/w clock FSK emulator - initialise data pointers for ISR and start timer 2 // args: clock pulsewidth (NOT period!), data as array of 0/1, T0 sub-carrier ticks, T1 sub-carrier ticks, repeat void write_FSK_HW_clock(unsigned long pulse, BYTE *data, unsigned int tpb, unsigned int t0, unsigned int t1, unsigned int repeat) { // convert to ticks pulse= CONVERT_TO_TICKS(pulse); // point globals at data for ISR EMU_ThisBit= *data; EMU_Data= data + 1; EMU_Reset_Data= data; EMU_Repeat= repeat; EMU_DataBitRate= tpb; EMU_SubCarrier_T0= t0; EMU_SubCarrier_T1= t1; // set mode EmulationMode= MOD_MODE_FSK; // make sure no clock is running stop_HW_clock(); // make sure nobody's using our timer CloseTimer3(); // emulator mode COIL_MODE_EMULATOR(); // tri-state on, clock low READER_CLOCK_ENABLE_ON(); CLOCK_COIL= LOW; // this is also a semaphore so the rest of the code knows we're running mLED_Emulate_On(); // start timer - ISR will send data OpenTimer3( T3_ON | T3_PS_1_1 | T3_SOURCE_INT, pulse - 1L); mT3SetIntPriority(6); mT3ClearIntFlag(); mT3IntEnable(TRUE); }
void __ISR(_TIMER_3_VECTOR, ipl2) _InterruptHandler_TMR3(void) { // if(current_block->direction_bits[Y_AXIS]) // PORTSetBits(xAxis.directionPin.port, xAxis.directionPin.pin); // else // PORTClearBits(yAxis.directionPin.port, yAxis.directionPin.pin); if(steps_X) { if(!(mPORTGReadBits(xAxis.enablePin.pin))) steps_X--; } else if (current_block != Null) { if(current_block->steps_x) { if(!(mPORTGReadBits(xAxis.enablePin.pin))) current_block->steps_x--; } else { //CloseOC2(); BSP_AxisDisable(X_AXIS); BSP_Timer3Stop(); } } else { //CloseOC2(); BSP_AxisDisable(X_AXIS); BSP_Timer3Stop(); } // clear the interrupt flag mT3ClearIntFlag(); }
void __T3_ISR _T3Interrupt(void) { static SHORT tempX, tempY; SHORT temp; switch(state){ case SET_VALUES: if(!AD1CON1bits.DONE) break; if( (WORD)PRESS_THRESHOULD < (WORD)ADC1BUF0 ){ adcX = -1; adcY = -1; }else{ adcX = tempX; adcY = tempY; } state = RUN_POT; case RUN_POT: AD1CHS = ADC_POT; // switch ADC channel AD1CON1bits.SAMP = 1; // run conversion state = GET_POT; break; case GET_POT: if(!AD1CON1bits.DONE) break; adcPot = ADC1BUF0; state = SET_X; case SET_X: AD1CHS = ADC_XPOS; // switch ADC channel ADPCFG_XPOS = 0; // analog ADPCFG_YPOS = 1; // digital TRIS_XPOS = 1; TRIS_YPOS = 1; TRIS_XNEG = 1; LAT_YNEG = 0; TRIS_YNEG = 0; AD1CON1bits.SAMP = 1; // run conversion state = CHECK_X; break; case CHECK_X: if(!AD1CON1bits.DONE) break; if( (WORD)PRESS_THRESHOULD > (WORD)ADC1BUF0 ){ LAT_YPOS = 1; TRIS_YPOS = 0; tempX = -1; state = RUN_X; }else{ adcX = -1; adcY = -1; state = RUN_POT; break; } case RUN_X: AD1CON1bits.SAMP = 1; state = GET_X; break; case GET_X: if(!AD1CON1bits.DONE) break; temp = ADC1BUF0; if(temp != tempX){ tempX = temp; state = RUN_X; break; } TRIS_YPOS = 1; AD1CON1bits.SAMP = 1; state = SET_Y; break; case SET_Y: if(!AD1CON1bits.DONE) break; if( (WORD)PRESS_THRESHOULD < (WORD)ADC1BUF0 ){ adcX = -1; adcY = -1; state = RUN_POT; break; } AD1CHS = ADC_YPOS; // switch ADC channel ADPCFG_XPOS = 1; // digital ADPCFG_YPOS = 0; // analog TRIS_XPOS = 1; TRIS_YPOS = 1; LAT_XNEG = 0; TRIS_XNEG = 0; TRIS_YNEG = 1; AD1CON1bits.SAMP = 1; // run conversion state = CHECK_Y; break; case CHECK_Y: if(!AD1CON1bits.DONE) break; if( (WORD)PRESS_THRESHOULD > (WORD)ADC1BUF0 ){ LAT_XPOS = 1; TRIS_XPOS = 0; tempY = -1; state = RUN_Y; }else{ adcX = -1; adcY = -1; state = RUN_POT; break; } case RUN_Y: AD1CON1bits.SAMP = 1; state = GET_Y; break; case GET_Y: // Get Y value if(!AD1CON1bits.DONE) break; temp = ADC1BUF0; if(temp != tempY){ tempY = temp; state = RUN_Y; break; } TRIS_XPOS = 1; AD1CON1bits.SAMP = 1; state = SET_VALUES; break; default: state = SET_X; } // Clear flag #ifdef __PIC32MX__ mT3ClearIntFlag(); #else IFS0bits.T3IF = 0; #endif }
int main(void) { timesec=0; // set PIC32 to max computing power SYSTEMConfig(SYS_FREQ, SYS_CFG_ALL); INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR); INTEnableSystemMultiVectoredInt(); initLEDs(); LED0 = 1; LED1 = 1; initSerialNU32v2(); setup_counters(); CloseADC10(); #define PARAM1 ADC_MODULE_ON | ADC_FORMAT_INTG | ADC_CLK_AUTO | ADC_AUTO_SAMPLING_ON #define PARAM2 ADC_VREF_AVDD_AVSS | ADC_OFFSET_CAL_DISABLE | ADC_SCAN_ON | ADC_SAMPLES_PER_INT_16 | ADC_ALT_BUF_OFF | ADC_ALT_INPUT_OFF #define PARAM3 ADC_CONV_CLK_INTERNAL_RC | ADC_SAMPLE_TIME_31 #define PARAM4 ENABLE_AN0_ANA | ENABLE_AN1_ANA | ENABLE_AN2_ANA | ENABLE_AN3_ANA | ENABLE_AN5_ANA | ENABLE_AN15_ANA OpenADC10( PARAM1, PARAM2, PARAM3, PARAM4,0); EnableADC10(); // Setup and turn off electromagnets EMAG1 = 0; EMAG2 = 0; TRISEbits.TRISE7 = 0; TRISCbits.TRISC1 = 0; //Direction Output DIR = 1; TRISAbits.TRISA9 = 0; //g-select Outputs GSEL1 = 0; GSEL2 = 0; TRISEbits.TRISE2 = 0; TRISCbits.TRISC13= 0; //0g Inputs TRISAbits.TRISA0 = 1; TRISAbits.TRISA4 = 1; // 20kHz PWM signal, duty from 0-1000, pin D3 OpenTimer2(T2_ON | T2_PS_1_4, 1000); OpenOC4(OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0); HBridgeDuty = 0; SetDCOC4PWM(HBridgeDuty); // 20Hz ISR OpenTimer3(T3_ON | T3_PS_1_256, 15625); mT3SetIntPriority(1); mT3ClearIntFlag(); mT3IntEnable(1); while(1) { if(start){ EMAG2=0; SetDCOC4PWM(100); delaysec(delay1); SetDCOC4PWM(1000); delaysec(delay2); SetDCOC4PWM(500); delaysec(delay3); EMAG2=1; SetDCOC4PWM(0); // EMAG1=0; // SetDCOC4PWM(900); // DIR = 0; // delaysec(delay1); // SetDCOC4PWM(0); // delaysec(delay2); // SetDCOC4PWM(700); // delaysec(delay1); // SetDCOC4PWM(1000); // EMAG1=1; start=0; } } }
// Emulate TAG ISR // this ISR does the actual send of a '*' terminated bitstream // mLED_Antenna is set during emulation, and can be used as a semaphore to detect emulation in progress // note that the best resolution we can achieve on a pic32 seems to be 2us // // setup routine is responsible for: // // setting clock period and arming interrupt // setting global variables: // // EMU_ThisBit - the next bit to output (as 0x00 or 0x01) // *EMU_Data - pointer to array of 0x00/0x01 values, '*' terminated // inital value should be &EMU_ThisBit + 1 // *EMU_Reset_Data - pointer to the complete data array // EMU_Repeat - number of times to repeat full data pattern (0 means send once) // EMU_Invert - Invert 0x00/0x01 values TRUE/FALSE // EMU_DataBitRate - Frame Clocks Per Bit // EMU_SubCarrier_T0 - 1st sub-carrier Frame Clocks // EMU_SubCarrier_T1 - 2nd sub-carrier Frame Clocks // EMU_Manchester - Manchester Encoding TRUE/FALSE // EMU_BiPhase - BiPhase Encoding TRUE/FALSE void __ISR(_TIMER_3_VECTOR, ipl7auto) emulation_send_bit (void) { static unsigned int count= 0; // ack interrupt mT3ClearIntFlag(); #ifdef RFIDLER_DEBUG // show bit value //DEBUG_PIN_1= EMU_ThisBit; // show tick //DEBUG_PIN_2= !DEBUG_PIN_2; #endif // are we finished? if(EMU_ThisBit == '*') { if(!EMU_Background && !(EMU_Repeat--)) { CloseTimer3(); mLED_Emulate_Off(); count= 0; COIL_OUT= 0; return; } // repeat EMU_Data= EMU_Reset_Data; EMU_ThisBit= *(EMU_Data++); count= 0; } // count reflects the FC we are about to process, starting from 1 // so we can calulate bit periods and sub-carriers. // count should be reset after each full bit. ++count; // output and set up bit for next tick switch(EmulationMode) { // ASK / OOK - we get called once per bit just toggle the line according to bit value // // MANCHESTER/BI_PHASE - we get called twice per bit, half-bit toggles // case MOD_MODE_ASK_OOK: // output half-bit? manchester always toggles, biphase only toggles if it's a 1 if(count == EMU_SubCarrier_T0 && (RFIDlerConfig.Manchester || (RFIDlerConfig.BiPhase && (EMU_ThisBit ^ RFIDlerConfig.Invert)))) COIL_OUT= !COIL_OUT; // output current bit else { // biphase always toggles on a full bit period if(RFIDlerConfig.BiPhase) { if (count % EMU_DataBitRate) COIL_OUT= !COIL_OUT; } else COIL_OUT= (EMU_ThisBit ^ RFIDlerConfig.Invert); } // is this a bit period? if (count == EMU_DataBitRate) { // set the next bit value EMU_ThisBit= *(EMU_Data++); count= 0; } break; // FSK - we get called N times per bit // create sub-carriers T0 & T1 for bit values 0 and 1 // e.g. if bit period N is 40 ticks (RF/40) and T0 is RF/8 and T1 is RF/5 // then T0 is 8 ticks and T1 is 5 ticks. // note that we must independantly check for end of bit period for each sub-carrier // to cater for cases where there is no common clock multiple (e.g. HID: RF/8 & RF/10) case MOD_MODE_FSK1: case MOD_MODE_FSK2: // output sub-carriers // if current bit is a '1' if(EMU_ThisBit ^ RFIDlerConfig.Invert) { if(!(count % EMU_SubCarrier_T1)) COIL_OUT= !COIL_OUT; // rounded bit period? if (!(count % ((EMU_DataBitRate / EMU_SubCarrier_T1) * EMU_SubCarrier_T1))) { // set the next bit value EMU_ThisBit= *(EMU_Data++); count= 0; } } // if current bit is a '0' else { if(!(count % EMU_SubCarrier_T0)) COIL_OUT= !COIL_OUT; // rounded bit period? if (!(count % ((EMU_DataBitRate / EMU_SubCarrier_T0) * EMU_SubCarrier_T0))) { // set the next bit value EMU_ThisBit= *(EMU_Data++); count= 0; } } break; // TODO: PSK2, PSK3 // PSK1 - we get called N times per bit // create sub-carrier // half-bit phase shift if bit changes case MOD_MODE_PSK1: // output sub-carrier? if(!(count % EMU_SubCarrier_T0)) COIL_OUT= !COIL_OUT; // output current bit else COIL_OUT= (EMU_ThisBit ^ RFIDlerConfig.Invert); // is this is a bit period? if (count == EMU_DataBitRate) { // set the next bit value EMU_ThisBit= *(EMU_Data++); count= 0; } break; default: break; } //#ifdef RFIDLER_DEBUG // // show modulator // DEBUG_PIN_3= COIL_OUT; //#endif }
/**************************************************************************** Function: Timer5IntHandler Parameters: None. Returns: None. Description Implements the Stepper motor FULL STEP drive state machine. Notes Author: Gabriel Hugh Elkaim, 2011.12.15 16:42 ****************************************************************************/ void __ISR(_TIMER_3_VECTOR, ipl4) Timer3IntHandler(void) { static unsigned short timerLoopCount = 0; LED_BANK1_0 ^= 1; if (++timerLoopCount > overflowReps) { timerLoopCount = 0; LED_BANK1_1 ^= 1; // execute Stepper Drive state machine here switch(stepperState) { case off: // should not get here dbprintf("\noff"); T5CONbits.ON = 0; // halt timer5 ShutDownDrive(); CloseTimer5(); break; case inited: case halted: case waiting: ShutDownDrive(); if (stepCount < 0) stepCount = 0; LED_BANK1_2 ^= 1; break; //------------------- Full-Step -------------------------- case stepping: switch(stepperMode) { case full: if (--stepCount <= 0) stepperState = waiting; LED_BANK1_3 ^= 1; TurnOnDrive(); // enable both coils switch(coilState) { case step_one: // coil drive both forward ADirectionOn(); BDirectionOn(); if (stepDir == FORWARD) coilState = step_two; else coilState = step_four; break; case step_two: // coil drive A forward, B reverse ADirectionOn(); BDirectionOff(); if (stepDir == FORWARD) coilState = step_three; else coilState = step_one; break; case step_three: // coil drive both reverse ADirectionOff(); BDirectionOff(); if (stepDir == FORWARD) coilState = step_four; else coilState = step_two; break; case step_four: // coild drive A reverse, B forward ADirectionOff(); BDirectionOn(); if (stepDir == FORWARD) coilState = step_one; else coilState = step_three; break; } // end of full-step drive break; //------------------- Wave Drive ------------------------ case wave: if (--stepCount <= 0) stepperState = waiting; LED_BANK1_3 ^= 1; switch(coilState) { case step_one: // coil drive both forward AEnable(); BDisable(); ADirectionOn(); if (stepDir == FORWARD) coilState = step_two; else coilState = step_four; printf("\nStep one, wave"); break; case step_two: // coil drive A forward, B reverse ADisable(); BEnable(); BDirectionOff(); if (stepDir == FORWARD) coilState = step_three; else coilState = step_one; printf("\nStep two, wave"); break; case step_three: // coil drive both reverse AEnable(); BDisable(); ADirectionOff(); if (stepDir == FORWARD) coilState = step_four; else coilState = step_two; printf("\nStep three, wave"); break; case step_four: // coild drive A reverse, B forward ADisable(); BEnable(); BDirectionOn(); if (stepDir == FORWARD) coilState = step_one; else coilState = step_three; printf("\nStep four, wave"); break; } // end of wave drive break; //------------------- Half Step -------------------------- case half: if (--stepCount <= 0) stepperState = waiting; LED_BANK1_3 ^= 1; switch(coilState) { case step_one: // coil drive both forward AEnable(); BEnable(); ADirectionOn(); BDirectionOn(); if (stepDir == FORWARD) coilState = step_two; else coilState = step_eight; break; case step_two: // coil drive A forward, B reverse AEnable(); BDisable(); ADirectionOn(); BDirectionOff(); if (stepDir == FORWARD) coilState = step_three; else coilState = step_one; break; case step_three: // coil drive both reverse AEnable(); BEnable(); ADirectionOn(); if (stepDir == FORWARD) coilState = step_four; else coilState = step_two; break; case step_four: // coild drive A reverse, B forward ADisable(); BEnable(); BDirectionOff(); if (stepDir == FORWARD) coilState = step_five; else coilState = step_three; break; case step_five: // coil drive both forward AEnable(); BEnable(); ADirectionOff(); // ? BDirectionOff(); if (stepDir == FORWARD) coilState = step_six; else coilState = step_four; break; case step_six: // coil drive A forward, B reverse AEnable(); BDisable(); ADirectionOff(); if (stepDir == FORWARD) coilState = step_seven; else coilState = step_five; break; case step_seven: // coil drive both reverse AEnable(); BEnable(); ADirectionOff(); BDirectionOn(); if (stepDir == FORWARD) coilState = step_eight; else coilState = step_six; break; case step_eight: // coild drive A reverse, B forward ADisable(); BEnable(); BDirectionOn(); if (stepDir == FORWARD) coilState = step_one; else coilState = step_seven; break; } // end of half-step drive break; } // end of switch(stepperMode) } // end of switch(stepperState) } mT3ClearIntFlag(); }
/**************************************************************************** Function: Timer5IntHandler Parameters: None. Returns: None. Description Implements the Stepper motor FULL STEP drive state machine. Notes Author: Gabriel Hugh Elkaim, 2011.12.15 16:42 ****************************************************************************/ void __ISR(_TIMER_3_VECTOR, ipl4) Timer3IntHandler(void) { static unsigned short timerLoopCount = 0; LED_BANK1_0 ^= 1; if (++timerLoopCount > overflowReps) { timerLoopCount = 0; LED_BANK1_1 ^= 1; // execute Stepper Drive state machine here switch(stepperState) { case off: // should not get here dbprintf("\noff"); T5CONbits.ON = 0; // halt timer5 ShutDownDrive(); CloseTimer5(); break; case inited: case halted: case waiting: ShutDownDrive(); if (stepCount < 0) stepCount = 0; LED_BANK1_2 ^= 1; break; case stepping: if (--stepCount <= 0) stepperState = waiting; LED_BANK1_3 ^= 1; TurnOnDrive(); switch(coilState) { case step_one: // coil drive both forward COIL_A_DIRECTION = 1; COIL_B_DIRECTION = 1; if (stepDir == FORWARD) coilState = step_two; else coilState = step_four; break; case step_two: // coil drive A forward, B reverse COIL_A_DIRECTION = 1; COIL_B_DIRECTION = 0; if (stepDir == FORWARD) coilState = step_three; else coilState = step_one; break; case step_three: // coil drive both reverse COIL_A_DIRECTION = 0; COIL_B_DIRECTION = 0; if (stepDir == FORWARD) coilState = step_four; else coilState = step_two; break; case step_four: // coild drive A reverse, B forward COIL_A_DIRECTION = 0; COIL_B_DIRECTION = 1; if (stepDir == FORWARD) coilState = step_one; else coilState = step_three; break; } break; } } mT3ClearIntFlag(); }