////////////////////////////////////////////////////////////////////////
// Functions
//---------------------------------------------------------------------
//IC1Setup -- This function configures the Input Capture 1 register. During
//execution of the code, the setup for each IC will change depending on the current
//state.
void IC1_Config(void)
{
#if DEBUG>0
printf("Loading Interrupt Capture...");
#endif
//Enable IC1, Interrupt on, Pri to 6
ConfigIntCapture1(IC_INT_PRIOR_6 & IC_INT_ON);
ConfigIntCapture3(IC_INT_PRIOR_6 & IC_INT_ON);
//Configuration options
//----Idle while in stop
//----Use Timer 3 as timing source
//----Interrupt on the first capture
//----Capture on every edge
OpenCapture1(IC_IDLE_STOP & IC_TIMER3_SRC & IC_INT_1CAPTURE & IC_EVERY_EDGE);
OpenCapture3(IC_IDLE_STOP & IC_TIMER3_SRC & IC_INT_1CAPTURE & IC_EVERY_FALL_EDGE);
#if DEBUG>0
printf("DONE\r\n");
#endif
return;
}
int main(void)
{
uint16_t i;
FRESULT rc;
map_io();
init_port();
InitRTCC();
uart2_init();
xdev_out(uart2_put);
xdev_in(uart2_get);
dbg_printf("$" PROJECT_NAME "\n");
dbg_printf("$" __DATE__ " " __TIME__ "\n");
rc = f_mount(&fatfs, "", 1);
dbg_printf("$FF,f_mount,%s\n", get_rc(rc));
OpenTimer1(T1_PS_1_256 & T1_GATE_OFF & T1_SOURCE_INT & T1_IDLE_CON &
T1_ON & T1_SYNC_EXT_OFF, 0xFFFF);
ConfigIntTimer1(T1_INT_ON & T1_INT_PRIOR_1);
OpenCapture1(IC_IDLE_STOP & IC_TIMER1_SRC & IC_INT_1CAPTURE & IC_EVERY_RISE_EDGE,
IC_CASCADE_DISABLE & IC_TRIGGER_ENABLE & IC_UNTRIGGER_TIMER & IC_SYNC_TRIG_IN_DISABLE);
ConfigIntCapture1(IC_INT_ON & IC_INT_PRIOR_5);
_IC1IF = 0;
while (1) {
while (_RTCSYNC == 0);
while (_RTCSYNC == 1);
if (gps_pr > 0) {
_T1IE = 0;
float f = (float) TMR1 / gps_pr;
_T1IE = 1;
xprintf("%u\n", (uint16_t) (f * 1000));
}
if (ngpslines > 0) {
ngpslines--;
if (xgets(gps_line, 128)) {
xprintf("$GPS%s\n", gps_line);
}
}
}
while (0) {
while (_RTCSYNC == 0);
while (_RTCSYNC == 1);
if (gps_pr > 0) {
_T1IE = 0;
float f = (float) TMR1 / gps_pr;
_T1IE = 1;
xprintf("%u\n", (uint16_t) (f * 1000));
}
}
return (EXIT_SUCCESS);
}
void Setup_configInterrupts(void)
{
ConfigIntCapture1(IC_INT_ON | IC_INT_PRIOR_6);
ConfigIntCapture2(IC_INT_ON | IC_INT_PRIOR_6);
ConfigIntCapture3(IC_INT_ON | IC_INT_PRIOR_6);
ConfigIntCapture4(IC_INT_ON | IC_INT_PRIOR_6);
ConfigIntCapture5(IC_INT_ON | IC_INT_PRIOR_6);
}
//===================== Main ======================= //
void main(void) {
SYSTEMConfig( SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
ANSELA = 0; ANSELB = 0; CM1CON = 0; CM2CON = 0;
PT_setup();
INTEnableSystemMultiVectoredInt();
// initialize the threads
PT_INIT(&pt_blink);
PT_INIT(&pt_capture);
// initialize the display
tft_init_hw();
tft_begin();
tft_fillScreen(ILI9340_BLACK);
tft_setRotation(0); //240x320 vertical display
// initialize the comparator
CMP1Open(CMP_ENABLE | CMP_OUTPUT_ENABLE | CMP1_NEG_INPUT_IVREF);
// initialize the timer2
OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_64, 0xffffffff);
// initialize the input capture, uses timer2
OpenCapture1( IC_EVERY_RISE_EDGE | IC_FEDGE_RISE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON);
ConfigIntCapture1(IC_INT_ON | IC_INT_PRIOR_3 | IC_INT_SUB_PRIOR_3 );
INTClearFlag(INT_IC1);
// initialize the input/output I/O
mPORTBSetPinsDigitalOut(BIT_3);
mPORTBClearBits(BIT_3);
PPSOutput(4, RPB9, C1OUT); //set up output of comparator for debugging
PPSInput(3, IC1, RPB13); //Either Pin 6 or Pin 24 idk
//round-robin scheduler for threads
while(1) {
PT_SCHEDULE(protothread_blink(&pt_blink));
PT_SCHEDULE(protothread_capture(&pt_capture));
}
} //main
int main(void)
{
//LOCALS
unsigned int temp;
unsigned int channel1, channel2;
M1_stepPeriod = M2_stepPeriod = M3_stepPeriod = M4_stepPeriod = 50; // in tens of u-seconds
unsigned char M1_state = 0, M2_state = 0, M3_state = 0, M4_state = 0;
SYSTEMConfig(GetSystemClock(), SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
/* TIMER1 - now configured to interrupt at 10 khz (every 100us) */
OpenTimer1(T1_ON | T1_SOURCE_INT | T1_PS_1_1, T1_TICK);
ConfigIntTimer1(T1_INT_ON | T1_INT_PRIOR_2);
/* TIMER2 - 100 khz interrupt for distance measure*/
OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_1, T2_TICK);
ConfigIntTimer2(T2_INT_ON | T2_INT_PRIOR_3); //It is off until trigger
/* PORTA b2 and b3 for servo-PWM */
mPORTAClearBits(BIT_2 | BIT_3);
mPORTASetPinsDigitalOut(BIT_2 | BIT_3);
/* ULTRASONICS: some bits of PORTB for ultrasonic sensors */
PORTResetPins(IOPORT_B, BIT_8 | BIT_9| BIT_10 | BIT_11 );
PORTSetPinsDigitalOut(IOPORT_B, BIT_8 | BIT_9| BIT_10 | BIT_11); //trigger
/* Input Capture pins for echo signals */
//interrupt on every risging/falling edge starting with a rising edge
PORTSetPinsDigitalIn(IOPORT_D, BIT_8| BIT_9| BIT_10| BIT_11); //INC1, INC2, INC3, INC4 Pin
mIC1ClearIntFlag();
OpenCapture1( IC_EVERY_EDGE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON );//front
ConfigIntCapture1(IC_INT_ON | IC_INT_PRIOR_4 | IC_INT_SUB_PRIOR_3);
OpenCapture2( IC_EVERY_EDGE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON );//back
ConfigIntCapture2(IC_INT_ON | IC_INT_PRIOR_4 | IC_INT_SUB_PRIOR_3);
OpenCapture3( IC_EVERY_EDGE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON );//left
ConfigIntCapture3(IC_INT_ON | IC_INT_PRIOR_4 | IC_INT_SUB_PRIOR_3);
OpenCapture4( IC_EVERY_EDGE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON );//right
ConfigIntCapture4(IC_INT_ON | IC_INT_PRIOR_4 | IC_INT_SUB_PRIOR_3);
/* PINS used for the START (RD13) BUTTON */
PORTSetPinsDigitalIn(IOPORT_D, BIT_13);
#define CONFIG (CN_ON | CN_IDLE_CON)
#define INTERRUPT (CHANGE_INT_ON | CHANGE_INT_PRI_2)
mCNOpen(CONFIG, CN19_ENABLE, CN19_PULLUP_ENABLE);
temp = mPORTDRead();
/* PORT D and E for motors */
//motor 1
mPORTDSetBits(BIT_4 | BIT_5 | BIT_6 | BIT_7); // Turn on PORTD on startup.
mPORTDSetPinsDigitalOut(BIT_4 | BIT_5 | BIT_6 | BIT_7); // Make PORTD output.
//motor 2
mPORTCSetBits(BIT_1 | BIT_2 | BIT_3 | BIT_4); // Turn on PORTC on startup.
mPORTCSetPinsDigitalOut(BIT_1 | BIT_2 | BIT_3 | BIT_4); // Make PORTC output.
//motor 3 and 4
mPORTESetBits(BIT_0 | BIT_1 | BIT_2 | BIT_3 |
BIT_4 | BIT_5 | BIT_6 | BIT_7); // Turn on PORTE on startup.
mPORTESetPinsDigitalOut(BIT_0 | BIT_1 | BIT_2 | BIT_3 |
BIT_4 | BIT_5 | BIT_6 | BIT_7); // Make PORTE output.
// UART2 to connect to the PC.
// This initialization assumes 36MHz Fpb clock. If it changes,
// you will have to modify baud rate initializer.
UARTConfigure(UART2, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(UART2, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(UART2, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(UART2, GetPeripheralClock(), BAUD);
UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
// Configure UART2 RX Interrupt
INTEnable(INT_SOURCE_UART_RX(UART2), INT_ENABLED);
INTSetVectorPriority(INT_VECTOR_UART(UART2), INT_PRIORITY_LEVEL_2);
INTSetVectorSubPriority(INT_VECTOR_UART(UART2), INT_SUB_PRIORITY_LEVEL_0);
/* PORTD for LEDs - DEBUGGING */
mPORTDClearBits(BIT_0 | BIT_1 | BIT_2);
mPORTDSetPinsDigitalOut(BIT_0 | BIT_1 | BIT_2);
// Congifure Change/Notice Interrupt Flag
ConfigIntCN(INTERRUPT);
// configure for multi-vectored mode
INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
// enable interrupts
INTEnableInterrupts();
counterDistanceMeasure=600; //measure ULTRASONICS distance each 60 ms
while (1) {
/***************** Robot MAIN state machine *****************/
unsigned char ret = 0;
switch (Robo_State) {
case 0:
MotorsON = 0;
Robo_State = 0;
InvInitialOrientation(RESET);
TestDog(RESET);
GoToRoom4short(RESET);
BackToStart(RESET);
InitialOrientation(RESET);
GoToCenter(RESET);
GoToRoom4long(RESET);
break;
case 1:
ret = InvInitialOrientation(GO);
if (ret == 1) {
Robo_State = 2;
}
break;
case 2:
ret = TestDog(GO);
if (ret == 1) {
Robo_State = 3; //DOG not found
} else if (ret == 2) {
Robo_State = 4; //DOG found
}
break;
case 3:
ret = GoToRoom4short(GO);
if (ret == 1) {
Robo_State = 0;
}
break;
case 4:
ret = BackToStart(GO);
if (ret == 1) {
Robo_State = 5;
}
break;
case 5:
ret = GoToCenter(GO);
if (ret == 1) {
Robo_State = 6;
}
break;
case 6:
ret = GoToRoom4long(GO);
if (ret == 1) {
Robo_State = 0;
}
break;
}
if (frontDistance < 30 || backDistance < 30 || leftDistance < 30 || rightDistance < 30)
mPORTDSetBits(BIT_0);
else
mPORTDClearBits(BIT_0);
/***************************************************************/
/***************** Motors State Machine ************************/
if (MotorsON) {
/****************************
MOTOR MAP
M1 O-------------O M2 ON EVEN MOTORS, STEPS MUST BE INVERTED
| /\ | i.e. FORWARD IS BACKWARD
| / \ |
| || |
| || |
M3 O-------------O M4
*****************************/
if (M1_counter == 0) {
switch (M1_state) {
case 0: // set 0011
step (0x3 , 1);
if (M1forward)
M1_state = 1;
else
M1_state = 3;
break;
case 1: // set 1001
step (0x9 , 1);
if (M1forward)
M1_state = 2;
else
M1_state = 0;
break;
case 2: // set 1100
step (0xC , 1);
if (M1forward)
M1_state = 3;
else
M1_state = 1;
break;
case 3: // set 0110
default:
step (0x6 , 1);
if (M1forward)
M1_state = 0;
else
M1_state = 2;
break;
}
M1_counter = M1_stepPeriod;
step_counter[0]--;
if (directionNow == countingDirection)
step_counter[1]--;
}
if (M2_counter == 0) {
switch (M2_state) {
case 0: // set 0011
step (0x3 , 2);
if (M2forward)
M2_state = 1;
else
M2_state = 3;
break;
case 1: // set 0110
step (0x6 , 2);
if (M2forward)
M2_state = 2;
else
M2_state = 0;
break;
case 2: // set 1100
step (0xC , 2);
if (M2forward)
M2_state = 3;
else
M2_state = 1;
break;
case 3: // set 1001
default:
step (0x9 , 2);
if (M2forward)
M2_state = 0;
else
M2_state = 2;
break;
}
M2_counter = M2_stepPeriod;
}
if (M3_counter == 0) {
switch (M3_state) {
case 0: // set 0011
step (0x3 , 3);
if (M3forward)
M3_state = 1;
else
M3_state = 3;
break;
case 1: // set 1001
step (0x9 , 3);
if (M3forward)
M3_state = 2;
else
M3_state = 0;
break;
case 2: // set 1100
step (0xC , 3);
if (M3forward)
M3_state = 3;
else
M3_state = 1;
break;
case 3: // set 0110
default:
step (0x6 , 3);
if (M3forward)
M3_state = 0;
else
M3_state = 2;
break;
}
M3_counter = M3_stepPeriod;
}
if (M4_counter == 0) {
switch (M4_state) {
case 0: // set 0011
step (0x3 , 4);
if (M4forward)
M4_state = 1;
else
M4_state = 3;
break;
case 1: // set 0110
step (0x6 , 4);
if (M4forward)
M4_state = 2;
else
M4_state = 0;
break;
case 2: // set 1100
step (0xC , 4);
if (M4forward)
M4_state = 3;
else
M4_state = 1;
break;
case 3: // set 1001
default:
step (0x9 , 4);
if (M4forward)
M4_state = 0;
else
M4_state = 2;
break;
}
M4_counter = M4_stepPeriod;
}
} else {
//motors off
mPORTDSetBits(BIT_4 | BIT_5 | BIT_6 | BIT_7);
mPORTCSetBits(BIT_1 | BIT_2 | BIT_3 | BIT_4);
mPORTESetBits(BIT_0 | BIT_1 | BIT_2 | BIT_3 |
BIT_4 | BIT_5 | BIT_6 | BIT_7);
}
/************************************************************/
/******* TEST CODE, toggles the servos (from 90 deg. to -90 deg.) every 1 s. ********/
/* if (auxcounter == 0) {
servo1_angle = 0;
if (servo2_angle == 90)
servo2_angle = -90;
else
servo2_angle = 90;
auxcounter = 20000; // toggle angle every 2 s.
}
*/
servo1_angle = 0;
servo2_angle = -90;
/*
if (frontDistance > 13 && frontDistance < 17) {
servo2_angle = 90;
}
else
servo2_angle = -90;
*/
/*******************************************************************/
/****************** SERVO CONTROL ******************/
/*
Changing the global servoX_angle at any point in the code will
move the servo to the desired angle.
*/
servo1_counter = (servo1_angle + 90)*(18)/180 + 6; // between 600 and 2400 us
if (servo1_period == 0) {
mPORTASetBits(BIT_2);
servo1_period = SERVOMAXPERIOD; /* 200 * 100us = 20000us period */
}
servo2_counter = (servo2_angle + 90)*(18)/180 + 6; // between 600 and 2400 us
if (servo2_period == 0) {
mPORTASetBits(BIT_3);
servo2_period = SERVOMAXPERIOD; /* 200 * 100us = 20000us period */
}
/*****************************************************/
} /* end of while(1) */
return 0;
}
int main(void)
{
/*** LOCAL VARIABLES ***/
unsigned int period , period2, config1=0 ,config2=0;
Int_flag = 0;
/*** CONFIGURE OSCILLATOR ***/
SET_FreqOsc( FRCDIV_1MHZ ); //Set Frequency
/*** CONFIGURE HARDWARE ****/
Hardware_INIT(); //Initialise Hardware functions
LCD_INIT();
//NOTE: PPS Unlock & Lock Sequence not required when Using Hardware.ConfigPins_Default()
__builtin_write_OSCCONL(OSCCON & 0xbf); //UNLCOK PPS
// Hardware.ConfigPins_PWM(USE1 | USE2 | USE4 | USE3 ); //Configure the PWM Pins to use
PWM4_DIR = DIR_OUT; // Set PWM4 as Output
PWM4 = C_OFF;
iPPSInput(IN_FN_PPS_IC1, IN_PIN_PPS_RP10);
iPPSOutput(OUT_PIN_PPS_RP12, OUT_FN_PPS_OC1);
iPPSOutput(OUT_PIN_PPS_RP11, OUT_FN_PPS_OC9);
__builtin_write_OSCCONL(OSCCON | 0x40); //LOCK PPS
Int_flag = 0;
// timers
T1CON = 0x8000;
T2CON = 0x8000;
T1CONbits.TCKPS = 0b00;
T2CONbits.TCKPS = 0b01;
T3CON = 0x8000;
T4CON = 0x8000;
T4CONbits.TCKPS = 0b01;
// input capture
ConfigIntCapture1(IC_INT_ON | IC_INT_PRIOR_4);
config1 = IC_IDLE_STOP | IC_TIMER2_SRC | IC_INT_1CAPTURE | IC_EVERY_EDGE;
config2 = IC_CASCADE_DISABLE /*| IC_SYNC_ENABLE | IC_SYNC_TRIG_IN_TMR2*/;
OpenCapture1_GB(config1, config2);
// output compare
EnableIntOC9;
OC9R = 0x5FF0;
OC9RS = 0x5FF4;
OC9CON1bits.OCTSEL = 0b000;
OC9CON2bits.SYNCSEL = 0x1F;
OC9CON1bits.OCM = 0b110;
OC9CON2bits.OCINV = 1;
// PR1 = 2000;// period for timer 1
// PR2 = 0xFFFF;
// IFS0bits.IC1IF = 0; // Clear the IC1 interrupt status flag
// IEC0bits.IC1IE = 1; // Enable IC1 interrupts
// IPC0bits.IC1IP = 1; // Set module interrupt priority as 1
// IC1CON1 = 0x1C24;
// IC1CON2 = 0x0040;
// IC1CON1bits.ICSIDL = 0; //Continue in idle mode
// IC1CON1bits.ICI = 0b00; //Interrupt on every capture
// IC1CON1bits.ICM = 0b001; //Every edge
// EnableIntIC1;
/*** INITIALIZE PERIPHERAL ***/
// TIMER3_INIT( 1000, TMR_INT_PRI7 );
PWM1_INIT(PWMsrc_FOSC, 20); //Set PWM Period of 20 mSec
// PWM3_INIT(PWMsrc_Timer1, 100); //Set PWM Period of 1000 mSec
// PWM3_INIT(PWMsrc_FOSC, 30);
/*** APPLICATION CODE BEGINS ***/
// PWM3_SET_PulseWidth(1);
PWM1_SET_PulseWidth(1.3);
// PWM3_SET_PulseWidth(10);
//Set PWM1 Dutycycle Time 5 mSec
//To Test, Probe the Pin1 of PWM connector J7
LED1_DIR = DIR_OUT; // Set LED1 as Output
LED1 = C_OFF;
LED2_DIR = DIR_OUT; // Set LED1 as Output
LED2 = C_OFF;
LED3_DIR = DIR_OUT; // Set LED1 as Output
LED3 = C_OFF;
/*** ENTER ETERNITY ***/
int buf[100];
Int_flag = 2;
//LOCK PPS
while (1) {
// while (!read_enable);
//wait till two succssive falling edges
// M_ToggleIO(LED1);
// period = timer_second_edge - timer_first_edge;
// period2 = 65535 + timer_first_edge - timer_second_edge;
int j;
for(j=1;j<5;j++){
if(edge_buffer[j+1] - edge_buffer[j] > 30){
if(edge_buffer[j+1] - edge_buffer[j] < 500){
pulse = edge_buffer[j+1] - edge_buffer[j];
break;
}else{
pulse = 11111;
}
}else{
pulse = 11111;
}
}
if(pulse != 11111){
LCD_Clear();
sprintf(A_Str_U8, "%u", pulse); // Print variable to string
LCD_WriteString(1, 1, A_Str_U8);
}
// sprintf(A_Str_U8, "%u", timer_second_edge); // Print variable to string
// LCD_WriteString(1, 8, A_Str_U8);
// sprintf(A_Str_U8, "%u", abs(timer_second_edge - timer_first_edge)); // Print variable to string
// LCD_WriteString(2, 1, A_Str_U8);
// sprintf(A_Str_U8, "%u", abs(timer_third_edge - timer_second_edge)); // Print variable to string
// LCD_WriteString(2, 7, A_Str_U8);
// DELAY_mSec(100);
// sprintf(A_Str_U8, "%d", Interrupt_Count); // Print variable to string
// LCD_WriteString(2, 8, A_Str_U8);
// Int_flag = 0;
read_enable = 0;
// __builtin_write_OSCCONL(OSCCON & 0xbf);
// iPPSOutput(OUT_PIN_PPS_RP10, OUT_FN_PPS_OC4);
// __builtin_write_OSCCONL(OSCCON | 0x40);
//
// PWM4 = C_OFF;
// PWM4 = C_ON;
// PWM4 = C_OFF;
// DELAY_mSec(200);
// DELAY_mSec(200);
// LATEbits.LATE5 = 1;
// DELAY_mSec(500);
// LATEbits.LATE5 = 0;
// ReadCapture1_v4(buf) ;
/*** RECURRING CODE HERE***/
//Use TIMER Interrupts to perform time based tasks at fixed interval.
//Use Peripheral Interrupts to perform event based tasks
int i;
for (i = 40; i < 100; i++) {
PWM1_SET_PulseWidth(0.02 * i);
DELAY_mSec(20);
}
while (i>=40) {
PWM1_SET_PulseWidth(0.02 * i);
DELAY_mSec(20);
i--;
}
}
}
