//---- INT Handlers ----//
void Timer0BIntHandler(void)
{
//
// Clear the timer interrupt flag.
//
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMB_TIMEOUT);
//
// Update the periodic interrupt counter.
//
g_ui32Counter++;
//
// Once NUMBER_OF_INTS interrupts have been received, turn off the
// TIMER0B interrupt.
//
if(g_ui32Counter == NUMBER_OF_INTS)
{
//
// Disable the Timer0B interrupt.
//
ROM_IntDisable(INT_TIMER0B);
//
// Turn off Timer0B interrupt.
//
ROM_TimerIntDisable(TIMER0_BASE, TIMER_TIMB_TIMEOUT);
//
// Clear any pending interrupt flag.
//
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMB_TIMEOUT);
}
}
void
ToneIntHandler(void)
{
ROM_TimerIntClear(TIMER4_BASE, TIMER_A);
//End of tone duration
if(--g_duration <= 0) {
noTone(current_pin);
ROM_TimerIntDisable(TIMER4_BASE, TIMER_TIMA_TIMEOUT);
ROM_TimerIntClear(TIMER4_BASE, TIMER_TIMA_TIMEOUT);
ROM_TimerDisable(TIMER4_BASE, TIMER_A);
}
}
//*****************************************************************************
//
// The interrupt handler for the fourth timer interrupt. (light)
//
//*****************************************************************************
void
Timer3IntHandler(void)
{
//
// Clear the timer interrupt.
//
ROM_TimerIntClear(TIMER3_BASE, TIMER_TIMA_TIMEOUT);
// Get the timer value and reset it
ROM_TimerDisable(TIMER5_BASE, TIMER_A);
// Get the timer value
Timer = ROM_TimerValueGet(TIMER5_BASE, TIMER_A);
// Reset the timer value to 65000
ROM_TimerLoadSet(TIMER5_BASE, TIMER_A, 65000); // Timer5
ROM_TimerEnable(TIMER5_BASE, TIMER_A);
//
// Toggle the flag for the light timer.
//
HWREGBITW(&g_ui32InterruptFlags, 2) = 1;
//
// Update the interrupt status.
//
}
//*****************************************************************************
//
// The interrupt handler for the real time clock interrupt.
//
//*****************************************************************************
void
Timer0IntHandler(void)
{
//Real time clock interrupt, keep track of days, hours, minutes, seconds
//
// Clear the timer interrupt.
//
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
//Increment Timer A Count
TimerACount++;
RTC_Seconds = (TimerACount / 10);
RTC_Minutes = (RTC_Seconds / 60);
RTC_Hours = (RTC_Minutes / 60);
RTC_Days = RTC_Hours / 24;
HWREGBITW(&g_ui32PrintFlags, 0) = 1;
/*//
// Use the flags to Toggle the LED for this timer
//
GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, g_ui32Flags);*/
//
// Update the interrupt status.
//
}
void Timer0AIntHandler(void)
{
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
led_value ^= LED_BLUE;
ROM_GPIOPinWrite(GPIO_PORTF_BASE, LED_BLUE, led_value);
}
//*****************************************************************************
//
// The interrupt handler for timer 4. This will be called whenever the timer
// count reaches the match value (0 in this example).
//
// TODO: Make sure you hook your ISR to the correct vector in the application
// startup file.
//
//*****************************************************************************
void
Timer4IntHandler(void)
{
//
// Clear the timer interrupt.
//
// TODO: Rework this for the timer you are using in your application.
//
ROM_TimerIntClear(TIMER4_BASE, TIMER_CAPA_MATCH);
//
// TODO: Do whatever your application needs to do when the relevant
// number of edges have been counted.
//
ProcessInterrupt();
//
// The timer is automatically stopped when it reaches the match value
// so re-enable it here.
//
// TODO: Whether you reenable the timer here or elsewhere will be up to
// your particular application.
//
ROM_TimerEnable(TIMER4_BASE, TIMER_A);
}
///
/// routine di servizio del timer0
void Timer0ISR(void){
//
// Clear the timer interrupt.
//
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
//
// Toggle the flag for the first timer.
//
///HWREGBITW(&g_ui32Flags, 0) ^= 1;
//PIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);
procCom = 1;
tick++;
//
// Use the flags to Toggle the LED for this timer
//
//GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, g_ui32Flags << 1);
//
// Update the interrupt status on the display.
//
}
void Timer0IntHandler(void){
// Used to countdown from entered time
// Clear the timer interrupt.
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
// Check if time has been reached
if(g_countdownTime == 0){
ROM_IntMasterDisable();
UARTprintf("Time's Up!\n\n");
ROM_IntMasterEnable();
ROM_TimerEnable(TIMER1_BASE, TIMER_A);
ROM_TimerIntDisable(TIMER0_BASE, TIMER_A);
return;
}
// Turn on LED
ROM_GPIOPinWrite(GPIO_PORTF_BASE, LED_RED, LED_RED);
ROM_TimerEnable(TIMER2_BASE, TIMER_A);
// Update the interrupt status on the display.
ROM_IntMasterDisable();
UARTprintf(" %i\n",g_countdownTime);
ROM_IntMasterEnable();
// Decrement counter
g_countdownTime--;
// Turn off LED
//ROM_GPIOPinWrite(GPIO_PORTF_BASE, LED_RED, 0);
}
//*****************************************************************************
//
//! Wide Timer interrupt to handle blinking effect of the RGB
//!
//! This function is called by the hardware interrupt controller on a timeout
//! of the wide timer. This function must be in the NVIC table in the startup
//! file. When called will toggle the enable flag to turn on or off the entire
//! RGB unit. This creates a blinking effect. A wide timer is used since the
//! blink is intended to be visible to the human eye and thus is expected to
//! have a frequency between 15 and 0.1 hz. Currently blink duty is fixed at
//! 50%.
//!
//! \return None.
//
//*****************************************************************************
void
RGBBlinkIntHandler(void)
{
static unsigned long ulFlags;
//
// Clear the timer interrupt.
//
ROM_TimerIntClear(WTIMER5_BASE, TIMER_TIMB_TIMEOUT);
//
// Toggle the flag for the blink timer.
//
ulFlags ^= 1;
if(ulFlags)
{
RGBEnable();
}
else
{
RGBDisable();
}
}
void timer0_int_handler(void) {
// Clear the interrupt flag
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
// Pass the next value to the DAC
dac_write(*readPtr);
readPtr++;
if (readPtr == startPtr + BUFFER_SIZE)
{
readPtr = startPtr;
}
// // Debugging
// if (g_ulTimeStamp % 100 == 0)
// {
// if (testTimer0)
// {
// UARTprintf("Timer 0 is firing\n");
// testTimer0 = 0;
// }
// }
// else
// {
// testTimer0 = 1;
// }
}
void Mode_WTimer3BISR(void){
ROM_TimerIntClear(WTIMER3_BASE, TIMER_CAPB_EVENT);
// Doc trang thai canh ngat
if (GPIOPinRead(GPIO_PORTD_BASE,GPIO_PIN_3)&GPIO_PIN_3)
ui32T_Edgeup_Mode = ROM_TimerValueGet(WTIMER3_BASE, TIMER_B);
else
{
if (firstEdgeMode)
{
firstEdgeMode=0;
return;
}
ui32T_Edgedown_Mode = ROM_TimerValueGet(WTIMER3_BASE, TIMER_B);
i32DeltaT_Mode = (int32_t)(ui32T_Edgedown_Mode - ui32T_Edgeup_Mode);
// UARTPutn(UART0_BASE,i32DeltaT_SStop);
// UARTCharPut(UART0_BASE,'\n');
// if ((i32DeltaT_Mode<125000) && (i32DeltaT_Mode>115000))
// isAuto=true;
// else if ((i32DeltaT_Mode>135000) && (i32DeltaT_Mode<145000))
// isAuto=false;
}
}
//*****************************************************************************
//
// The interrupt handler for the periodic timer interrupt. When the uDMA
// channel is used, interrupts from the periodic timer are used as DMA
// requests, and this interrupt handler is invoked only at the end of all of
// the DMA transfers.
//
//*****************************************************************************
void
Timer0IntHandler(void)
{
unsigned long ulStatus;
//
// Clear the timer interrupt.
//
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
//
// Read the uDMA channel status to verify it is done
//
ulStatus = uDMAChannelModeGet(UDMA_CHANNEL_TMR0A);
if(ulStatus == UDMA_MODE_STOP)
{
//
// Disable the periodic timer and set the done flag
//
ROM_TimerDisable(TIMER0_BASE, TIMER_A);
g_bDoneFlag = 1;
}
//
// Increment a counter to indicate the number of times this handler
// was invoked
//
g_ulTimer0AIntCount++;
}
//*****************************************************************************
//
// The interrupt handler for the first timer interrupt.
//
//*****************************************************************************
void
Timer0IntHandler(void)
{
char cOne, cTwo;
//
// Clear the timer interrupt.
//
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
//
// Toggle the flag for the first timer.
//
HWREGBITW(&g_ui32Flags, 0) ^= 1;
//
// Use the flags to Toggle the LED for this timer
//
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, g_ui32Flags << 1);
//
// Update the interrupt status on the display.
//
ROM_IntMasterDisable();
cOne = HWREGBITW(&g_ui32Flags, 0) ? '1' : '0';
cTwo = HWREGBITW(&g_ui32Flags, 1) ? '1' : '0';
UARTprintf("\rT1: %c T2: %c", cOne, cTwo);
ROM_IntMasterEnable();
}
// Triggered every SERVO_TIMER_RESOLUTION microseconds
void TimerIntHandlerServos(void) {
// Clear the interrupt
ROM_TimerIntClear(SERVO_TIMER, SERVO_TIMER_TRIGGER);
// SERVO_TIMER_RESOLUTION microseconds have passed, increment each counter by that
// to determine how long to set the pin high for
g_pulseTime += SERVO_TIMER_RESOLUTION;
if(g_pulseTime > SERVO_PERIOD) {
g_pulseTime = 0;
}
// Loop through al servo configs and see if they need to be set low yet
uint8_t i;
for(i=0; i<SERVO_MAX_COUNT; i++) {
servo_t *servo = &g_servos[i];
if(servo->state & SERVO_STATE_ENABLED) {
if(g_pulseTime >= servo->value) {
// End of pulse, set low
ROM_GPIOPinWrite(servo->port, servo->pin, 0);
} else {
// Beginning of pulse, set high
ROM_GPIOPinWrite(servo->port, servo->pin, servo->pin);
}
}
}
}
void ServoClass::ServoIntHandler(void)
{
// Clear the timer interrupt.
ROM_TimerIntClear(SERVO_TIMER, SERVO_TIMER_TRIGGER);
// Get the pulse width value for the current servo from the array
// if we have already serviced all servos (g_iServoNo = MAX_SERVO_NO)
// then this value should be the 20ms period value
unsigned long l_ulPulseWidth = g_ulTicksPerMicrosecond * g_ulServoPulse[g_iServoNo];
// Re-Load the timer with the new pulse width count value
ROM_TimerLoadSet(SERVO_TIMER, SERVO_TIMER_A, l_ulPulseWidth);
// End the servo pulse set previously (if any)
if(g_iServoNo > 0) // If not the 1st Servo....
{
if (g_ulServoPins[g_iServoNo - 1] != INVALID_SERVO_PIN)
digitalWrite(g_ulServoPins[g_iServoNo - 1], LOW);
}
// Set the current servo pin HIGH
if(g_iServoNo < SERVOS_PER_TIMER)
{
if (g_ulServoPins[g_iServoNo] != INVALID_SERVO_PIN)
digitalWrite(g_ulServoPins[g_iServoNo], HIGH);
g_iServoNo++; // Advance to next servo for processing next time
}
else
{
g_iServoNo = 0; // Start all over again
}
}
void stagInterrupt(void)
{
g_stag.moveLegs();
float a, b, c;
for (int i = 0; i < 4; i++)
{
g_stag.getLeg(i, &a, &b, &c);
/*
puts("Leg ");
puti(i+1);
puts(" Value1: ");
puti(servoPulseOffset[i*3] + a*angleToPulseFactor);
puts(" Value2: ");
puti(servoPulseOffset[i*3 + 1] + b*angleToPulseFactor);
puts(" Value3: ");
puti(servoPulseOffset[i*3 + 2] + c*angleToPulseFactor);
putln();
*/
servoWrite(legPins[i*3], servoPulseOffset[i*3] + a*angleToPulseFactor);
servoWrite(legPins[i*3 + 1], servoPulseOffset[i*3 + 1] + b*angleToPulseFactor);
servoWrite(legPins[i*3 + 2], servoPulseOffset[i*3 + 2] + c*angleToPulseFactor);
}
//putln();
// Sensor feeds are sent from here
ROM_TimerIntClear(WTIMER0_BASE, TIMER_TIMA_TIMEOUT);
}
void SStop_WTimer2AISR(void){
ROM_TimerIntClear(WTIMER2_BASE, TIMER_CAPA_EVENT);
// Doc trang thai canh ngat
if (GPIOPinRead(GPIO_PORTD_BASE,GPIO_PIN_0)&GPIO_PIN_0)
ui32T_Edgeup_SStop = ROM_TimerValueGet(WTIMER2_BASE, TIMER_A);
else
{
if (firstEdgeSStop)
{
firstEdgeSStop=0;
return;
}
ui32T_Edgedown_SStop = ROM_TimerValueGet(WTIMER2_BASE, TIMER_A);
i32DeltaT_SStop = (int32_t)(ui32T_Edgedown_SStop - ui32T_Edgeup_SStop);
// UARTPutn(UART0_BASE,i32DeltaT_SStop);
// UARTCharPut(UART0_BASE,'\n');
if ((i32DeltaT_SStop<125000) && (i32DeltaT_SStop>115000))
SSTOP_STOP;
else if ((i32DeltaT_SStop>135000) && (i32DeltaT_SStop<145000) && isRunning)
//both RF receiver and PC gui must start
SSTOP_START;
}
}
void Timer1IntHandler(void)
{
//debugled(10);
ROM_TimerIntClear(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
//debugled(3);
int angle=0;
if(max2>0 && max1>0 && abs(maxi1-maxi2)<PULSE_SAMPLE)
{
//float dt=abs(maxi1-maxi2)/SAMPLING_FREQUENCY;
//angle=asin(dt*lambda/distance)*180/3.1412;
angle=abs(maxi1-maxi2);
}
//debugled(3);
acount++;
//rcount=0;
//ROM_IntMasterDisable();
snprintf(text,sizeof(text),"%3ld,%3ld",rcount,g_ulADCCount);
GrContextForegroundSet(&sDisplayContext, ClrDarkBlue);
GrRectFill(&sDisplayContext, &sRect1);
GrContextForegroundSet(&sDisplayContext, ClrWhite);
//GrRectDraw(&sDisplayContext, &sRect1);
GrContextFontSet(&sDisplayContext, g_pFontCm12);
GrStringDrawCentered(&sDisplayContext,text, -1,
GrContextDpyWidthGet(&sDisplayContext) / 2, 10, 0);
GrContextForegroundSet(&sDisplayContext, ClrDarkBlue);
GrRectFill(&sDisplayContext, &sRect2);
GrContextForegroundSet(&sDisplayContext, ClrWhite);
sprintf(text,"%4d,%4d",buffer_increment,rem);
GrContextFontSet(&sDisplayContext, g_pFontCm12/*g_pFontFixed6x8*/);
GrStringDrawCentered(&sDisplayContext, text, -1,
GrContextDpyWidthGet(&sDisplayContext) / 2,
((GrContextDpyHeightGet(&sDisplayContext) - 24) / 2) + 24,
0);
// GrFlush(&sDisplayContext);
max1=0;
max2=0;
res=0;
res1=0;
maxi1=0;
maxi2=0;
buffer_index=0;
for(i=0;i<buffer_size;i++)
{
buffer[0][i]=0;
buffer[1][i]=0;
}
i=0;
j=0;
ind2=buffer_index-buffer_increment+1;
}
void Timer1A_Interrupt_Handler(void){
// Clear the timer interrupt.
ROM_TimerIntClear(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
// Spin the Clock Face
LCD_Clock();
}
void stop_Timer0B(void)
{
ROM_IntDisable(INT_TIMER0B);
ROM_TimerIntDisable(TIMER0_BASE, TIMER_TIMB_TIMEOUT);
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMB_TIMEOUT);
}
/** ISR for Timer 2
* @pre timer configured with initTimer
* @pre global interrupts enabled with HAL_ENABLE_INTERRUPTS()
*/
void Timer2IntHandler(void)
{
// Clear the timer interrupt
ROM_TimerIntClear(TIMER2_BASE, TIMER_TIMA_TIMEOUT);
// Call the timerIsr function pointer
timerIsr();
}
//定时器0A周期中断服务函数
void Timer0AIntHandler(void)
{
static uint8_t i = 0;
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT); //清除定时器中断标志
Get_Attitude();//读取MPU6050得到姿态角
if (Pitch > 45 || Pitch < -45) //俯仰角限幅
{
g_stop_fly = 1; //停止
}
if (Roll > 45 || Roll < -45) //横滚角限幅
{
g_stop_fly = 1;
}
X_MODE_Control(); //PID控制
if (g_start == 0)
{
//输出值最大值限幅
if (X_OUT1 > 5000) X_OUT1 = 5000;
else if (X_OUT1 < 2620) X_OUT1 = 2620;
if (X_OUT2 > 5000) X_OUT2 = 5000;
else if (X_OUT2 < 2620) X_OUT2 = 2620;
if (X_OUT3 > 5000) X_OUT3 = 5000;
else if (X_OUT3 < 2620) X_OUT3 = 2620;
if (X_OUT4 > 5000) X_OUT4 = 5000;
else if (X_OUT4 < 2620) X_OUT4 = 2620;
}
PWM_WidthSet(X_OUT1, X_OUT2, X_OUT3, X_OUT4);//PWM输出，电机控制
ui32Counter++; //更新周期中断计数
if (ui32Counter == NUMBER_OF_INTS) //1s闪灯标志
{
g_1s_flag = 1;
if (i == 0)
{
i = 1;
ui32Counter = 0;
LED_off;
}
else
{
i = 0;
ui32Counter = 0;
LED_on;
}
}
}
void Timer0IntHandler()
{
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
buffer[sample] = GPIO_PORTB_DATA_R;
if (++sample >= BUFFER_LEN)
{
stop();
}
}
void Timer4ISR(void) {
/// pulisce le interruzione del timer4
ROM_TimerIntClear(TIMER4_BASE, TIMER_TIMA_TIMEOUT);
/// disabilita la porta D a generare interruzioni
GPIOIntDisable(GPIO_PORTD_BASE, GPIO_INT_PIN_1);
/// disabilita il timer 4
TimerDisable(TIMER4_BASE, TIMER_A);
/// segnala lo scadere del timer
procCom4 = 1;
/// spento il dispositivo
HWREG(GPIO_PORTD_BASE + (GPIO_O_DATA + (GPIO_PIN_0 << 2))) = 0;
}
//*****************************************************************************
//
// The interrupt handler for the SoftUART transmit timer interrupt.
//
//*****************************************************************************
void
Timer0AIntHandler(void)
{
//
// Clear the timer interrupt.
//
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
//
// Call the SoftUART transmit timer tick function.
//
SoftUARTTxTimerTick(&g_sUART);
}
/*---------------------------------------------------------------------------*/
void Timer0IntHandler(void)
{
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
count++;
if(etimer_pending()) {
etimer_request_poll();
}
if (--second_countdown == 0) {
current_seconds++;
second_countdown = CLOCK_SECOND;
}
}
void Throttle_WTimer2BISR(void){
ROM_TimerIntClear(WTIMER2_BASE, TIMER_CAPB_EVENT);
// Doc trang thai canh ngat
if (ROM_GPIOPinRead(GPIO_PORTD_BASE,GPIO_PIN_1)&GPIO_PIN_1)
ui32T_Edgeup_Throttle = ROM_TimerValueGet(WTIMER2_BASE, TIMER_B);
else
{
static int32_t sp=0,pre_sp=0;
if (firstEdgeThrottle)
{
firstEdgeThrottle=0;
return;
}
ui32T_Edgedown_Throttle = ROM_TimerValueGet(WTIMER2_BASE, TIMER_B);
i32DeltaT_Throttle = (int32_t)(ui32T_Edgedown_Throttle - ui32T_Edgeup_Throttle);
if ((i32DeltaT_Throttle<70000) || (i32DeltaT_Throttle>170000))
return;
#ifdef DEBUG_DELTAT_THROTTLE
printStep++;
if (printStep==5)
{
RFprint("Throttle sp:%d\r\n", i32DeltaT_Throttle);
printStep = 0;
}
#endif
sp = (i32DeltaT_Throttle-80000)/PULSE2VEL;
if (sp<0)
sp=0;
else if (sp>1000)
sp=1000;
if ((sp - pre_sp > 2)||(sp - pre_sp < -2))
throttleSet(sp);
pre_sp = sp;
#ifdef DEBUG_THROTTLE_SETPOINT
printStep++;
if (printStep==5)
{
RFprint("Throttle sp:%d\r\n", sp);
printStep = 0;
}
#endif
}
}
//*****************************************************************************
//
// The interrupt handler for the timer interrupt.
//
//*****************************************************************************
void
Timer0IntHandler(void)
{
//
// Clear the timer interrupt.
//
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
//
// Toggle the LED.
//
ROM_GPIOPinWrite(TOGGLE_GPIO_BASE, TOGGLE_GPIO_PIN,
(ROM_GPIOPinRead(TOGGLE_GPIO_BASE, TOGGLE_GPIO_PIN) ^
TOGGLE_GPIO_PIN));
}
//*****************************************************************************
//
// The interrupt handler for the timer interrupt.
//
//*****************************************************************************
void
Timer0IntHandler(void)
{
//
// Clear the timer interrupt.
//
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
//
// Toggle the flag for the timer.
//
HWREGBITW(&g_ulFlags, 0) = 1;
GPIOPinWrite(STP1_BASE, STP1_PLS, STP1_PLS);
SysCtlDelay(SysCtlClockGet() / 500000);
GPIOPinWrite(STP1_BASE, STP1_PLS, 0x00);
}
void Timer5ISR(void)
{
static uint8_t NumSpdSet = 0;
static int32_t SpeedLeft, SpeedRight;
ROM_TimerIntClear(TIMER5_BASE, TIMER_TIMA_TIMEOUT);
SpeedLeft = ROM_QEIVelocityGet(QEI0_BASE) * ROM_QEIDirectionGet(QEI0_BASE);
SpeedRight = ROM_QEIVelocityGet(QEI1_BASE) * ROM_QEIDirectionGet(QEI1_BASE);
PosLeftCount = ((int32_t)ROM_QEIPositionGet(QEI0_BASE)) / 2;
PosRightCount = ((int32_t)ROM_QEIPositionGet(QEI1_BASE)) / 2;
#ifdef PID_SPEED
UARTPutn(UART_Bluetooth.PortName, (int32_t)SpeedLeft);
UARTCharPut(UART_Bluetooth.PortName, '\n');
#endif
#ifdef PID_POSITION
UARTPutn(UART_Bluetooth.PortName, (int32_t)PosLeftCount);
UARTCharPut(UART_Bluetooth.PortName, '\n');
#endif
if (PIDVerLeft.Enable)
{
PIDVerCalc(&PIDVerLeft, &SpeedLeft, 90);
SetPWM(MOTOR_LEFT, DEFAULT, (long)PIDVerLeft.PIDResult);
}
if (PIDVerRight.Enable)
{
PIDVerCalc(&PIDVerRight, &SpeedRight, 90);
SetPWM(MOTOR_RIGHT, DEFAULT, (long)PIDVerRight.PIDResult);
}
NumSpdSet++;
if (NumSpdSet == PIDVerLoop) //PID position
{
NumSpdSet = 0;
if (PIDPosLeft.Enable)
{
PIDPosCalc(&PIDPosLeft, PosLeftCount, avrSpeed);
PIDSpeedSet(&PIDVerLeft, (long)PIDPosLeft.PIDResult);
}
if (PIDPosRight.Enable)
{
PIDPosCalc(&PIDPosRight, PosRightCount, avrSpeed);
PIDSpeedSet(&PIDVerRight, (long)PIDPosRight.PIDResult);
}
}
}