/*******************************************************************************
* FILE NAME: ifi_startup.c
*
* DESCRIPTION:
* This file contains important startup code.
*
* USAGE:
* This file should not be modified at all by the user.
*
* DO NOT MODIFY THIS FILE!
*******************************************************************************/
#include "ifi_default.h"
extern void Clear_Memory (void);
extern void main (void);
void _entry (void); /* prototype for the startup function */
void _startup (void);
void _do_cinit (void); /* prototype for the initialized data setup */
extern volatile near unsigned long short TBLPTR;
extern near unsigned FSR0;
extern near char FPFLAGS;
#define RND 6
#pragma code _entry_scn=RESET_VECTOR
void _entry (void)
{
_asm goto _startup _endasm
}
#pragma code _startup_scn
void _startup (void)
{
_asm
/* Initialize the stack pointer */
lfsr 1, _stack lfsr 2, _stack clrf TBLPTRU, 0 /* 1st silicon doesn't do this on POR */
bcf FPFLAGS,RND,0 /* Initialize rounding flag for floating point libs */
/* initialize the flash memory access configuration. this is harmless */
/* for non-flash devices, so we do it on all parts. */
bsf 0xa6, 7, 0
bcf 0xa6, 6, 0
_endasm
loop:
Clear_Memory();
_do_cinit ();
/* Call the user's main routine */
main ();
goto loop;
} /* end _startup() */
/* MPLAB-C18 initialized data memory support */
/* The linker will populate the _cinit table */
extern far rom struct
{
unsigned short num_init;
struct _init_entry
{
unsigned long from;
unsigned long to;
unsigned long size;
}
entries];
}
_cinit;
#pragma code _cinit_scn
void
_do_cinit (void)
{
/* we'll make the assumption in the following code that these statics
* will be allocated into the same bank.
*/
static short long prom;
static unsigned short curr_byte;
static unsigned short curr_entry;
static short long data_ptr;
/* Initialized data... */
TBLPTR = (short long)&_cinit;
_asm
movlb data_ptr
tblrdpostinc
movf TABLAT, 0, 0
movwf curr_entry, 1
tblrdpostinc
movf TABLAT, 0, 0
movwf curr_entry+1, 1
_endasm
test:
_asm
bnz 3
tstfsz curr_entry, 1
bra 1
_endasm
goto done;
/* Count down so we only have to look up the data in _cinit
* once.
*
* At this point we know that TBLPTR points to the top of the current
* entry in _cinit, so we can just start reading the from, to, and
* size values.
*/
_asm
/* read the source address */
tblrdpostinc
movf TABLAT, 0, 0
movwf prom, 1
tblrdpostinc
movf TABLAT, 0, 0
movwf prom+1, 1
tblrdpostinc
movf TABLAT, 0, 0
movwf prom+2, 1
/* skip a byte since it's stored as a 32bit int */
tblrdpostinc
/* read the destination address directly into FSR0 */
tblrdpostinc
movf TABLAT, 0, 0
movwf FSR0L, 0
tblrdpostinc
movf TABLAT, 0, 0
movwf FSR0H, 0
/* skip two bytes since it's stored as a 32bit int */
tblrdpostinc
tblrdpostinc
/* read the destination address directly into FSR0 */
tblrdpostinc
movf TABLAT, 0, 0
movwf curr_byte, 1
tblrdpostinc
movf TABLAT, 0, 0
movwf curr_byte+1, 1
/* skip two bytes since it's stored as a 32bit int */
tblrdpostinc
tblrdpostinc
_endasm
/* the table pointer now points to the next entry. Save it
* off since we'll be using the table pointer to do the copying
* for the entry.
*/
data_ptr = TBLPTR;
/* now assign the source address to the table pointer */
TBLPTR = prom;
/* do the copy loop */
_asm
/* determine if we have any more bytes to copy */
movlb curr_byte
movf curr_byte, 1, 1
copy_loop:
bnz 2 /* copy_one_byte */
movf curr_byte + 1, 1, 1
bz 7 /* done_copying */
copy_one_byte:
tblrdpostinc
movf TABLAT, 0, 0
movwf POSTINC0, 0
/* decrement byte counter */
decf curr_byte, 1, 1
bc -8 /* copy_loop */
decf curr_byte + 1, 1, 1
bra -7 /* copy_one_byte */
done_copying:
_endasm
/* restore the table pointer for the next entry */
TBLPTR = data_ptr;
/* next entry... */
curr_entry--;
goto test;
done:
;
}
/*******************************************************************************
* FILE NAME: ifi_utilities.c
*
* DESCRIPTION:
* This file contains some useful functions that you can call in your program.
*
* USAGE:
* The user should NOT modify this file, so that if a new version is released
* by Innovation First then it can be easily replaced.
* The user should add their own functions to either user_routines.c or another
* custom file.
*
*******************************************************************************/
#include <usart.h>
#include <spi.h>
#include <adc.h>
#include <capture.h>
#include <timers.h>
#include <string.h>
#include <pwm.h>
#include "delays.h" /*defined locally*/
#include "ifi_aliases.h"
#include "ifi_default.h"
#include "ifi_utilities.h"
#include "user_routines.h"
int ifi_packet_num1 = 0;
int ifi_last_packet1 = 0;
char ifi_printfBufr[80];
unsigned char *ptr;
unsigned char ifi_count;
unsigned char ifi_analog_channels;
/*******************************************************************************
* FUNCTION NAME: Wait4TXEmpty
* PURPOSE: Wait for serial transmit buffer to be empty.
* CALLED FROM: anywhere
* ARGUMENTS: none
* RETURNS: void
*******************************************************************************/
/* Used when transmitting data serially. It waits for each byte to finish. */
void Wait4TXEmpty(void)
{
#ifndef _SIMULATOR
while (!TXINTF)
{
continue;
}
#endif
}
/*******************************************************************************
* FUNCTION NAME: PrintByte
* PURPOSE: A simple way to print a byte of data to the serial port.
* CALLED FROM: anywhere
* ARGUMENTS: none
* Argument Type IO Description
* -------- ------------- -- -----------
* odata unsigned char I byte of data to be transmitted
* RETURNS: void
*******************************************************************************/
void PrintByte(unsigned char odata)
{
Hex_output((unsigned char) odata);
TXREG = 13; /* a carriage return */
Wait4TXEmpty();
}
/*******************************************************************************
* FUNCTION NAME: PrintWord
* PURPOSE: A simple way to print a word of data to the serial port.
* CALLED FROM: anywhere
* ARGUMENTS: none
* Argument Type IO Description
* -------- ------------- -- -----------
* odata unsigned int I word of data to be transmitted
* RETURNS: void
*******************************************************************************/
void PrintWord(unsigned int odata)
{
ptr = (unsigned char *) &odata;
Hex_output(ptr[1]);
Hex_output(ptr[0]);
TXREG = 13; /* add a carriage return */
Wait4TXEmpty();
}
/*******************************************************************************
* FUNCTION NAME: PrintString
* PURPOSE: Prints a string to the serial port.
* CALLED FROM: anywhere
* ARGUMENTS: none
* Argument Type IO Description
* -------- ------------- -- -----------
* bufr pointer I word of data to be transmitted
* RETURNS: void
*******************************************************************************/
void PrintString(char *bufr)
{
static int len,I;
strcpypgm2ram (ifi_printfBufr,(rom char *) bufr); /*Move from flash to ram*/
len = (int) strlen((const char *)ifi_printfBufr);
if (len > 80) len = 80;
for (I=0;I<len;I++)
{
TXREG = ifi_printfBufr*;
Wait4TXEmpty();
}
}
/*******************************************************************************
* FUNCTION NAME: DisplayBufr
* PURPOSE: Print the entire transmit or receive buffer over the serial
* port for viewing in a terminal program on your PC.
* CALLED FROM: anywhere
* ARGUMENTS:
* Argument Type IO Description
* -------- -------- -- -----------
* *bufr pointer I points to beginning of buffer to transmit
* RETURNS: void
*******************************************************************************/
void DisplayBufr(unsigned char *bufr)
{
for (ifi_count=0;ifi_count<26;ifi_count++)
{
Hex_output((unsigned char) *bufr++);
}
TXREG = 13; /* add a carriage return */
Wait4TXEmpty();
}
/*******************************************************************************
* FUNCTION NAME: PacketNum_Check
* PURPOSE: Print the packet number over the serial port if a packet gets
* dropped. Handy for seeing if you are dropping data.
* CALLED FROM: anywhere
* ARGUMENTS: none
* RETURNS: void
*******************************************************************************/
void PacketNum_Check(void)
{
/* to print only the 10th (packet num) byte*/
ptr = (unsigned char *) &rxdata.packet_num;
ifi_packet_num1 = (int) rxdata.packet_num;
if (ifi_packet_num1 != ifi_last_packet1)
{
if (statusflag.FIRST_TIME == 1)
{
statusflag.FIRST_TIME = 0;
}
else
{
Hex_output((unsigned char) ifi_last_packet1);
Hex_output((unsigned char) ifi_packet_num1);
TXREG = 13;
Wait4TXEmpty();
statusflag.FIRST_TIME = 0;
}
ifi_last_packet1 = ifi_packet_num1;
}/* if (ifi_packet_num1 != ifi_last_packet1)*/
ifi_last_packet1++;
if (ifi_last_packet1 > 255)
{
ifi_last_packet1 = 0;
}
}
/*******************************************************************************
* FUNCTION NAME: Initialize_Serial_Comms
* PURPOSE: Opens the serial port 1 for communicating with your PC at
* 115k baud, 8 bits, no parity, one stop bit, and no flow control.
* CALLED FROM: user_routines.c
* ARGUMENTS: none
* RETURNS: void
*******************************************************************************/
void Initialize_Serial_Comms (void)
{
OpenUSART(USART_TX_INT_OFF &
USART_RX_INT_OFF &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_CONT_RX &
USART_BRGH_HIGH,
baud_115);
Delay1KTCYx( 50 ); /* Settling time */
}
/*******************************************************************************
* FUNCTION NAME: Set_Number_of_Analog_Channels
* PURPOSE: Sets the variable used in Get_Analog_Value routine (below)
* to the number of analog channels desired by the user.
* CALLED FROM: user_routines.c initialization, typically
* ARGUMENTS:
* Argument Type IO Description
* ----------- ----- -- -----------
* number_of_channels alias I choose alias from ifi_aliases.h
* RETURNS: void
*******************************************************************************/
void Set_Number_of_Analog_Channels (unsigned char number_of_channels)
{
ifi_analog_channels = number_of_channels;
}
/*******************************************************************************
* FUNCTION NAME: Get_Analog_Value
* PURPOSE: Reads the analog voltage on an A/D port and returns the
* 10-bit value read stored in an unsigned int.
* CALLED FROM: user_routines.c, typically
* ARGUMENTS:
* Argument Type IO Description
* ----------- ------------- -- -----------
* ADC_channel alias I alias found in ifi_aliases.h
* RETURNS: unsigned int
*******************************************************************************/
unsigned int Get_Analog_Value (unsigned char ADC_channel)
{
unsigned int result;
OpenADC( ADC_FOSC_RC & ADC_RIGHT_JUST & ifi_analog_channels,
ADC_channel & ADC_INT_OFF & ADC_VREFPLUS_VDD & ADC_VREFMINUS_VSS );
Delay10TCYx( 10 );
ConvertADC();
while( BusyADC() );
ReadADC();
CloseADC();
result = (int) ADRESH << 8 | ADRESL;
return result;
}
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/*******************************************************************************
* FILE NAME: user_routines_fast.c
*
* DESCRIPTION:
* This file is where the user can add their custom code within the framework
* of the routines below.
*
* USAGE:
* You can either modify this file to fit your needs, or remove it from your
* project and replace it with a modified copy.
*
* OPTIONS: Interrupts are disabled and not used by default.
*******************************************************************************/
#include "ifi_aliases.h"
#include "ifi_default.h"
#include "ifi_utilities.h"
#include "user_routines.h"
#include "receiver.h"
#include "tracker.h"
#include "navigate.h"
/*** DEFINE USER VARIABLES AND INITIALIZE THEM HERE ***/
/*******************************************************************************
* FUNCTION NAME: InterruptVectorLow
* PURPOSE: Low priority interrupt vector
* CALLED FROM: nowhere by default
* ARGUMENTS: none
* RETURNS: void
* DO NOT MODIFY OR DELETE THIS FUNCTION
*******************************************************************************/
#pragma code InterruptVectorLow = LOW_INT_VECTOR
void InterruptVectorLow (void)
{
_asm
goto InterruptHandlerLow /*jump to interrupt routine*/
_endasm
}
/*******************************************************************************
* FUNCTION NAME: InterruptHandlerLow
* PURPOSE: Low priority interrupt handler
* If you want to use these external low priority interrupts or any of the
* peripheral interrupts then you must enable them in your initialization
* routine. Innovation First, Inc. will not provide support for using these
* interrupts, so be careful. There is great potential for glitchy code if good
* interrupt programming practices are not followed. Especially read p. 28 of
* the "MPLAB(R) C18 C Compiler User's Guide" for information on context saving.
* CALLED FROM: this file, InterruptVectorLow routine
* ARGUMENTS: none
* RETURNS: void
*******************************************************************************/
#pragma code
#pragma interruptlow InterruptHandlerLow
void InterruptHandlerLow ()
{
unsigned char Port_B;
unsigned char Port_B_Delta;
static unsigned char Old_Port_B = 0xFF; // state of port b the last time
// this function was called
if (INTCONbits.TMR0IF) // timer 0 Interrupt
{
INTCONbits.TMR0IF = 0; // clear the interrupt flag
// if used, call the timer 0 interrupt handler here
}
else if (PIR1bits.TMR1IF) // timer 1 interrupt - used by the IR receiver
{
PIR1bits.TMR1IF = 0; // clear the interrupt flag
Timer_1_Int_Handler(); // call the timer 1 interrupt handler (in receiver.c)
}
else if (INTCON3bits.INT2IF) // external interrupt 1 - used by IR sensor 1
{
INTCON3bits.INT2IF = 0; // clear the interrupt flag
Int_1_Handler(); // call the IR sensor 1 interrupt handler (in receiver.c)
}
else if (INTCON3bits.INT3IF) // external interrupt 2 - used by IR sensor 2
{
INTCON3bits.INT3IF = 0; // clear the interrupt flag
Int_2_Handler(); // call the IR sensor 2 interrupt handler (in receiver.c)
}
else if (INTCONbits.RBIF) // external interrupts 3 through 6
{
Port_B = PORTB; // remove the "mismatch condition" by reading port b
INTCONbits.RBIF = 0; // clear the interrupt flag
Port_B_Delta = Port_B ^ Old_Port_B; // determine which bits have changed
Old_Port_B = Port_B; // save a copy of port b for next time around
if(Port_B_Delta & 0x10) // did external interrupt 3 change state?
{
// if used, call the interrupt 3 handler here
}
if(Port_B_Delta & 0x20) // did external interrupt 4 change state? - IR sensor 3
{
Int_4_Handler(Port_B & 0x20 ? 1 : 0); // call the interrupt 4 handler (in receiver.c)
}
if(Port_B_Delta & 0x40) // did external interrupt 5 change state? - IR sensor 4
{
Int_5_Handler(Port_B & 0x40 ? 1 : 0); // call the interrupt 5 handler (in receiver.c)
}
if(Port_B_Delta & 0x80) // did external interrupt 6 change state?
{
// if used, call the interrupt 6 handler here
}
}
}
/*******************************************************************************
* FUNCTION NAME: User_Autonomous_Code
* PURPOSE: Execute user's code during autonomous robot operation.
* You should modify this routine by adding code which you wish to run in
* autonomous mode. It will be executed every program loop, and not
* wait for or use any data from the Operator Interface.
* CALLED FROM: main.c file, main() routine when in Autonomous mode
* ARGUMENTS: none
* RETURNS: void
*******************************************************************************/
void User_Autonomous_Code(void)
{
while (autonomous_mode) /* DO NOT CHANGE! */
{
if (statusflag.NEW_SPI_DATA) /* 26.2ms loop area */
{
Getdata(&rxdata); /* DO NOT DELETE, or you will be stuck here forever! */
/* Add your own autonomous code here. */
Navigate();
if(rc_dig_in01 ==1 )
{
pwm13 = 137;
pwm14=100;
}
else
{
pwm13 = pwm14 = 140;
}
if(rc_dig_in02 == 1)
{
pwm13 = 100;
pwm14 = 137;
}
else
{
pwm13 = pwm14 = 140;
}
Generate_Pwms(pwm13,pwm14,pwm15,pwm16);
Putdata(&txdata); /* DO NOT DELETE, or you will get no PWM outputs! */
}
}
}
/*******************************************************************************
* FUNCTION NAME: Process_Data_From_Local_IO
* PURPOSE: Execute user's realtime code.
* You should modify this routine by adding code which you wish to run fast.
* It will be executed every program loop, and not wait for fresh data
* from the Operator Interface.
* CALLED FROM: main.c
* ARGUMENTS: none
* RETURNS: void
*******************************************************************************/
void Process_Data_From_Local_IO(void)
{
/* Add code here that you want to be executed every program loop. */
}
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/*******************************************************************************
* FILE NAME: user_routines_fast.c
*
* DESCRIPTION:
* This file is where the user can add their custom code within the framework
* of the routines below.
*
* USAGE:
* You can either modify this file to fit your needs, or remove it from your
* project and replace it with a modified copy.
*
* OPTIONS: Interrupts are disabled and not used by default.
*******************************************************************************/
#include "ifi_aliases.h"
#include "ifi_default.h"
#include "ifi_utilities.h"
#include "user_routines.h"
#include "receiver.h"
#include "tracker.h"
#include "navigate.h"
/*** DEFINE USER VARIABLES AND INITIALIZE THEM HERE ***/
/*******************************************************************************
* FUNCTION NAME: InterruptVectorLow
* PURPOSE: Low priority interrupt vector
* CALLED FROM: nowhere by default
* ARGUMENTS: none
* RETURNS: void
* DO NOT MODIFY OR DELETE THIS FUNCTION
*******************************************************************************/
#pragma code InterruptVectorLow = LOW_INT_VECTOR
void InterruptVectorLow (void)
{
_asm
goto InterruptHandlerLow /*jump to interrupt routine*/
_endasm
}
/*******************************************************************************
* FUNCTION NAME: InterruptHandlerLow
* PURPOSE: Low priority interrupt handler
* If you want to use these external low priority interrupts or any of the
* peripheral interrupts then you must enable them in your initialization
* routine. Innovation First, Inc. will not provide support for using these
* interrupts, so be careful. There is great potential for glitchy code if good
* interrupt programming practices are not followed. Especially read p. 28 of
* the "MPLAB(R) C18 C Compiler User's Guide" for information on context saving.
* CALLED FROM: this file, InterruptVectorLow routine
* ARGUMENTS: none
* RETURNS: void
*******************************************************************************/
#pragma code
#pragma interruptlow InterruptHandlerLow
void InterruptHandlerLow ()
{
unsigned char Port_B;
unsigned char Port_B_Delta;
static unsigned char Old_Port_B = 0xFF; // state of port b the last time
// this function was called
if (INTCONbits.TMR0IF) // timer 0 Interrupt
{
INTCONbits.TMR0IF = 0; // clear the interrupt flag
// if used, call the timer 0 interrupt handler here
}
else if (PIR1bits.TMR1IF) // timer 1 interrupt - used by the IR receiver
{
PIR1bits.TMR1IF = 0; // clear the interrupt flag
Timer_1_Int_Handler(); // call the timer 1 interrupt handler (in receiver.c)
}
else if (INTCON3bits.INT2IF) // external interrupt 1 - used by IR sensor 1
{
INTCON3bits.INT2IF = 0; // clear the interrupt flag
Int_1_Handler(); // call the IR sensor 1 interrupt handler (in receiver.c)
}
else if (INTCON3bits.INT3IF) // external interrupt 2 - used by IR sensor 2
{
INTCON3bits.INT3IF = 0; // clear the interrupt flag
Int_2_Handler(); // call the IR sensor 2 interrupt handler (in receiver.c)
}
else if (INTCONbits.RBIF) // external interrupts 3 through 6
{
Port_B = PORTB; // remove the "mismatch condition" by reading port b
INTCONbits.RBIF = 0; // clear the interrupt flag
Port_B_Delta = Port_B ^ Old_Port_B; // determine which bits have changed
Old_Port_B = Port_B; // save a copy of port b for next time around
if(Port_B_Delta & 0x10) // did external interrupt 3 change state?
{
// if used, call the interrupt 3 handler here
}
if(Port_B_Delta & 0x20) // did external interrupt 4 change state? - IR sensor 3
{
Int_4_Handler(Port_B & 0x20 ? 1 : 0); // call the interrupt 4 handler (in receiver.c)
}
if(Port_B_Delta & 0x40) // did external interrupt 5 change state? - IR sensor 4
{
Int_5_Handler(Port_B & 0x40 ? 1 : 0); // call the interrupt 5 handler (in receiver.c)
}
if(Port_B_Delta & 0x80) // did external interrupt 6 change state?
{
// if used, call the interrupt 6 handler here
}
}
}
/*******************************************************************************
* FUNCTION NAME: User_Autonomous_Code
* PURPOSE: Execute user's code during autonomous robot operation.
* You should modify this routine by adding code which you wish to run in
* autonomous mode. It will be executed every program loop, and not
* wait for or use any data from the Operator Interface.
* CALLED FROM: main.c file, main() routine when in Autonomous mode
* ARGUMENTS: none
* RETURNS: void
*******************************************************************************/
void User_Autonomous_Code(void)
{
while (autonomous_mode) /* DO NOT CHANGE! */
{
if (statusflag.NEW_SPI_DATA) /* 26.2ms loop area */
{
Getdata(&rxdata); /* DO NOT DELETE, or you will be stuck here forever! */
/* Add your own autonomous code here. */
Navigate();
if(rc_dig_in01 ==1 )
{
pwm13 = 137;
pwm14=100;
}
else
{
pwm13 = pwm14 = 140;
}
if(rc_dig_in02 == 1)
{
pwm13 = 100;
pwm14 = 137;
}
else
{
pwm13 = pwm14 = 140;
}
Generate_Pwms(pwm13,pwm14,pwm15,pwm16);
Putdata(&txdata); /* DO NOT DELETE, or you will get no PWM outputs! */
}
}
}
/*******************************************************************************
* FUNCTION NAME: Process_Data_From_Local_IO
* PURPOSE: Execute user's realtime code.
* You should modify this routine by adding code which you wish to run fast.
* It will be executed every program loop, and not wait for fresh data
* from the Operator Interface.
* CALLED FROM: main.c
* ARGUMENTS: none
* RETURNS: void
*******************************************************************************/
void Process_Data_From_Local_IO(void)
{
/* Add code here that you want to be executed every program loop. */
}
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/*******************************************************************************
* FILE NAME: main.c <FRC VERSION>
*
* DESCRIPTION:
* This file contains the main program loop.
*
* USAGE:
* You should not need to modify this file.
* Note the different loop speed for the two routines:
* Process_Data_From_Master_uP
* Process_Data_From_Local_IO
*******************************************************************************/
#include "ifi_aliases.h"
#include "ifi_default.h"
#include "ifi_utilities.h"
#include "user_routines.h"
tx_data_record txdata; /* DO NOT CHANGE! */
rx_data_record rxdata; /* DO NOT CHANGE! */
packed_struct statusflag; /* DO NOT CHANGE! */
/*******************************************************************************
* FUNCTION NAME: main
* PURPOSE: Main program loop.
* CALLED FROM: ifi_startup.c
* ARGUMENTS: none
* RETURNS: void
* DO NOT DELETE THIS FUNCTION
*******************************************************************************/
void main (void)
{
#ifdef UNCHANGEABLE_DEFINITION_AREA
IFI_Initialization (); /* DO NOT CHANGE! */
#endif
User_Initialization(); /* You edit this in user_routines.c */
statusflag.NEW_SPI_DATA = 0; /* DO NOT CHANGE! */
while (1) /* This loop will repeat indefinitely. */
{
#ifdef _SIMULATOR
statusflag.NEW_SPI_DATA = 1;
#endif
if (statusflag.NEW_SPI_DATA) /* 26.2ms loop area */
{ /* I'm slow! I only execute every 26.2ms because that's */
/* how fast the Master uP gives me data. */
Process_Data_From_Master_uP(); /* You edit this in user_routines.c */
if (autonomous_mode) /* DO NOT CHANGE! */
{
User_Autonomous_Code(); /* You edit this in user_routines_fast.c */
}
}
Process_Data_From_Local_IO(); /* You edit this in user_routines_fast.c */
/* I'm fast! I execute during every loop.*/
} /* while (1) */
} /* END of Main */
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/*******************************************************************************
* FILE NAME: printf_lib.c
*
* DESCRIPTION:
* This file contains generic routines that work like the standard C I/O library.
* These unsupported routines have been modified to work with the Microchip
* C compiler. The printf routine is limited as follows:
*
* 1. Only the %s, %lx, %d, %x, %u, %X directives are parsed. An additional %b
* directive is parsed for those who like to view data in binary (base 2).
*
* Examples:
*
* rom const char *StrPtr = "Hello world!";
* int x = 15;
* int y = 0x50;
* long z = 0xdeadface;
*
* printf("%s
",StrPtr); will display 'Hello world!'
*
* printf("X = %d, Y = %x, Z = %lx
",x,y,z); will display 'X = 15, Y = 0x50, Z = deadface'
*
* printf("X = %b (base 2)
",x); will display 'X = 1111 (base 2)'
*
* printf("X = %16b
",x); will display 'X = 0000000000001111'
*
* printf("X = %04x
",x); will display 'X = 000f'
*
* 2. All bytes (8 bits) or bit references (rc_dig_in01) must be type-cast to a
* 16 bit word. The %c directive is unsupported.
*
* Examples:
*
* unsigned char byte1 = 0xfa;
* char byte2 = 25;
*
* printf("1st byte = %x, 2nd byte = %d
",(int)byte1,(int)byte2);
* will display '1st byte = fa, 2nd byte = 25
* if (rc_dig_in01)
* printf("On %d
",(int)rc_dig_in01); will display 'On 1'
* else
* printf("Off %d
",(int)rc_dig_in01); will display 'Off 0'
*
* 3. The %s directive only supports a string of 40 bytes and the format string
* may not exceed 80 bytes. The sprintf routine is not included. Keep in
* mind that the stack size has a 256 byte limit.
*
* USAGE:
* These library routines may be modified to suit the needs of the user.
*******************************************************************************/
#include "ifi_default.h"
#include "printf_lib.h"
#include "ifi_utilities.h"
#include "string.h"
/* the following should be enough for a 32 bit word */
#define PRINT_BUF_LEN 20
extern char ifi_printfBufr]; /* declared in ifi_utilities.c */
rom char *nullStr = "(null)";
static char print_buf[PRINT_BUF_LEN];
static char scr[2];
static int k;
/*******************************************************************************
* SUBROUTINE NAME: Write_Byte_To_Uart
* PURPOSE: Writes a byte to the UART.
* Argument Type IO Description
* -------- ----------- -- -----------
* data int I data to transmit to the UART
* RETURNS: void
*******************************************************************************/
static void Write_Byte_To_Uart(int data)
{
TXREG = data; /* a carriage return */
Wait4TXEmpty();
}
#define PAD_RIGHT 1
#define PAD_ZERO 2
/*******************************************************************************
* FUNCTION NAME: prints
* PURPOSE: Pads the output stream.
* RETURNS: void
*******************************************************************************/
static int prints(char *string, int width, int pad)
{
register int pc = 0, padchar = ' ';
if (width > 0) {
register int len = 0;
register char *ptr;
for (ptr = string; *ptr; ++ptr) ++len;
if (len >= width) width = 0;
else width -= len;
if (pad & PAD_ZERO) padchar = '0';
}
if (!(pad & PAD_RIGHT)) {
for ( ; width > 0; --width) {
Write_Byte_To_Uart (padchar);
++pc;
}
}
for ( ; *string ; ++string) {
Write_Byte_To_Uart (*string);
++pc;
}
for ( ; width > 0; --width) {
Write_Byte_To_Uart (padchar);
++pc;
}
return pc;
}
/*******************************************************************************
* FUNCTION NAME: printi
* PURPOSE: Converts the output stream to the proper width and base.
* RETURNS: void
*******************************************************************************/
static int printi(int i, int b, int sg, int width, int pad, int letbase)
{
register char *s;
register int t, neg = 0, pc = 0;
register unsigned int u = i;
print_buf[0] = 0xBE;
print_buf[PRINT_BUF_LEN] = 0xEF;
if (i == 0) {
print_buf[0] = '0';
print_buf[1] = '\0';
return prints (print_buf, width, pad);
}
if (sg && b == 10 && i < 0) {
neg = 1;
u = -i;
}
s = print_buf + PRINT_BUF_LEN-1;
*s = '\0';
while (u) {
t = u % b;
if( t >= 10 )
t += letbase - '0' - 10;
*--s = t + '0';
u /= b;
}
if (neg) {
if( width && (pad & PAD_ZERO) ) {
Write_Byte_To_Uart ('-');
++pc;
--width;
}
else {
*--s = '-';
}
}
return pc + prints (s, width, pad);
}
/*******************************************************************************
* FUNCTION NAME: print
* PURPOSE: Parses the output stream.
* RETURNS: void
*******************************************************************************/
static int print(char *format, int *varg)
{
char tmpBufr[40];
register int width, pad;
register int pc = 0;
for (; *format != 0; ++format) {
if (*format == '%') {
++format;
width = pad = 0;
if (*format == '\0') break;
if (*format == '%') goto out;
if (*format == '-') {
++format;
pad = PAD_RIGHT;
}
while (*format == '0') {
++format;
pad |= PAD_ZERO;
}
for ( ; *format >= '0' && *format <= '9'; ++format) {
width *= 10;
width += *format - '0';
}
if( *format == 's' )
{
strcpypgm2ram(tmpBufr,(rom char *) *varg--);
if (tmpBufr[0] == 0)
strcpypgm2ram(tmpBufr,nullStr);
pc += prints (tmpBufr, width, pad);
continue;
}
if( *format == 'd' ) {
pc += printi (*varg--, 10, 1, width, pad, 'a');
continue;
}
if( *format == 'x' ) {
pc += printi (*varg--, 16, 0, width, pad, 'a');
continue;
}
if( *format == 'X' ) {
pc += printi (*varg--, 16, 0, width, pad, 'A');
continue;
}
if( *format == 'u' ) {
pc += printi (*varg--, 10, 0, width, pad, 'a');
continue;
}
if( *format == 'l' ) { /* assumes lx */
pc += printi (*varg--, 16, 0, width, pad, 'a');
pc += printi (*varg--, 16, 0, width, pad, 'a');
format++; /* skip over x*/
continue;
}
if( *format == 'b' ) {
pc += printi (*varg--, 2, 0, width, 2, 'a');
continue;
}
}
else {
out:
if (*format == '
') *format = '\r'; /* replace line feed with cr */
Write_Byte_To_Uart (*format);
++pc;
}
}
return pc;
}
/*******************************************************************************
* FUNCTION NAME: printf
* PURPOSE: Formats an output stream.
* RETURNS: void
*******************************************************************************/
int printf(rom const char *format, ...)
{
register int *varg = (int *)(&format);
/*
Since constant strings are kept in program (flash) memory, the strcpypgm2ram
routine copies the string from flash to ram.
*/
strcpypgm2ram(ifi_printfBufr,(rom char *) format);
varg--; /* adjust stack for Microchip C Compiler */
return print(ifi_printfBufr, varg);
}
/******************************************************************************
*
* The following routines are examples how to use the printf library routines
* to create your own output modules:
*
*******************************************************************************/
/*******************************************************************************
* FUNCTION NAME: printid
* PURPOSE: Prints a 16bit word (base 10) w/o a carriage return.
* RETURNS: void
*******************************************************************************/
void printid(int data,int crtOn)
{
printi (data, 10, 1, 4, 2, 'a');
if (crtOn)
Write_Byte_To_Uart('\r');
}
/*******************************************************************************
* FUNCTION NAME: printd
* PURPOSE: Prints an 8bit word (base 10) w/o a carriage return.
* RETURNS: void
*******************************************************************************/
void printd(unsigned char data,int crtOn)
{
printi ((int) data, 10, 1, 3, 2, 'a');
if (crtOn)
Write_Byte_To_Uart('\r');
}
/*******************************************************************************
* FUNCTION NAME: printib
* PURPOSE: Prints a 16bit binary word (base 2) w/o a carriage return.
* RETURNS: void
*******************************************************************************/
void printib(unsigned int data,int crtOn)
{
printi (data, 2, 0, 16, 2, 'a');
if (crtOn)
Write_Byte_To_Uart('\r');
}
/*******************************************************************************
* FUNCTION NAME: printb
* PURPOSE: Prints an 8bit binary word (base 2) w/o a carriage return.
* RETURNS: void
*******************************************************************************/
void printb(unsigned char data,int crtOn)
{
printi ((int) data, 2, 0, 8, 2, 'a');
if (crtOn)
Write_Byte_To_Uart('\r');
}
/*******************************************************************************
* FUNCTION NAME: printix
* PURPOSE: Prints a 16bit hex word (base 16) w/o a carriage return.
* RETURNS: void
*******************************************************************************/
void printix(int data,int crtOn)
{
printi (data, 16, 0, 2, 0, 'a');
if (crtOn)
Write_Byte_To_Uart('\r');
}
/*******************************************************************************
* FUNCTION NAME: printx
* PURPOSE: Prints an 8bit hex word (base 16) w/o a carriage return.
* RETURNS: void
*******************************************************************************/
void printx(unsigned char data,int crtOn)
{
printi ((int) data, 16, 0, 2, 2, 'a');
if (crtOn)
Write_Byte_To_Uart('\r');
}
/*******************************************************************************
* FUNCTION NAME: debug_print
* PURPOSE: Prints a header and a 16bit hex word (base 16) with a carriage
* return.
* RETURNS: void
*******************************************************************************/
void debug_print(char *bufr,int data)
{
strcpypgm2ram (ifi_printfBufr,(rom char *) bufr);
for (k=0;k<strlen(ifi_printfBufr);k++)
Write_Byte_To_Uart(ifi_printfBufr[k]);
printix(data,1);
}
/*******************************************************************************
* FUNCTION NAME: debug_printb
* PURPOSE: Prints a header and an 8bit binary word (base 2) with a carriage
* return.
* RETURNS: void
*******************************************************************************/
void debug_printb(char *bufr,unsigned int data)
{
strcpypgm2ram (ifi_printfBufr,(rom char *) bufr);
for (k=0;k<strlen(ifi_printfBufr);k++)
Write_Byte_To_Uart(ifi_printfBufr[k]);
printib(data,1);
}
/*******************************************************************************
* FUNCTION NAME: debug_println
* PURPOSE: Prints a header (assumming a carriage return is supplied).
* RETURNS: void
*******************************************************************************/
void debug_println(char *bufr)
{
strcpypgm2ram (ifi_printfBufr,(rom char *) bufr);
for (k=0;k<strlen(ifi_printfBufr);k++)
Write_Byte_To_Uart(ifi_printfBufr[k]);
}
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/*******************************************************************************
* FILE NAME: printf_lib.c
*
* DESCRIPTION:
* This file contains generic routines that work like the standard C I/O library.
* These unsupported routines have been modified to work with the Microchip
* C compiler. The printf routine is limited as follows:
*
* 1. Only the %s, %lx, %d, %x, %u, %X directives are parsed. An additional %b
* directive is parsed for those who like to view data in binary (base 2).
*
* Examples:
*
* rom const char *StrPtr = "Hello world!";
* int x = 15;
* int y = 0x50;
* long z = 0xdeadface;
*
* printf("%s
",StrPtr); will display 'Hello world!'
*
* printf("X = %d, Y = %x, Z = %lx
",x,y,z); will display 'X = 15, Y = 0x50, Z = deadface'
*
* printf("X = %b (base 2)
",x); will display 'X = 1111 (base 2)'
*
* printf("X = %16b
",x); will display 'X = 0000000000001111'
*
* printf("X = %04x
",x); will display 'X = 000f'
*
* 2. All bytes (8 bits) or bit references (rc_dig_in01) must be type-cast to a
* 16 bit word. The %c directive is unsupported.
*
* Examples:
*
* unsigned char byte1 = 0xfa;
* char byte2 = 25;
*
* printf("1st byte = %x, 2nd byte = %d
",(int)byte1,(int)byte2);
* will display '1st byte = fa, 2nd byte = 25
* if (rc_dig_in01)
* printf("On %d
",(int)rc_dig_in01); will display 'On 1'
* else
* printf("Off %d
",(int)rc_dig_in01); will display 'Off 0'
*
* 3. The %s directive only supports a string of 40 bytes and the format string
* may not exceed 80 bytes. The sprintf routine is not included. Keep in
* mind that the stack size has a 256 byte limit.
*
* USAGE:
* These library routines may be modified to suit the needs of the user.
*******************************************************************************/
#include "ifi_default.h"
#include "printf_lib.h"
#include "ifi_utilities.h"
#include "string.h"
/* the following should be enough for a 32 bit word */
#define PRINT_BUF_LEN 20
extern char ifi_printfBufr]; /* declared in ifi_utilities.c */
rom char *nullStr = "(null)";
static char print_buf[PRINT_BUF_LEN];
static char scr[2];
static int k;
/*******************************************************************************
* SUBROUTINE NAME: Write_Byte_To_Uart
* PURPOSE: Writes a byte to the UART.
* Argument Type IO Description
* -------- ----------- -- -----------
* data int I data to transmit to the UART
* RETURNS: void
*******************************************************************************/
static void Write_Byte_To_Uart(int data)
{
TXREG = data; /* a carriage return */
Wait4TXEmpty();
}
#define PAD_RIGHT 1
#define PAD_ZERO 2
/*******************************************************************************
* FUNCTION NAME: prints
* PURPOSE: Pads the output stream.
* RETURNS: void
*******************************************************************************/
static int prints(char *string, int width, int pad)
{
register int pc = 0, padchar = ' ';
if (width > 0) {
register int len = 0;
register char *ptr;
for (ptr = string; *ptr; ++ptr) ++len;
if (len >= width) width = 0;
else width -= len;
if (pad & PAD_ZERO) padchar = '0';
}
if (!(pad & PAD_RIGHT)) {
for ( ; width > 0; --width) {
Write_Byte_To_Uart (padchar);
++pc;
}
}
for ( ; *string ; ++string) {
Write_Byte_To_Uart (*string);
++pc;
}
for ( ; width > 0; --width) {
Write_Byte_To_Uart (padchar);
++pc;
}
return pc;
}
/*******************************************************************************
* FUNCTION NAME: printi
* PURPOSE: Converts the output stream to the proper width and base.
* RETURNS: void
*******************************************************************************/
static int printi(int i, int b, int sg, int width, int pad, int letbase)
{
register char *s;
register int t, neg = 0, pc = 0;
register unsigned int u = i;
print_buf[0] = 0xBE;
print_buf[PRINT_BUF_LEN] = 0xEF;
if (i == 0) {
print_buf[0] = '0';
print_buf[1] = '\0';
return prints (print_buf, width, pad);
}
if (sg && b == 10 && i < 0) {
neg = 1;
u = -i;
}
s = print_buf + PRINT_BUF_LEN-1;
*s = '\0';
while (u) {
t = u % b;
if( t >= 10 )
t += letbase - '0' - 10;
*--s = t + '0';
u /= b;
}
if (neg) {
if( width && (pad & PAD_ZERO) ) {
Write_Byte_To_Uart ('-');
++pc;
--width;
}
else {
*--s = '-';
}
}
return pc + prints (s, width, pad);
}
/*******************************************************************************
* FUNCTION NAME: print
* PURPOSE: Parses the output stream.
* RETURNS: void
*******************************************************************************/
static int print(char *format, int *varg)
{
char tmpBufr[40];
register int width, pad;
register int pc = 0;
for (; *format != 0; ++format) {
if (*format == '%') {
++format;
width = pad = 0;
if (*format == '\0') break;
if (*format == '%') goto out;
if (*format == '-') {
++format;
pad = PAD_RIGHT;
}
while (*format == '0') {
++format;
pad |= PAD_ZERO;
}
for ( ; *format >= '0' && *format <= '9'; ++format) {
width *= 10;
width += *format - '0';
}
if( *format == 's' )
{
strcpypgm2ram(tmpBufr,(rom char *) *varg--);
if (tmpBufr[0] == 0)
strcpypgm2ram(tmpBufr,nullStr);
pc += prints (tmpBufr, width, pad);
continue;
}
if( *format == 'd' ) {
pc += printi (*varg--, 10, 1, width, pad, 'a');
continue;
}
if( *format == 'x' ) {
pc += printi (*varg--, 16, 0, width, pad, 'a');
continue;
}
if( *format == 'X' ) {
pc += printi (*varg--, 16, 0, width, pad, 'A');
continue;
}
if( *format == 'u' ) {
pc += printi (*varg--, 10, 0, width, pad, 'a');
continue;
}
if( *format == 'l' ) { /* assumes lx */
pc += printi (*varg--, 16, 0, width, pad, 'a');
pc += printi (*varg--, 16, 0, width, pad, 'a');
format++; /* skip over x*/
continue;
}
if( *format == 'b' ) {
pc += printi (*varg--, 2, 0, width, 2, 'a');
continue;
}
}
else {
out:
if (*format == '
') *format = '\r'; /* replace line feed with cr */
Write_Byte_To_Uart (*format);
++pc;
}
}
return pc;
}
/*******************************************************************************
* FUNCTION NAME: printf
* PURPOSE: Formats an output stream.
* RETURNS: void
*******************************************************************************/
int printf(rom const char *format, ...)
{
register int *varg = (int *)(&format);
/*
Since constant strings are kept in program (flash) memory, the strcpypgm2ram
routine copies the string from flash to ram.
*/
strcpypgm2ram(ifi_printfBufr,(rom char *) format);
varg--; /* adjust stack for Microchip C Compiler */
return print(ifi_printfBufr, varg);
}
/******************************************************************************
*
* The following routines are examples how to use the printf library routines
* to create your own output modules:
*
*******************************************************************************/
/*******************************************************************************
* FUNCTION NAME: printid
* PURPOSE: Prints a 16bit word (base 10) w/o a carriage return.
* RETURNS: void
*******************************************************************************/
void printid(int data,int crtOn)
{
printi (data, 10, 1, 4, 2, 'a');
if (crtOn)
Write_Byte_To_Uart('\r');
}
/*******************************************************************************
* FUNCTION NAME: printd
* PURPOSE: Prints an 8bit word (base 10) w/o a carriage return.
* RETURNS: void
*******************************************************************************/
void printd(unsigned char data,int crtOn)
{
printi ((int) data, 10, 1, 3, 2, 'a');
if (crtOn)
Write_Byte_To_Uart('\r');
}
/*******************************************************************************
* FUNCTION NAME: printib
* PURPOSE: Prints a 16bit binary word (base 2) w/o a carriage return.
* RETURNS: void
*******************************************************************************/
void printib(unsigned int data,int crtOn)
{
printi (data, 2, 0, 16, 2, 'a');
if (crtOn)
Write_Byte_To_Uart('\r');
}
/*******************************************************************************
* FUNCTION NAME: printb
* PURPOSE: Prints an 8bit binary word (base 2) w/o a carriage return.
* RETURNS: void
*******************************************************************************/
void printb(unsigned char data,int crtOn)
{
printi ((int) data, 2, 0, 8, 2, 'a');
if (crtOn)
Write_Byte_To_Uart('\r');
}
/*******************************************************************************
* FUNCTION NAME: printix
* PURPOSE: Prints a 16bit hex word (base 16) w/o a carriage return.
* RETURNS: void
*******************************************************************************/
void printix(int data,int crtOn)
{
printi (data, 16, 0, 2, 0, 'a');
if (crtOn)
Write_Byte_To_Uart('\r');
}
/*******************************************************************************
* FUNCTION NAME: printx
* PURPOSE: Prints an 8bit hex word (base 16) w/o a carriage return.
* RETURNS: void
*******************************************************************************/
void printx(unsigned char data,int crtOn)
{
printi ((int) data, 16, 0, 2, 2, 'a');
if (crtOn)
Write_Byte_To_Uart('\r');
}
/*******************************************************************************
* FUNCTION NAME: debug_print
* PURPOSE: Prints a header and a 16bit hex word (base 16) with a carriage
* return.
* RETURNS: void
*******************************************************************************/
void debug_print(char *bufr,int data)
{
strcpypgm2ram (ifi_printfBufr,(rom char *) bufr);
for (k=0;k<strlen(ifi_printfBufr);k++)
Write_Byte_To_Uart(ifi_printfBufr[k]);
printix(data,1);
}
/*******************************************************************************
* FUNCTION NAME: debug_printb
* PURPOSE: Prints a header and an 8bit binary word (base 2) with a carriage
* return.
* RETURNS: void
*******************************************************************************/
void debug_printb(char *bufr,unsigned int data)
{
strcpypgm2ram (ifi_printfBufr,(rom char *) bufr);
for (k=0;k<strlen(ifi_printfBufr);k++)
Write_Byte_To_Uart(ifi_printfBufr[k]);
printib(data,1);
}
/*******************************************************************************
* FUNCTION NAME: debug_println
* PURPOSE: Prints a header (assumming a carriage return is supplied).
* RETURNS: void
*******************************************************************************/
void debug_println(char *bufr)
{
strcpypgm2ram (ifi_printfBufr,(rom char *) bufr);
for (k=0;k<strlen(ifi_printfBufr);k++)
Write_Byte_To_Uart(ifi_printfBufr[k]);
}
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/*******************************************************************************
*
* TITLE: tracker.c
*
* VERSION: 1.0
*
* DATE: 09-Jan-2004
*
* AUTHOR: R. Kevin Watson
*
* COMMENTS: This code assumes IR sensor 1 is the left sensor on the left tracker
* " IR sensor 2 is the right sensor on the left tracker
* " IR sensor 3 is the left sensor on the right tracker
* " IR sensor 4 is the right sensor on the right tracker
*
* " left IR beacon tracking servo motor is on PWM 1
* " right IR beacon tracking servo motor is on PWM 2
*
* " beacon type selector switch is on digital I/O 7
*
********************************************************************************
*
* CHANGE LOG:
*
* DATE REV DESCRIPTION
* ----------- --- ----------------------------------------------------------
* 03-Dec-2003 0.1 RKW Original
* 07-Dec-2003 0.2 RKW - Modified Track_Beacon() to handle an arbitrary number
* of IR beam tracking assemblies. All state machine
* information is now kept in the Tracker_Data data structure.
* RKW - Cleaned-up Track_Beacon to make it understandable,
* hiding most of the tough-to-grasp code in tracker.h
* 09-Jan-2004 1.0 RKW - This version used for kick-off demo
*
*******************************************************************************/
#include "ifi_picdefs.h"
#include "ifi_default.h"
#include "ifi_aliases.h"
#include "printf_lib.h"
#include "user_routines.h"
#include "receiver.h"
#include "tracker.h"
Tracker_Data_Struct Tracker_Data[2]; // two trackers: left and right
/*******************************************************************************
*
* FUNCTION: Initialize_Tracker()
*
* PURPOSE: Initializes the infrared beacon tracker code.
*
* CALLED FROM: user_routines.c/User_Initialization()
*
* PARAMETERS: None
*
* RETURNS: Nothing
*
* COMMENTS: Adjustable tracker parameters are located in tracker.h
*******************************************************************************/
void Initialize_Tracker(void)
{
// initialize servo PWM channels
LEFT_TRACKER_SERVO = INITIAL_SERVO_POSITION; // rotate left tracker fully clockwise
RIGHT_TRACKER_SERVO = INITIAL_SERVO_POSITION; // rotate right tracker fully clockwise
// initialize the left tracker's state machine
Tracker_Data[LEFT].Status = NONE_IN_VIEW; // defined in tracker.h
Tracker_Data[LEFT].Position = INITIAL_SERVO_POSITION; // defined in tracker.h
Tracker_Data[LEFT].Search_Increment = INITIAL_SERVO_STEP_SIZE; // defined in tracker.h
Tracker_Data[LEFT].Beacon_Type = BEACON_TYPE; // defined in tracker.h
Tracker_Data[LEFT].Left_Sensor_Stats_Index = LEFT_TRACKER_LEFT_SENSOR; // defined in tracker.h
Tracker_Data[LEFT].Right_Sensor_Stats_Index = LEFT_TRACKER_RIGHT_SENSOR; // defined in tracker.h
// initialize the right tracker's state machine
Tracker_Data[RIGHT].Status = NONE_IN_VIEW; // defined in tracker.h
Tracker_Data[RIGHT].Position = INITIAL_SERVO_POSITION; // defined in tracker.h
Tracker_Data[RIGHT].Search_Increment = INITIAL_SERVO_STEP_SIZE; // defined in tracker.h
Tracker_Data[RIGHT].Beacon_Type = BEACON_TYPE; // defined in tracker.h
Tracker_Data[RIGHT].Left_Sensor_Stats_Index = RIGHT_TRACKER_LEFT_SENSOR; // defined in tracker.h
Tracker_Data[RIGHT].Right_Sensor_Stats_Index = RIGHT_TRACKER_RIGHT_SENSOR; // defined in tracker.h
}
/*******************************************************************************
*
* FUNCTION: Track_Beacon()
*
* PURPOSE: Controls the servo motor(s) such that the pair of
* infrared beacon sensors mounted on it will always
* point at the selected IR beacon. Using two or more
* beacon trackers, separated by a known baseline
* distance, and some trigonometry will allow the user
* to calculate the heading and distance to the beacon.
*
* CALLED FROM: navigate.c/navigate()
*
* PARAMETERS: unsigned char that identifies which tracker to use
*
* RETURNS: nothing
*
* COMMENTS: There must be one Tracker_Data structure per tracker.
* More than two trackers can be used.
*
*******************************************************************************/
void Track_Beacon(unsigned char Tracker)
{
// which state was tracker <Tracker> in the last time through?
switch(TRACKER_STATUS)
{
case NONE_IN_VIEW: // neither sensor sees the beacon
{
if(LEFT_SENSOR > 0)
{
// found the beacon
TRACKER_STATUS = LEFT_IN_VIEW;
// printf("Tracker: from none to left
");
}
else
{
// continue to rotate left until the beacon comes into view
TRACKER_POSITION += SEARCH_INCREMENT; // rolling over is okay
}
break;
}
case LEFT_IN_VIEW: // left sensor sees beacon, but the right sensor doesn't
{
if(RIGHT_SENSOR > 0)
{
// found the beacon
TRACKER_STATUS = BOTH_IN_VIEW;
// printf("Tracker: from left to both
");
}
else
{
// continue to rotate left until the beacon comes into view of the right sensor
TRACKER_POSITION += SEARCH_INCREMENT; // rolling over is okay
}
break;
}
case RIGHT_IN_VIEW: // right sensor sees beacon, but the left sensor doesn't
{
if(LEFT_SENSOR > 0)
{
// found the beacon
TRACKER_STATUS = BOTH_IN_VIEW;
// printf("Tracker: from right to both
");
}
else
{
// continue to rotate right until the beacon comes into view of the left sensor
TRACKER_POSITION -= SEARCH_INCREMENT; // rolling over is okay
}
break;
}
case BOTH_IN_VIEW: // both sensors see the beacon
{
if((LEFT_SENSOR > 0) && (RIGHT_SENSOR > 0))
{
// do nothing because both sensors see the beacon
// printf("Tracker: both
", 0);
}
else
{
// is the beacon in view of the left sensor?
if(LEFT_SENSOR > 0)
{
// left sensor sees beacon; change state and rotate left
TRACKER_STATUS = LEFT_IN_VIEW;
TRACKER_POSITION += SEARCH_INCREMENT; // rolling over is okay
// printf("Tracker: from both to left
");
}
// is the beacon in view of the right sensor?
else if(RIGHT_SENSOR > 0)
{
// right sensor sees beacon; change state and rotate right
TRACKER_STATUS = RIGHT_IN_VIEW;
TRACKER_POSITION -= SEARCH_INCREMENT; // rolling over is okay
// printf("Tracker: from both to right
");
}
else
{
// neither sensor sees the beacon; change state and start search
TRACKER_STATUS = NONE_IN_VIEW;
TRACKER_POSITION += SEARCH_INCREMENT; // rolling over is okay
// printf("Tracker: from both to none
");
}
}
break;
}
}// end switch(TRACKER_STATUS)
}
/*******************************************************************************
* FILE NAME: user_routines_fast.c
*
* DESCRIPTION:
* This file is where the user can add their custom code within the framework
* of the routines below.
*
* USAGE:
* You can either modify this file to fit your needs, or remove it from your
* project and replace it with a modified copy.
*
* OPTIONS: Interrupts are disabled and not used by default.
*******************************************************************************/
#include "ifi_aliases.h"
#include "ifi_default.h"
#include "ifi_utilities.h"
#include "user_routines.h"
#include "receiver.h"
#include "tracker.h"
#include "navigate.h"
/*** DEFINE USER VARIABLES AND INITIALIZE THEM HERE ***/
/*******************************************************************************
* FUNCTION NAME: InterruptVectorLow
* PURPOSE: Low priority interrupt vector
* CALLED FROM: nowhere by default
* ARGUMENTS: none
* RETURNS: void
* DO NOT MODIFY OR DELETE THIS FUNCTION
*******************************************************************************/
#pragma code InterruptVectorLow = LOW_INT_VECTOR
void InterruptVectorLow (void)
{
_asm
goto InterruptHandlerLow /*jump to interrupt routine*/
_endasm
}
/*******************************************************************************
* FUNCTION NAME: InterruptHandlerLow
* PURPOSE: Low priority interrupt handler
* If you want to use these external low priority interrupts or any of the
* peripheral interrupts then you must enable them in your initialization
* routine. Innovation First, Inc. will not provide support for using these
* interrupts, so be careful. There is great potential for glitchy code if good
* interrupt programming practices are not followed. Especially read p. 28 of
* the "MPLAB(R) C18 C Compiler User's Guide" for information on context saving.
* CALLED FROM: this file, InterruptVectorLow routine
* ARGUMENTS: none
* RETURNS: void
*******************************************************************************/
#pragma code
#pragma interruptlow InterruptHandlerLow
void InterruptHandlerLow ()
{
unsigned char Port_B;
unsigned char Port_B_Delta;
static unsigned char Old_Port_B = 0xFF; // state of port b the last time
// this function was called
if (INTCONbits.TMR0IF) // timer 0 Interrupt
{
INTCONbits.TMR0IF = 0; // clear the interrupt flag
// if used, call the timer 0 interrupt handler here
}
else if (PIR1bits.TMR1IF) // timer 1 interrupt - used by the IR receiver
{
PIR1bits.TMR1IF = 0; // clear the interrupt flag
Timer_1_Int_Handler(); // call the timer 1 interrupt handler (in receiver.c)
}
else if (INTCON3bits.INT2IF) // external interrupt 1 - used by IR sensor 1
{
INTCON3bits.INT2IF = 0; // clear the interrupt flag
Int_1_Handler(); // call the IR sensor 1 interrupt handler (in receiver.c)
}
else if (INTCON3bits.INT3IF) // external interrupt 2 - used by IR sensor 2
{
INTCON3bits.INT3IF = 0; // clear the interrupt flag
Int_2_Handler(); // call the IR sensor 2 interrupt handler (in receiver.c)
}
else if (INTCONbits.RBIF) // external interrupts 3 through 6
{
Port_B = PORTB; // remove the "mismatch condition" by reading port b
INTCONbits.RBIF = 0; // clear the interrupt flag
Port_B_Delta = Port_B ^ Old_Port_B; // determine which bits have changed
Old_Port_B = Port_B; // save a copy of port b for next time around
if(Port_B_Delta & 0x10) // did external interrupt 3 change state?
{
// if used, call the interrupt 3 handler here
}
if(Port_B_Delta & 0x20) // did external interrupt 4 change state? - IR sensor 3
{
Int_4_Handler(Port_B & 0x20 ? 1 : 0); // call the interrupt 4 handler (in receiver.c)
}
if(Port_B_Delta & 0x40) // did external interrupt 5 change state? - IR sensor 4
{
Int_5_Handler(Port_B & 0x40 ? 1 : 0); // call the interrupt 5 handler (in receiver.c)
}
if(Port_B_Delta & 0x80) // did external interrupt 6 change state?
{
// if used, call the interrupt 6 handler here
}
}
}
/*******************************************************************************
* FUNCTION NAME: User_Autonomous_Code
* PURPOSE: Execute user's code during autonomous robot operation.
* You should modify this routine by adding code which you wish to run in
* autonomous mode. It will be executed every program loop, and not
* wait for or use any data from the Operator Interface.
* CALLED FROM: main.c file, main() routine when in Autonomous mode
* ARGUMENTS: none
* RETURNS: void
*******************************************************************************/
void User_Autonomous_Code(void)
{
while (autonomous_mode) /* DO NOT CHANGE! */
{
if (statusflag.NEW_SPI_DATA) /* 26.2ms loop area */
{
Getdata(&rxdata); /* DO NOT DELETE, or you will be stuck here forever! */
/* Add your own autonomous code here. */
Navigate();
if(rc_dig_in01 ==1 )
{
pwm13 = 137;
pwm14=100;
}
else
{
pwm13 = pwm14 = 140;
}
if(rc_dig_in02 == 1)
{
pwm13 = 100;
pwm14 = 137;
}
else
{
pwm13 = pwm14 = 140;
}
Generate_Pwms(pwm13,pwm14,pwm15,pwm16);
Putdata(&txdata); /* DO NOT DELETE, or you will get no PWM outputs! */
}
}
}
/*******************************************************************************
* FUNCTION NAME: Process_Data_From_Local_IO
* PURPOSE: Execute user's realtime code.
* You should modify this routine by adding code which you wish to run fast.
* It will be executed every program loop, and not wait for fresh data
* from the Operator Interface.
* CALLED FROM: main.c
* ARGUMENTS: none
* RETURNS: void
*******************************************************************************/
void Process_Data_From_Local_IO(void)
{
/* Add code here that you want to be executed every program loop. */
}
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/********************************************************************************
* FILE NAME: ifi_aliases.h <FRC VERSION>
*
* DESCRIPTION:
* This file contains common macros (known as aliases in PBASIC) for the
* I/O pins of the Robot Controller and elements in the data sent between the
* User processor and the Master processor.
*
* If you want to create your own macros, do so in the designated section of
* the user_routines.h file.
*
* DO NOT EDIT THIS FILE!
********************************************************************************/
#ifndef __ifi_aliases_h_
#define __ifi_aliases_h_
#include <adc.h>
/* PWM Type Definitions used in Setup_PWM_Output_Type(...) */
#define IFI_PWM 0 /* Standard IFI PWM output generated with Generate_PWM(...) */
#define USER_CCP 1 /* User can use PWM pin as digital I/O or CCP pin. */
/*
*-----------------------------------------------------------------------------------------------------
*---------- Aliases for each OI analog input ---------------------------------------------------------
*-----------------------------------------------------------------------------------------------------
* Below are aliases for the analog inputs located on the Operator Interface.
*/
#define p1_y rxdata.oi_analog01
#define p2_y rxdata.oi_analog02
#define p3_y rxdata.oi_analog03
#define p4_y rxdata.oi_analog04
#define p1_x rxdata.oi_analog05
#define p2_x rxdata.oi_analog06
#define p3_x rxdata.oi_analog07
#define p4_x rxdata.oi_analog08
#define p1_wheel rxdata.oi_analog09
#define p2_wheel rxdata.oi_analog10
#define p3_wheel rxdata.oi_analog11
#define p4_wheel rxdata.oi_analog12
/*
*-----------------------------------------------------------------------------------------------------
*---------- Aliases for each OI switch input ---------------------------------------------------------
*-----------------------------------------------------------------------------------------------------
* Below are aliases for the digital inputs located on the Operator Interface.
* Ports 1 & 3 have their inputs duplicated in ports 4 & 2 respectively. The
* inputs from ports 1 & 3 may be disabled via the 'Disable' dip switch
* located on the Operator Interface. See Users Manual for details.
*/
#define p1_sw_trig rxdata.oi_swA_byte.bitselect.bit0 /* Joystick Trigger Button, same as Port4 pin5 */
#define p1_sw_top rxdata.oi_swA_byte.bitselect.bit1 /* Joystick Top Button, same as Port4 pin8 */
#define p1_sw_aux1 rxdata.oi_swA_byte.bitselect.bit2 /* Aux input, same as Port4 pin9 */
#define p1_sw_aux2 rxdata.oi_swA_byte.bitselect.bit3 /* Aux input, same as Port4 pin15*/
#define p3_sw_trig rxdata.oi_swA_byte.bitselect.bit4 /* Joystick Trigger Button, same as Port2 pin5 */
#define p3_sw_top rxdata.oi_swA_byte.bitselect.bit5 /* Joystick Top Button, same as Port2 pin8 */
#define p3_sw_aux1 rxdata.oi_swA_byte.bitselect.bit6 /* Aux input, same as Port2 pin9 */
#define p3_sw_aux2 rxdata.oi_swA_byte.bitselect.bit7 /* Aux input, same as Port2 pin15*/
#define p2_sw_trig rxdata.oi_swB_byte.bitselect.bit0 /* Joystick Trigger Button*/
#define p2_sw_top rxdata.oi_swB_byte.bitselect.bit1 /* Joystick Top Button*/
#define p2_sw_aux1 rxdata.oi_swB_byte.bitselect.bit2 /* Aux input*/
#define p2_sw_aux2 rxdata.oi_swB_byte.bitselect.bit3 /* Aux input*/
#define p4_sw_trig rxdata.oi_swB_byte.bitselect.bit4 /* Joystick Trigger Button*/
#define p4_sw_top rxdata.oi_swB_byte.bitselect.bit5 /* Joystick Top Button*/
#define p4_sw_aux1 rxdata.oi_swB_byte.bitselect.bit6 /* Aux input*/
#define p4_sw_aux2 rxdata.oi_swB_byte.bitselect.bit7 /* Aux input*/
/*
*-----------------------------------------------------------------------------------------------------
*---------- Aliases for DIGITAL IN/OUT connectors ----------------------------------------------------
*-----------------------------------------------------------------------------------------------------
* Below are aliases for the digital I/O located on the Robot Controller.
* They can be configured to be either Inputs or Outputs.
*/
#define INPUT 1
#define OUTPUT 0
/* Used in User_Initialization routine in user_routines.c file. */
/* Used to set pins as digital INPUTS or digital OUTPUTS. */
#define digital_io_01 TRISBbits.TRISB2
#define digital_io_02 TRISBbits.TRISB3
#define digital_io_03 TRISBbits.TRISB4
#define digital_io_04 TRISBbits.TRISB5
#define digital_io_05 TRISBbits.TRISB6
#define digital_io_06 TRISBbits.TRISB7
#define digital_io_07 TRISHbits.TRISH0
#define digital_io_08 TRISHbits.TRISH1
#define digital_io_09 TRISHbits.TRISH2
#define digital_io_10 TRISHbits.TRISH3
#ifdef _FRC_NC1
#define digital_io_11 TRISGbits.TRISG0
#define digital_io_12 TRISGbits.TRISG3
#define digital_io_13 TRISGbits.TRISG4
#else
#define digital_io_11 TRISJbits.TRISJ1
#define digital_io_12 TRISJbits.TRISJ2
#define digital_io_13 TRISJbits.TRISJ3
#endif
#define digital_io_14 TRISCbits.TRISC0
#define digital_io_15 TRISJbits.TRISJ4
#define digital_io_16 TRISJbits.TRISJ5
#define digital_io_17 TRISJbits.TRISJ6
#define digital_io_18 TRISJbits.TRISJ7
/* Aliases used to read the pins when used as INPUTS. */
#define rc_dig_in01 PORTBbits.RB2
#define rc_dig_in02 PORTBbits.RB3
#define rc_dig_in03 PORTBbits.RB4
#define rc_dig_in04 PORTBbits.RB5
#define rc_dig_in05 PORTBbits.RB6
#define rc_dig_in06 PORTBbits.RB7
#define rc_dig_in07 PORTHbits.RH0
#define rc_dig_in08 PORTHbits.RH1
#define rc_dig_in09 PORTHbits.RH2
#define rc_dig_in10 PORTHbits.RH3
#ifdef _FRC_NC1
#define rc_dig_in11 PORTGbits.RG0
#define rc_dig_in12 PORTGbits.RG3
#define rc_dig_in13 PORTGbits.RG4
#else
#define rc_dig_in11 PORTJbits.RJ1
#define rc_dig_in12 PORTJbits.RJ2
#define rc_dig_in13 PORTJbits.RJ3
#endif
#define rc_dig_in14 PORTCbits.RC0
#define rc_dig_in15 PORTJbits.RJ4
#define rc_dig_in16 PORTJbits.RJ5
#define rc_dig_in17 PORTJbits.RJ6
#define rc_dig_in18 PORTJbits.RJ7
/* Aliases used to drive the pins when used as OUTPUTS. */
#define rc_dig_out01 LATBbits.LATB2
#define rc_dig_out02 LATBbits.LATB3
#define rc_dig_out03 LATBbits.LATB4
#define rc_dig_out04 LATBbits.LATB5
#define rc_dig_out05 LATBbits.LATB6
#define rc_dig_out06 LATBbits.LATB7
#define rc_dig_out07 LATHbits.LATH0
#define rc_dig_out08 LATHbits.LATH1
#define rc_dig_out09 LATHbits.LATH2
#define rc_dig_out10 LATHbits.LATH3
#ifdef _FRC_NC1
#define rc_dig_out11 LATGbits.LATG0
#define rc_dig_out12 LATGbits.LATG3
#define rc_dig_out13 LATGbits.LATG4
#else
#define rc_dig_out11 LATJbits.LATJ1
#define rc_dig_out12 LATJbits.LATJ2
#define rc_dig_out13 LATJbits.LATJ3
#endif
#define rc_dig_out14 LATCbits.LATC0
#define rc_dig_out15 LATJbits.LATJ4
#define rc_dig_out16 LATJbits.LATJ5
#define rc_dig_out17 LATJbits.LATJ6
#define rc_dig_out18 LATJbits.LATJ7
/*
*-----------------------------------------------------------------------------------------------------
*---------- Aliases for PWM OUTPUTS ------------------------------------------------------------------
*-----------------------------------------------------------------------------------------------------
* Below are aliases for the PWM OUTPUTS located on the Robot Controller.
*/
#define pwm01 txdata.rc_pwm01
#define pwm02 txdata.rc_pwm02
#define pwm03 txdata.rc_pwm03
#define pwm04 txdata.rc_pwm04
#define pwm05 txdata.rc_pwm05
#define pwm06 txdata.rc_pwm06
#define pwm07 txdata.rc_pwm07
#define pwm08 txdata.rc_pwm08
#define pwm09 txdata.rc_pwm09
#define pwm10 txdata.rc_pwm10
#define pwm11 txdata.rc_pwm11
#define pwm12 txdata.rc_pwm12
#define pwm13 txdata.rc_pwm13
#define pwm14 txdata.rc_pwm14
#define pwm15 txdata.rc_pwm15
#define pwm16 txdata.rc_pwm16
/*
*-----------------------------------------------------------------------------------------------------
*---------- Aliases for RELAY OUTPUTS conncectors ----------------------------------------------------
*-----------------------------------------------------------------------------------------------------
* Below are aliases for the relay outputs located on the Robot Controller.
*/
#define relay1_fwd LATDbits.LATD0
#define relay1_rev LATEbits.LATE0
#define relay2_fwd LATDbits.LATD1
#define relay2_rev LATEbits.LATE1
#define relay3_fwd LATDbits.LATD2
#define relay3_rev LATEbits.LATE2
#define relay4_fwd LATDbits.LATD3
#define relay4_rev LATEbits.LATE3
#define relay5_fwd LATDbits.LATD4
#define relay5_rev LATEbits.LATE4
#define relay6_fwd LATDbits.LATD5
#define relay6_rev LATEbits.LATE5
#define relay7_fwd LATDbits.LATD6
#define relay7_rev LATEbits.LATE6
#define relay8_fwd LATDbits.LATD7
#ifdef _FRC_NC1
#define relay8_rev LATEbits.LATE7
#else
#define relay8_rev LATJbits.LATJ0
#endif
/*
*-----------------------------------------------------------------------------------------------------
*---------- Aliases for ANALOG INPUTS connectors -----------------------------------------------------
*-----------------------------------------------------------------------------------------------------
* Below are aliases for the analog input pins located on the Robot Controller.
* vvvvvvvv You can change these aliases, but they are descriptive of the default setup.
*/
/* Used in Get_Analog_Value routine. */
#define rc_ana_in01 ADC_CH0
#define rc_ana_in02 ADC_CH1
#define rc_ana_in03 ADC_CH2
#define rc_ana_in04 ADC_CH3
#define rc_ana_in05 ADC_CH4
#define rc_ana_in06 ADC_CH5
#define rc_ana_in07 ADC_CH6
#define rc_ana_in08 ADC_CH7
#define rc_ana_in09 ADC_CH8
#define rc_ana_in10 ADC_CH9
#define rc_ana_in11 ADC_CH10
#define rc_ana_in12 ADC_CH11
#define rc_ana_in13 ADC_CH12
#define rc_ana_in14 ADC_CH13
#define rc_ana_in15 ADC_CH14
#define rc_ana_in16 ADC_CH15
/* Optionally used in User_Initialization routine in user_routines.c file. */
#define NO_ANALOG ADC_0ANA /* All digital */
#define ONE_ANALOG ADC_1ANA /* analog: AN0 digital: AN1->15 */
#define TWO_ANALOG ADC_2ANA /* analog: AN0->1 digital: AN2->15 */
#define THREE_ANALOG ADC_3ANA /* analog: AN0->2 digital: AN3->15 */
#define FOUR_ANALOG ADC_4ANA /* analog: AN0->3 digital: AN4->15 */
#define FIVE_ANALOG ADC_5ANA /* analog: AN0->4 digital: AN5->15 */
#define SIX_ANALOG ADC_6ANA /* analog: AN0->5 digital: AN6->15 */
#define SEVEN_ANALOG ADC_7ANA /* analog: AN0->6 digital: AN7->15 */
#define EIGHT_ANALOG ADC_8ANA /* analog: AN0->7 digital: AN8->15 */
#define NINE_ANALOG ADC_9ANA /* analog: AN0->8 digital: AN9->15 */
#define TEN_ANALOG ADC_10ANA /* analog: AN0->9 digital: AN10->15 */
#define ELEVEN_ANALOG ADC_11ANA /* analog: AN0->10 digital: AN11->15 */
#define TWELVE_ANALOG ADC_12ANA /* analog: AN0->11 digital: AN12->15 */
#define THIRTEEN_ANALOG ADC_13ANA /* analog: AN0->12 digital: AN13->15 */
#define FOURTEEN_ANALOG ADC_14ANA /* analog: AN0->13 digital: AN14->15 */
/* There is no FIFTEEN_ANALOG! */
#define SIXTEEN_ANALOG ADC_16ANA /* All analog */
/* The following aliases are probably not needed. */
#define rc_a2d_pin01 PORTAbits.RA0
#define rc_a2d_pin02 PORTAbits.RA1
#define rc_a2d_pin03 PORTAbits.RA2
#define rc_a2d_pin04 PORTAbits.RA3
#define rc_a2d_pin05 PORTAbits.RA5
#define rc_a2d_pin06 PORTFbits.RF0
#define rc_a2d_pin07 PORTFbits.RF1
#define rc_a2d_pin08 PORTFbits.RF2
#define rc_a2d_pin09 PORTFbits.RF3
#define rc_a2d_pin10 PORTFbits.RF4
#define rc_a2d_pin11 PORTFbits.RF5
#define rc_a2d_pin12 PORTFbits.RF6
#define rc_a2d_pin13 PORTHbits.RH4
#define rc_a2d_pin14 PORTHbits.RH5
#define rc_a2d_pin15 PORTHbits.RH6
#define rc_a2d_pin16 PORTHbits.RH7
/*
*-----------------------------------------------------------------------------------------------------
*---------- Aliases for the ROBOT FEEDBACK LEDs ------------------------------------------------------
*-----------------------------------------------------------------------------------------------------
* Below are aliases for the ROBOT FEEDBACK LEDs located on the Operator Interface.
*/
#define pwm1_green txdata.LED_byte1.bitselect.bit0
#define pwm1_red txdata.LED_byte1.bitselect.bit1
#define pwm2_green txdata.LED_byte1.bitselect.bit2
#define pwm2_red txdata.LED_byte1.bitselect.bit3
#define Relay1_green txdata.LED_byte1.bitselect.bit4
#define Relay1_red txdata.LED_byte1.bitselect.bit5
#define Relay2_green txdata.LED_byte1.bitselect.bit6
#define Relay2_red txdata.LED_byte1.bitselect.bit7
#define Switch1_LED txdata.LED_byte2.bitselect.bit0
#define Switch2_LED txdata.LED_byte2.bitselect.bit1
#define Switch3_LED txdata.LED_byte2.bitselect.bit2
/*
*-----------------------------------------------------------------------------------------------------
*---------- Alias for Battery Voltage ---------------------------------------------------------------
*-----------------------------------------------------------------------------------------------------
* current voltage = battery_voltage * 0.038 + 0.05;
*/
#define battery_voltage rxdata.rc_analog01
/*
*-----------------------------------------------------------------------------------------------------
*---------- Aliases for User Modes ------------------------------------------------------------------
*-----------------------------------------------------------------------------------------------------
*/
#define user_display_mode rxdata.rc_mode_byte.mode.user_display
#define autonomous_mode rxdata.rc_mode_byte.mode.autonomous
#define competition_mode rxdata.rc_mode_byte.mode.disabled
#endif
/*---------------------------------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------------------------------*/
/*******************************************************************************
* FILE NAME: ifi_default.h
*
* DESCRIPTION:
* This file contains important data definitions.
*
* DO NOT EDIT THIS FILE!
*******************************************************************************/
#ifndef __ifi_default_h_
#define __ifi_default_h_
#include "ifi_picdefs.h"
#ifdef UNCHANGEABLE_DEFINITION_AREA
/*******************************************************************************
ALIAS DEFINITIONS
*******************************************************************************/
/* DO NOT CHANGE! */
#define DATA_SIZE 30
#define SPI_TRAILER_SIZE 2
#define SPI_XFER_SIZE DATA_SIZE + SPI_TRAILER_SIZE
#define RESET_VECTOR 0x800
#define HIGH_INT_VECTOR 0x808
#define LOW_INT_VECTOR 0x818
/*******************************************************************************
VARIABLE DECLARATIONS
*******************************************************************************/
/* DO NOT CHANGE! */
/* This structure contains important system status information. */
typedef struct
{
unsigned int :5;
unsigned int user_display:1; /* User display enabled = 1, disabled = 0 */
unsigned int autonomous:1; /* Autonomous enabled = 1, disabled = 0 */
unsigned int disabled:1; /* Competition enabled = 1, disabled = 0 */
} modebits;
/******************************************************************************/
/* DO NOT CHANGE! */
/* This structure allows you to address specific bits of a byte.*/
typedef struct
{
unsigned int bit0:1;
unsigned int bit1:1;
unsigned int bit2:1;
unsigned int bit3:1;
unsigned int bit4:1;
unsigned int bit5:1;
unsigned int bit6:1;
unsigned int bit7:1;
} bitid;
/******************************************************************************/
/* DO NOT CHANGE! */
/* This structure defines the contents of the data received from the Master
* microprocessor. */
typedef struct { /* begin rx_data_record structure */
unsigned char packet_num;
union
{
bitid bitselect;
modebits mode; /*rxdata.rc_mode_byte.mode.(user_display|autonomous|disabled)*/
unsigned char allbits; /*rxdata.rc_mode_byte.allbits*/
} rc_mode_byte;
union
{
bitid bitselect; /*rxdata.oi_swA_byte.bitselect.bit0*/
unsigned char allbits; /*rxdata.oi_swA_byte.allbits*/
} oi_swA_byte;
union
{
bitid bitselect; /*rxdata.oi_swB_byte.bitselect.bit0*/
unsigned char allbits; /*rxdata.oi_swB_byte.allbits*/
} oi_swB_byte;
union
{
bitid bitselect; /*rxdata.rc_swA_byte.bitselect.bit0*/
unsigned char allbits; /*rxdata.rc_swA_byte.allbits*/
} rc_swA_byte;
union
{
bitid bitselect; /*rxdata.rc_swB_byte.bitselect.bit0*/
unsigned char allbits; /*rxdata.rc_swB_byte.allbits*/
} rc_swB_byte;
unsigned char oi_analog01, oi_analog02, oi_analog03, oi_analog04; /*rxdata.oi_analog01*/
unsigned char oi_analog05, oi_analog06, oi_analog07, oi_analog08;
unsigned char oi_analog09, oi_analog10, oi_analog11, oi_analog12;
unsigned char oi_analog13, oi_analog14, oi_analog15, oi_analog16;
unsigned char rc_analog01, rc_analog02, rc_analog03, rc_analog04;
unsigned char rc_analog05, rc_analog06, rc_analog07, rc_analog08;
unsigned char res01, res02;
} rx_data_record;
typedef rx_data_record *rx_data_ptr;
/******************************************************************************/
/* DO NOT CHANGE! */
/* This structure defines the contents of the data transmitted to the master
* microprocessor. */
typedef struct { /*begin tx_data_record structure*/
union
{
bitid bitselect; /*txdata.LED_byte1.bitselect.bit0*/
unsigned char data; /*txdata.LED_byte1.data*/
} LED_byte1;
union
{
bitid bitselect; /*txdata.LED_byte1.bitselect.bit0*/
unsigned char data; /*txdata.LED_byte1.data*/
} LED_byte2;
union
{
bitid bitselect; /*txdata.relayA.bitselect.bit0*/
unsigned char allbits; /*txdata.relayA.allbits*/
} relayA;
union
{
bitid bitselect; /*txdata.relayB.bitselect.bit0*/
unsigned char allbits; /*txdata.relayB.allbits*/
} relayB;
unsigned char rc_pwm01, rc_pwm02, rc_pwm03, rc_pwm04; /*txdata.rc_pwm01*/
unsigned char rc_pwm05, rc_pwm06, rc_pwm07, rc_pwm08;
unsigned char rc_pwm09, rc_pwm10, rc_pwm11, rc_pwm12;
unsigned char rc_pwm13, rc_pwm14, rc_pwm15, rc_pwm16;
unsigned char user_cmd; /*reserved - for future use*/
unsigned char cmd_byte1; /*reserved - Don't use*/
unsigned char pwm_mask; /*<EDU> make sure you know how this works before changing*/
unsigned char warning_code; /*reserved - Don't use*/
unsigned char reserve[4]; /*reserved - Don't use (0-3)*/
unsigned char error_code; /*reserved - Don't use*/
unsigned char packetnum; /*reserved - Don't use*/
unsigned char current_mode; /*reserved - Don't use*/
unsigned char control; /*reserved - Don't use*/
} tx_data_record;
typedef tx_data_record *tx_data_ptr;
/******************************************************************************/
/* DO NOT CHANGE! */
/* This structure defines some flags which are used by the system. */
typedef struct
{
unsigned int NEW_SPI_DATA:1;
unsigned int TX_UPDATED:1;
unsigned int FIRST_TIME:1;
unsigned int TX_BUFFSELECT:1;
unsigned int RX_BUFFSELECT:1;
unsigned int :3;
} packed_struct;
/******************************************************************************/
extern tx_data_record txdata;
extern rx_data_record rxdata;
extern packed_struct statusflag;
#else
#error *** Error - Invalid Default File!
#endif
/*******************************************************************************
FUNCTION PROTOTYPES
*******************************************************************************/
/* These routines reside in ifi_library.lib */
void InterruptHandlerHigh (void);
void Initialize_Registers (void);
void IFI_Initialization (void);
void User_Proc_Is_Ready (void);
void Putdata(tx_data_ptr ptr);
void Getdata(rx_data_ptr ptr);
void Clear_SPIdata_flag(void);
void Setup_PWM_Output_Type(int pwmSpec1,int pwmSpec2,int pwmSpec3,int pwmSpec4);
#endif
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/*******************************************************************************
* FILE NAME: ifi_picdef.h
*
* DESCRIPTION:
* This include file contains definitions for the 18f8520 PICmicro. All
* register definitions are explained in detail in the PIC18FXX20 Data Sheet.
*
* USAGE:
* Refer to this file to determine if a register is off-limits to the user.
* Registers and bits marked by "Reserved - Do not use" should not be modified
* by the user's code or else the Robot Controller will not function.
* WARNING:
* DO NOT MODIFY THIS FILE!
*******************************************************************************/
#ifndef __ifi_picdefs_h_
#define __ifi_picdefs_h_
extern volatile near unsigned char RCSTA2;
extern volatile near union {
struct {
unsigned RX9D:1;
unsigned OERR:1;
unsigned FERR:1;
unsigned ADEN:1;
unsigned CREN:1;
unsigned SREN:1;
unsigned RX9:1;
unsigned SPEN:1;
};
struct {
unsigned RCD8:1;
unsigned :5;
unsigned RC9:1;
};
struct {
unsigned :6;
unsigned NOT_RC8:1;
};
struct {
unsigned :6;
unsigned RC8_9:1;
};
} RCSTA2bits;
extern volatile near unsigned char TXSTA2;
extern volatile near union {
struct {
unsigned TX9D:1;
unsigned TRMT:1;
unsigned BRGH:1;
unsigned :1;
unsigned SYNC:1;
unsigned TXEN:1;
unsigned TX9:1;
unsigned CSRC:1;
};
struct {
unsigned TXD8:1;
unsigned :5;
unsigned TX8_9:1;
};
struct {
unsigned :6;
unsigned NOT_TX8:1;
};
} TXSTA2bits;
extern volatile near unsigned char TXREG2;
extern volatile near unsigned char RCREG2;
extern volatile near unsigned char SPBRG2;
extern volatile near unsigned char CCP5CON;
extern volatile near union {
struct {
unsigned CCP5M0:1;
unsigned CCP5M1:1;
unsigned CCP5M2:1;
unsigned CCP5M3:1;
unsigned DCCP5Y:1;
unsigned DCCP5X:1;
};
struct {
unsigned :4;
unsigned DC5B0:1;
unsigned DC5B1:1;
};
} CCP5CONbits;
extern volatile near unsigned CCPR5;
extern volatile near unsigned char CCPR5L;
extern volatile near unsigned char CCPR5H;
extern volatile near unsigned char CCP4CON;
extern volatile near union {
struct {
unsigned CCP4M0:1;
unsigned CCP4M1:1;
unsigned CCP4M2:1;
unsigned CCP4M3:1;
unsigned DCCP4Y:1;
unsigned DCCP4X:1;
};
struct {
unsigned :4;
unsigned DC4B0:1;
unsigned DC4B1:1;
};
} CCP4CONbits;
extern volatile near unsigned CCPR4;
extern volatile near unsigned char CCPR4L;
extern volatile near unsigned char CCPR4H;
extern volatile near unsigned char T4CON;
extern volatile near struct {
unsigned T4CKPS0:1;
unsigned T4CKPS1:1;
unsigned TMR4ON:1;
unsigned T4OUTPS0:1;
unsigned T4OUTPS1:1;
unsigned T4OUTPS2:1;
unsigned T4OUTPS3:1;
} T4CONbits;
extern volatile near unsigned char PR4;
extern volatile near unsigned char TMR4;
extern volatile near unsigned char PORTA;
extern volatile near union {
struct {
unsigned RA0:1;
unsigned RA1:1;
unsigned RA2:1;
unsigned RA3:1;
unsigned RA4:1; /* Reserved - Do not use */
unsigned RA5:1;
unsigned RA6:1;
};
struct {
unsigned AN0:1;
unsigned AN1:1;
unsigned AN2:1;
unsigned AN3:1;
unsigned T0CKI:1; /* Reserved - Do not use */
unsigned AN4:1;
unsigned OSC2:1;
};
struct {
unsigned :2;
unsigned VREFM:1;
unsigned VREFP:1;
unsigned :1;
unsigned LVDIN:1;
unsigned CLKO:1;
};
} PORTAbits;
extern volatile near unsigned char PORTB;
extern volatile near union {
struct {
unsigned RB0:1; /* Reserved - Do not use */
unsigned RB1:1;
unsigned RB2:1;
unsigned RB3:1;
unsigned RB4:1;
unsigned RB5:1;
unsigned RB6:1;
unsigned RB7:1;
};
struct {
unsigned INT0:1; /* Reserved - Do not use */
unsigned INT1:1;
unsigned INT2:1;
unsigned INT3:1;
unsigned KBI0:1;
unsigned KBI1:1;
unsigned KBI2:1;
unsigned KBI3:1;
};
struct {
unsigned :3;
unsigned CCP2B:1;
unsigned :1;
unsigned PGM:1;
unsigned PGC:1;
unsigned PGD:1;
};
} PORTBbits;
extern volatile near unsigned char PORTC;
extern volatile near union {
struct {
unsigned RC0:1;
unsigned RC1:1; /* Reserved - Do not use */
unsigned RC2:1; /* Reserved - Do not use */
unsigned RC3:1; /* Reserved - Do not use */
unsigned RC4:1; /* Reserved - Do not use */
unsigned RC5:1; /* Reserved - Do not use */
unsigned RC6:1;
unsigned RC7:1;
};
struct {
unsigned T1OSO:1;
unsigned T1OSI:1; /* Reserved - Do not use */
unsigned CCP1:1; /* Reserved - Do not use */
unsigned SCK:1; /* Reserved - Do not use */
unsigned SDI:1; /* Reserved - Do not use */
unsigned SDO:1; /* Reserved - Do not use */
unsigned TX:1;
unsigned RX:1;
};
struct {
unsigned T13CKI:1;
unsigned CCP2C:1; /* Reserved - Do not use */
unsigned :1;
unsigned SCL:1; /* Reserved - Do not use */
unsigned SDA:1; /* Reserved - Do not use */
unsigned :1; /* Reserved - Do not use */
unsigned CK:1;
unsigned DT:1;
};
} PORTCbits;
extern volatile near unsigned char PORTD;
extern volatile near union {
struct {
unsigned RD0:1;
unsigned RD1:1;
unsigned RD2:1;
unsigned RD3:1;
unsigned RD4:1;
unsigned RD5:1;
unsigned RD6:1;
unsigned RD7:1;
};
struct {
unsigned PSP0:1;
unsigned PSP1:1;
unsigned PSP2:1;
unsigned PSP3:1;
unsigned PSP4:1;
unsigned PSP5:1;
unsigned PSP6:1;
unsigned PSP7:1;
};
struct {
unsigned AD0:1;
unsigned AD1:1;
unsigned AD2:1;
unsigned AD3:1;
unsigned AD4:1;
unsigned AD5:1;
unsigned AD6:1;
unsigned AD7:1;
};
} PORTDbits;
extern volatile near unsigned char PORTE;
extern volatile near union {
struct {
unsigned RE0:1;
unsigned RE1:1;
unsigned RE2:1;
unsigned RE3:1;
unsigned RE4:1;
unsigned RE5:1;
unsigned RE6:1;
unsigned RE7:1;
};
struct {
unsigned RD:1;
unsigned WR:1;
unsigned CS:1;
unsigned :4;
unsigned CCP2E:1;
};
struct {
unsigned AD8:1;
unsigned AD9:1;
unsigned AD10:1;
unsigned AD11:1;
unsigned AD12:1;
unsigned AD13:1;
unsigned AD14:1;
unsigned AD15:1;
};
} PORTEbits;
extern volatile near unsigned char PORTF;
extern volatile near union {
struct {
unsigned RF0:1;
unsigned RF1:1;
unsigned RF2:1;
unsigned RF3:1;
unsigned RF4:1;
unsigned RF5:1;
unsigned RF6:1;
unsigned RF7:1; /* Reserved - Do not use */
};
struct {
unsigned AN5:1;
unsigned AN6:1;
unsigned AN7:1;
unsigned AN8:1;
unsigned AN9:1;
unsigned AN10:1;
unsigned AN11:1;
unsigned SS:1; /* Reserved - Do not use */
};
struct {
unsigned :1;
unsigned C2OUTF:1;
unsigned C1OUTF:1;
unsigned :2;
unsigned CVREFF:1; /* Reserved - Do not use */
};
} PORTFbits;
extern volatile near unsigned char PORTG;
extern volatile near union {
struct {
unsigned RG0:1;
unsigned RG1:1;
unsigned RG2:1;
unsigned RG3:1;
unsigned RG4:1;
};
struct {
unsigned CCP3:1;
unsigned TX2:1;
unsigned RX2:1;
unsigned CCP4:1;
unsigned CCP5:1;
};
struct {
unsigned :1;
unsigned CK2:1;
unsigned DT2:1;
};
} PORTGbits;
extern volatile near unsigned char PORTH;
extern volatile near union {
struct {
unsigned RH0:1;
unsigned RH1:1;
unsigned RH2:1;
unsigned RH3:1;
unsigned RH4:1;
unsigned RH5:1;
unsigned RH6:1;
unsigned RH7:1;
};
struct {
unsigned A16:1;
unsigned A17:1;
unsigned A18:1;
unsigned A19:1;
unsigned AN12:1;
unsigned AN13:1;
unsigned AN14:1;
unsigned AN15:1;
};
} PORTHbits;
extern volatile near unsigned char PORTJ;
extern volatile near union {
struct {
unsigned RJ0:1;
unsigned RJ1:1;
unsigned RJ2:1;
unsigned RJ3:1;
unsigned RJ4:1;
unsigned RJ5:1;
unsigned RJ6:1;
unsigned RJ7:1;
};
struct {
unsigned ALE:1;
unsigned OE:1;
unsigned WRL:1;
unsigned WRH:1;
unsigned BA0:1;
unsigned CE:1;
unsigned LB:1;
unsigned UB:1;
};
} PORTJbits;
extern volatile near unsigned char LATA;
extern volatile near struct {
unsigned LATA0:1;
unsigned LATA1:1;
unsigned LATA2:1;
unsigned LATA3:1;
unsigned LATA4:1; /* Reserved - Do not use */
unsigned LATA5:1;
unsigned LATA6:1;
} LATAbits;
extern volatile near unsigned char LATB;
extern volatile near struct {
unsigned LATB0:1; /* Reserved - Do not use */
unsigned LATB1:1;
unsigned LATB2:1;
unsigned LATB3:1;
unsigned LATB4:1;
unsigned LATB5:1;
unsigned LATB6:1;
unsigned LATB7:1;
} LATBbits;
extern volatile near unsigned char LATC;
extern volatile near struct {
unsigned LATC0:1;
unsigned LATC1:1; /* Reserved - Do not use */
unsigned LATC2:1; /* Reserved - Do not use */
unsigned LATC3:1; /* Reserved - Do not use */
unsigned LATC4:1; /* Reserved - Do not use */
unsigned LATC5:1; /* Reserved - Do not use */
unsigned LATC6:1;
unsigned LATC7:1;
} LATCbits;
extern volatile near unsigned char LATD;
extern volatile near struct {
unsigned LATD0:1;
unsigned LATD1:1;
unsigned LATD2:1;
unsigned LATD3:1;
unsigned LATD4:1;
unsigned LATD5:1;
unsigned LATD6:1;
unsigned LATD7:1;
} LATDbits;
extern volatile near unsigned char LATE;
extern volatile near struct {
unsigned LATE0:1;
unsigned LATE1:1;
unsigned LATE2:1;
unsigned LATE3:1;
unsigned LATE4:1;
unsigned LATE5:1;
unsigned LATE6:1;
unsigned LATE7:1;
} LATEbits;
extern volatile near unsigned char LATF;
extern volatile near struct {
unsigned LATF0:1;
unsigned LATF1:1;
unsigned LATF2:1;
unsigned LATF3:1;
unsigned LATF4:1;
unsigned LATF5:1;
unsigned LATF6:1;
unsigned LATF7:1; /* Reserved - Do not use */
} LATFbits;
extern volatile near unsigned char LATG;
extern volatile near struct {
unsigned LATG0:1;
unsigned LATG1:1;
unsigned LATG2:1;
unsigned LATG3:1;
unsigned LATG4:1;
} LATGbits;
extern volatile near unsigned char LATH;
extern volatile near struct {
unsigned LATH0:1;
unsigned LATH1:1;
unsigned LATH2:1;
unsigned LATH3:1;
unsigned LATH4:1;
unsigned LATH5:1;
unsigned LATH6:1;
unsigned LATH7:1;
} LATHbits;
extern volatile near unsigned char LATJ;
extern volatile near struct {
unsigned LATJ0:1;
unsigned LATJ1:1;
unsigned LATJ2:1;
unsigned LATJ3:1;
unsigned LATJ4:1;
unsigned LATJ5:1;
unsigned LATJ6:1;
unsigned LATJ7:1;
} LATJbits;
extern volatile near unsigned char TRISA;
extern volatile near struct {
unsigned TRISA0:1;
unsigned TRISA1:1;
unsigned TRISA2:1;
unsigned TRISA3:1;
unsigned TRISA4:1; /* Reserved - Do not use */
unsigned TRISA5:1;
unsigned TRISA6:1;
} TRISAbits;
extern volatile near unsigned char DDRA;
extern volatile near struct {
unsigned RA0:1;
unsigned RA1:1;
unsigned RA2:1;
unsigned RA3:1;
unsigned RA4:1; /* Reserved - Do not use */
unsigned RA5:1;
unsigned RA6:1;
} DDRAbits;
extern volatile near unsigned char DDRB;
extern volatile near struct {
unsigned RB0:1; /* Reserved - Do not use */
unsigned RB1:1;
unsigned RB2:1;
unsigned RB3:1;
unsigned RB4:1;
unsigned RB5:1;
unsigned RB6:1;
unsigned RB7:1;
} DDRBbits;
extern volatile near unsigned char TRISB;
extern volatile near struct {
unsigned TRISB0:1; /* Reserved - Do not use */
unsigned TRISB1:1;
unsigned TRISB2:1;
unsigned TRISB3:1;
unsigned TRISB4:1;
unsigned TRISB5:1;
unsigned TRISB6:1;
unsigned TRISB7:1;
} TRISBbits;
extern volatile near unsigned char DDRC;
extern volatile near struct {
unsigned RC0:1;
unsigned RC1:1; /* Reserved - Do not use */
unsigned RC2:1; /* Reserved - Do not use */
unsigned RC3:1; /* Reserved - Do not use */
unsigned RC4:1; /* Reserved - Do not use */
unsigned RC5:1; /* Reserved - Do not use */
unsigned RC6:1;
unsigned RC7:1;
} DDRCbits;
extern volatile near unsigned char TRISC;
extern volatile near struct {
unsigned TRISC0:1;
unsigned TRISC1:1; /* Reserved - Do not use */
unsigned TRISC2:1; /* Reserved - Do not use */
unsigned TRISC3:1; /* Reserved - Do not use */
unsigned TRISC4:1; /* Reserved - Do not use */
unsigned TRISC5:1; /* Reserved - Do not use */
unsigned TRISC6:1;
unsigned TRISC7:1;
} TRISCbits;
extern volatile near unsigned char DDRD;
extern volatile near struct {
unsigned RD0:1;
unsigned RD1:1;
unsigned RD2:1;
unsigned RD3:1;
unsigned RD4:1;
unsigned RD5:1;
unsigned RD6:1;
unsigned RD7:1;
} DDRDbits;
extern volatile near unsigned char TRISD;
extern volatile near struct {
unsigned TRISD0:1;
unsigned TRISD1:1;
unsigned TRISD2:1;
unsigned TRISD3:1;
unsigned TRISD4:1;
unsigned TRISD5:1;
unsigned TRISD6:1;
unsigned TRISD7:1;
} TRISDbits;
extern volatile near unsigned char DDRE;
extern volatile near struct {
unsigned RE0:1;
unsigned RE1:1;
unsigned RE2:1;
unsigned RE3:1;
unsigned RE4:1;
unsigned RE5:1;
unsigned RE6:1;
unsigned RE7:1;
} DDREbits;
extern volatile near unsigned char TRISE;
extern volatile near struct {
unsigned TRISE0:1;
unsigned TRISE1:1;
unsigned TRISE2:1;
unsigned TRISE3:1;
unsigned TRISE4:1;
unsigned TRISE5:1;
unsigned TRISE6:1;
unsigned TRISE7:1;
} TRISEbits;
extern volatile near unsigned char TRISF;
extern volatile near struct {
unsigned TRISF0:1;
unsigned TRISF1:1;
unsigned TRISF2:1;
unsigned TRISF3:1;
unsigned TRISF4:1;
unsigned TRISF5:1;
unsigned TRISF6:1;
unsigned TRISF7:1; /* Reserved - Do not use */
} TRISFbits;
extern volatile near unsigned char DDRF;
extern volatile near struct {
unsigned RF0:1;
unsigned RF1:1;
unsigned RF2:1;
unsigned RF3:1;
unsigned RF4:1;
unsigned RF5:1;
unsigned RF6:1;
unsigned RF7:1; /* Reserved - Do not use */
} DDRFbits;
extern volatile near unsigned char DDRG;
extern volatile near struct {
unsigned RG0:1;
unsigned RG1:1;
unsigned RG2:1;
unsigned RG3:1;
unsigned RG4:1;
} DDRGbits;
extern volatile near unsigned char TRISG;
extern volatile near struct {
unsigned TRISG0:1;
unsigned TRISG1:1;
unsigned TRISG2:1;
unsigned TRISG3:1;
unsigned TRISG4:1;
} TRISGbits;
extern volatile near unsigned char DDRH;
extern volatile near struct {
unsigned RH0:1;
unsigned RH1:1;
unsigned RH2:1;
unsigned RH3:1;
unsigned RH4:1;
unsigned RH5:1;
unsigned RH6:1;
unsigned RH7:1;
} DDRHbits;
extern volatile near unsigned char TRISH;
extern volatile near struct {
unsigned TRISH0:1;
unsigned TRISH1:1;
unsigned TRISH2:1;
unsigned TRISH3:1;
unsigned TRISH4:1;
unsigned TRISH5:1;
unsigned TRISH6:1;
unsigned TRISH7:1;
} TRISHbits;
extern volatile near unsigned char DDRJ;
extern volatile near struct {
unsigned RJ0:1;
unsigned RJ1:1;
unsigned RJ2:1;
unsigned RJ3:1;
unsigned RJ4:1;
unsigned RJ5:1;
unsigned RJ6:1;
unsigned RJ7:1;
} DDRJbits;
extern volatile near unsigned char TRISJ;
extern volatile near struct {
unsigned TRISJ0:1;
unsigned TRISJ1:1;
unsigned TRISJ2:1;
unsigned TRISJ3:1;
unsigned TRISJ4:1;
unsigned TRISJ5:1;
unsigned TRISJ6:1;
unsigned TRISJ7:1;
} TRISJbits;
extern volatile near unsigned char MEMCON; /* Reserved - Do not use */
extern volatile near struct {
unsigned WM0:1;
unsigned WM1:1;
unsigned :2;
unsigned WAIT0:1;
unsigned WAIT1:1;
unsigned :1;
unsigned EBDIS:1;
} MEMCONbits; /* Reserved - Do not use */
extern volatile near unsigned char PIE1;
extern volatile near union {
struct {
unsigned TMR1IE:1;
unsigned TMR2IE:1;
unsigned CCP1IE:1;
unsigned SSPIE:1; /* Reserved - Do not use */
unsigned TX1IE:1;
unsigned RC1IE:1;
unsigned ADIE:1;
unsigned PSPIE:1; /* Reserved - Do not use */
};
struct {
unsigned :4;
unsigned TXIE:1;
unsigned RCIE:1;
};
} PIE1bits;
extern volatile near unsigned char PIR1;
extern volatile near union {
struct {
unsigned TMR1IF:1;
unsigned TMR2IF:1;
unsigned CCP1IF:1;
unsigned SSPIF:1; /* Reserved - Do not use */
unsigned TX1IF:1;
unsigned RC1IF:1;
unsigned ADIF:1;
unsigned PSPIF:1; /* Reserved - Do not use */
};
struct {
unsigned :4;
unsigned TXIF:1;
unsigned RCIF:1;
};
} PIR1bits;
extern volatile near unsigned char IPR1; /* Reserved - Do not use */
extern volatile near union {
struct {
unsigned TMR1IP:1;
unsigned TMR2IP:1;
unsigned CCP1IP:1;
unsigned SSPIP:1;
unsigned TX1IP:1;
unsigned RC1IP:1;
unsigned ADIP:1;
unsigned PSPIP:1;
};
struct {
unsigned :4;
unsigned TXIP:1;
unsigned RCIP:1;
};
} IPR1bits; /* Reserved - Do not use */
extern volatile near unsigned char PIE2;
extern volatile near struct {
unsigned CCP2IE:1;
unsigned TMR3IE:1;
unsigned LVDIE:1; /* Reserved - Do not use */
unsigned BCLIE:1; /* Reserved - Do not use */
unsigned EEIE:1; /* Reserved - Do not use */
unsigned :1;
unsigned CMIE:1;
} PIE2bits;
extern volatile near unsigned char PIR2;
extern volatile near struct {
unsigned CCP2IF:1;
unsigned TMR3IF:1;
unsigned LVDIF:1; /* Reserved - Do not use */
unsigned BCLIF:1; /* Reserved - Do not use */
unsigned EEIF:1; /* Reserved - Do not use */
unsigned :1;
unsigned CMIF:1;
} PIR2bits;
extern volatile near unsigned char IPR2; /* Reserved - Do not use */
extern volatile near struct {
unsigned CCP2IP:1;
unsigned TMR3IP:1;
unsigned LVDIP:1;
unsigned BCLIP:1;
unsigned EEIP:1;
unsigned :1;
unsigned CMIP:1;
} IPR2bits; /* Reserved - Do not use */
extern volatile near unsigned char PIE3;
extern volatile near struct {
unsigned CCP3IE:1;
unsigned CCP4IE:1;
unsigned CCP5IE:1;
unsigned TMR4IE:1;
unsigned TX2IE:1;
unsigned RC2IE:1;
} PIE3bits;
extern volatile near unsigned char PIR3;
extern volatile near struct {
unsigned CCP3IF:1;
unsigned CCP4IF:1;
unsigned CCP5IF:1;
unsigned TMR4IF:1;
unsigned TX2IF:1;
unsigned RC2IF:1;
} PIR3bits;
extern volatile near unsigned char IPR3; /* Reserved - Do not use */
extern volatile near struct {
unsigned CCP3IP:1;
unsigned CCP4IP:1;
unsigned CCP5IP:1;
unsigned TMR4IP:1;
unsigned TX2IP:1;
unsigned RC2IP:1;
} IPR3bits; /* Reserved - Do not use */
extern volatile near unsigned char EECON1; /* Use with caution. */
extern volatile near struct {
unsigned RD:1;
unsigned WR:1;
unsigned WREN:1;
unsigned WRERR:1;
unsigned FREE:1; /* Use with caution. Could result in program corruption. */
unsigned :1;
unsigned CFGS:1;
unsigned EEPGD:1;
} EECON1bits;
extern volatile near unsigned char EECON2;
extern volatile near unsigned char EEDATA;
extern volatile near unsigned char EEADR;
extern volatile near unsigned char EEADRH;
extern volatile near unsigned char RCSTA1;
extern volatile near union {
struct {
unsigned RX9D:1;
unsigned OERR:1;
unsigned FERR:1;
unsigned ADEN:1;
unsigned CREN:1;
unsigned SREN:1;
unsigned RX9:1;
unsigned SPEN:1;
};
struct {
unsigned :3;
unsigned ADDEN:1;
};
} RCSTA1bits;
extern volatile near unsigned char TXSTA1;
extern volatile near struct {
unsigned TX9D:1;
unsigned TRMT:1;
unsigned BRGH:1;
unsigned :1;
unsigned SYNC:1;
unsigned TXEN:1;
unsigned TX9:1;
unsigned CSRC:1;
} TXSTA1bits;
extern volatile near unsigned char TXREG1;
extern volatile near unsigned char RCREG1;
extern volatile near unsigned char SPBRG1;
extern volatile near unsigned char PSPCON; /* Reserved - Do not use */
extern volatile near struct {
unsigned :4;
unsigned PSPMODE:1;
unsigned IBOV:1;
unsigned OBF:1;
unsigned IBF:1;
} PSPCONbits; /* Reserved - Do not use */
extern volatile near unsigned char T3CON;
extern volatile near union {
struct {
unsigned TMR3ON:1;
unsigned TMR3CS:1;
unsigned T3SYNC:1;
unsigned T3CCP1:1;
unsigned T3CKPS0:1;
unsigned T3CKPS1:1;
unsigned T3CCP2:1;
unsigned RD16:1;
};
struct {
unsigned :2;
unsigned T3NSYNC:1;
};
struct {
unsigned :2;
unsigned NOT_T3SYNC:1;
};
} T3CONbits;
extern volatile near unsigned TMR3;
extern volatile near unsigned char TMR3L;
extern volatile near unsigned char TMR3H;
extern volatile near unsigned char CMCON;
extern volatile near struct {
unsigned CM0:1;
unsigned CM1:1;
unsigned CM2:1;
unsigned CIS:1;
unsigned C1INV:1;
unsigned C2INV:1;
unsigned C1OUT:1;
unsigned C2OUT:1;
} CMCONbits;
extern volatile near unsigned char CVRCON;
extern volatile near struct {
unsigned CVR0:1;
unsigned CVR1:1;
unsigned CVR2:1;
unsigned CVR3:1;
unsigned CVREF:1;
unsigned CVRR:1;
unsigned CVROE:1;
unsigned CVREN:1;
} CVRCONbits;
extern volatile near unsigned char CCP3CON;
extern volatile near union {
struct {
unsigned CCP3M0:1;
unsigned CCP3M1:1;
unsigned CCP3M2:1;
unsigned CCP3M3:1;
unsigned DCCP3Y:1;
unsigned DCCP3X:1;
};
struct {
unsigned :4;
unsigned DC3B0:1;
unsigned DC3B1:1;
};
} CCP3CONbits;
extern volatile near unsigned CCPR3;
extern volatile near unsigned char CCPR3L;
extern volatile near unsigned char CCPR3H;
extern volatile near unsigned char CCP2CON;
extern volatile near union {
struct {
unsigned CCP2M0:1;
unsigned CCP2M1:1;
unsigned CCP2M2:1;
unsigned CCP2M3:1;
unsigned DCCP2Y:1;
unsigned DCCP2X:1;
};
struct {
unsigned :4;
unsigned CCP2Y:1;
unsigned CCP2X:1;
};
struct {
unsigned :4;
unsigned DC2B0:1;
unsigned DC2B1:1;
};
} CCP2CONbits;
extern volatile near unsigned CCPR2;
extern volatile near unsigned char CCPR2L;
extern volatile near unsigned char CCPR2H;
extern volatile near unsigned char CCP1CON;
extern volatile near union {
struct {
unsigned CCP1M0:1;
unsigned CCP1M1:1;
unsigned CCP1M2:1;
unsigned CCP1M3:1;
unsigned DCCP1Y:1;
unsigned DCCP1X:1;
};
struct {
unsigned :4;
unsigned CCP1Y:1;
unsigned CCP1X:1;
};
struct {
unsigned :4;
unsigned DC1B0:1;
unsigned DC1B1:1;
};
} CCP1CONbits;
extern volatile near unsigned char CCPR1L;
extern volatile near unsigned CCPR1;
extern volatile near unsigned char CCPR1H;
extern volatile near unsigned char ADCON2;
extern volatile near struct {
unsigned ADCS0:1;
unsigned ADCS1:1;
unsigned ADCS2:1;
unsigned :4;
unsigned ADFM:1;
} ADCON2bits;
extern volatile near unsigned char ADCON1;
extern volatile near struct {
unsigned PCFG0:1;
unsigned PCFG1:1;
unsigned PCFG2:1;
unsigned PCFG3:1;
unsigned VCFG0:1;
unsigned VCFG1:1;
} ADCON1bits;
extern volatile near unsigned char ADCON0;
extern volatile near union {
struct {
unsigned ADON:1;
unsigned GO_DONE:1;
unsigned CHS0:1;
unsigned CHS1:1;
unsigned CHS2:1;
unsigned CHS3:1;
};
struct {
unsigned :1;
unsigned DONE:1;
};
struct {
unsigned :1;
unsigned GO:1;
};
struct {
unsigned :1;
unsigned NOT_DONE:1;
};
} ADCON0bits;
extern volatile near unsigned ADRES;
extern volatile near unsigned char ADRESL;
extern volatile near unsigned char ADRESH;
extern volatile near unsigned char SSPCON2; /* Reserved - Do not use */
extern volatile near struct {
unsigned SEN:1;
unsigned RSEN:1;
unsigned PEN:1;
unsigned RCEN:1;
unsigned ACKEN:1;
unsigned ACKDT:1;
unsigned ACKSTAT:1;
unsigned GCEN:1;
} SSPCON2bits; /* Reserved - Do not use */
extern volatile near unsigned char SSPCON1; /* Reserved - Do not use */
/* SSPCON1bits Reserved */
extern volatile near unsigned char SSPSTAT; /* Reserved - Do not use */
extern volatile near union {
struct {
unsigned BF:1;
unsigned UA:1;
unsigned R_W:1;
unsigned S:1;
unsigned P:1;
unsigned D_A:1;
unsigned CKE:1;
unsigned SMP:1;
};
struct {
unsigned :2;
unsigned I2C_READ:1;
unsigned I2C_START:1;
unsigned I2C_STOP:1;
unsigned I2C_DAT:1;
};
struct {
unsigned :2;
unsigned NOT_W:1;
unsigned :2;
unsigned NOT_A:1;
};
struct {
unsigned :2;
unsigned NOT_WRITE:1;
unsigned :2;
unsigned NOT_ADDRESS:1;
};
struct {
unsigned :2;
unsigned READ_WRITE:1;
unsigned :2;
unsigned DATA_ADDRESS:1;
};
struct {
unsigned :2;
unsigned R:1;
unsigned :2;
unsigned D:1;
};
} SSPSTATbits; /* Reserved - Do not use */
extern volatile near unsigned char SSPADD; /* Reserved - Do not use */
extern volatile near unsigned char SSPBUF; /* Reserved - Do not use */
extern volatile near unsigned char T2CON;
extern volatile near struct {
unsigned T2CKPS0:1;
unsigned T2CKPS1:1;
unsigned TMR2ON:1;
unsigned T2OUTPS0:1;
unsigned T2OUTPS1:1;
unsigned T2OUTPS2:1;
unsigned T2OUTPS3:1;
} T2CONbits;
extern volatile near unsigned char PR2;
extern volatile near unsigned char TMR2;
extern volatile near unsigned char T1CON;
extern volatile near union {
struct {
unsigned TMR1ON:1;
unsigned TMR1CS:1;
unsigned T1SYNC:1;
unsigned T1OSCEN:1;
unsigned T1CKPS0:1;
unsigned T1CKPS1:1;
unsigned :1;
unsigned RD16:1;
};
struct {
unsigned :2;
unsigned T1INSYNC:1;
};
struct {
unsigned :2;
unsigned NOT_T1SYNC:1;
};
} T1CONbits;
extern volatile near unsigned char TMR1L;
extern volatile near unsigned TMR1;
extern volatile near unsigned char TMR1H;
extern volatile near unsigned char RCON; /* Reserved - Do not use */
extern volatile near union {
struct {
unsigned NOT_BOR:1;
unsigned NOT_POR:1;
unsigned NOT_PD:1;
unsigned NOT_TO:1;
unsigned NOT_RI:1;
unsigned :2;
unsigned NOT_IPEN:1;
};
struct {
unsigned BOR:1;
unsigned POR:1;
unsigned PD:1;
unsigned TO:1;
unsigned RI:1;
unsigned :2;
unsigned IPEN:1;
};
} RCONbits; /* Reserved - Do not use */
extern volatile near unsigned char WDTCON; /* Reserved - Do not use */
extern volatile near union {
struct {
unsigned SWDTEN:1;
};
struct {
unsigned SWDTE:1;
};
} WDTCONbits; /* Reserved - Do not use */
extern volatile near unsigned char LVDCON; /* Reserved - Do not use */
extern volatile near union {
struct {
unsigned LVDL0:1;
unsigned LVDL1:1;
unsigned LVDL2:1;
unsigned LVDL3:1;
unsigned LVDEN:1;
unsigned IRVST:1;
};
struct {
unsigned LVV0:1;
unsigned LVV1:1;
unsigned LVV2:1;
unsigned LVV3:1;
unsigned :1;
unsigned BGST:1;
};
} LVDCONbits; /* Reserved - Do not use */
extern volatile near unsigned char OSCCON; /* Reserved - Do not use */
extern volatile near struct {
unsigned SCS:1;
} OSCCONbits; /* Reserved - Do not use */
extern volatile near unsigned char T0CON; /* Reserved - Do not use if you are using ifi_library.lib */
extern volatile near struct {
unsigned T0PS0:1;
unsigned T0PS1:1;
unsigned T0PS2:1;
unsigned PSA:1;
unsigned T0SE:1;
unsigned T0CS:1;
unsigned T08BIT:1;
unsigned TMR0ON:1;
} T0CONbits; /* Reserved - Do not use if you are using ifi_library.lib */
extern volatile near unsigned TMR0; /* Reserved - Do not modify if you are using ifi_library.lib */
extern volatile near unsigned char TMR0L; /* Reserved - Do not modify if you are using ifi_library.lib */
extern volatile near unsigned char TMR0H; /* Reserved - Do not modify if you are using ifi_library.lib */
extern near unsigned char STATUS;
extern near struct {
unsigned C:1;
unsigned DC:1;
unsigned Z:1;
unsigned OV:1;
unsigned N:1;
} STATUSbits;
extern near unsigned FSR2; /* Reserved - Do not use */
extern near unsigned char FSR2L; /* Reserved - Do not use */
extern near unsigned char FSR2H; /* Reserved - Do not use */
extern volatile near unsigned char PLUSW2; /* Reserved - Do not use */
extern volatile near unsigned char PREINC2; /* Reserved - Do not use */
extern volatile near unsigned char POSTDEC2; /* Reserved - Do not use */
extern volatile near unsigned char POSTINC2; /* Reserved - Do not use */
extern near unsigned char INDF2; /* Reserved - Do not use */
extern near unsigned char BSR; /* Reserved - Do not use */
extern near unsigned FSR1; /* Reserved - Do not use */
extern near unsigned char FSR1L; /* Reserved - Do not use */
extern near unsigned char FSR1H; /* Reserved - Do not use */
extern volatile near unsigned char PLUSW1; /* Reserved - Do not use */
extern volatile near unsigned char PREINC1; /* Reserved - Do not use */
extern volatile near unsigned char POSTDEC1; /* Reserved - Do not use */
extern volatile near unsigned char POSTINC1; /* Reserved - Do not use */
extern near unsigned char INDF1; /* Reserved - Do not use */
extern near unsigned char WREG; /* Use at your own risk. */
extern near unsigned char FSR0L; /* Use at your own risk. */
extern near unsigned FSR0; /* Use at your own risk. */
extern near unsigned char FSR0H; /* Use at your own risk. */
extern volatile near unsigned char PLUSW0; /* Use at your own risk. */
extern volatile near unsigned char PREINC0; /* Use at your own risk. */
extern volatile near unsigned char POSTDEC0; /* Use at your own risk. */
extern volatile near unsigned char POSTINC0; /* Use at your own risk. */
extern near unsigned char INDF0; /* Use at your own risk. */
extern volatile near unsigned char INTCON3;
extern volatile near union {
struct {
unsigned INT1IF:1;
unsigned INT2IF:1;
unsigned INT3IF:1;
unsigned INT1IE:1;
unsigned INT2IE:1;
unsigned INT3IE:1;
unsigned INT1IP:1; /* Reserved - Do not use */
unsigned INT2IP:1; /* Reserved - Do not use */ /* Must be set to 0 (low priority) */
};
struct {
unsigned INT1F:1;
unsigned INT2F:1;
unsigned INT3F:1;
unsigned INT1E:1;
unsigned INT2E:1;
unsigned INT3E:1;
unsigned INT1P:1; /* Reserved - Do not use */
unsigned INT2P:1; /* Reserved - Do not use */
};
} INTCON3bits;
extern volatile near unsigned char INTCON2;
extern volatile near union {
struct {
unsigned RBIP:1; /* Reserved - Do not use */
unsigned INT3IP:1; /* Reserved - Do not use */
unsigned TMR0IP:1; /* Reserved - Do not use */
unsigned INTEDG3:1;
unsigned INTEDG2:1;
unsigned INTEDG1:1;
unsigned INTEDG0:1; /* Reserved - Do not use */
unsigned NOT_RBPU:1; /* Reserved - Do not use */
};
struct {
unsigned :1;
unsigned INT3P:1; /* Reserved - Do not use */
unsigned T0IP:1; /* Reserved - Do not use */
unsigned :4;
unsigned RBPU:1; /* Reserved - Do not use */
};
} INTCON2bits;
extern volatile near unsigned char INTCON;
extern volatile near union {
struct {
unsigned RBIF:1;
unsigned INT0IF:1; /* Reserved - Do not use */
unsigned TMR0IF:1; /* Reserved - Do not modify if you are using ifi_library.lib */
unsigned RBIE:1;
unsigned INT0IE:1; /* Reserved - Do not use */
unsigned TMR0IE:1; /* Reserved - Do not use if you are using ifi_library.lib */
unsigned PEIE:1;
unsigned GIE:1; /* Reserved - Do not use */
};
struct {
unsigned :1;
unsigned INT0F:1; /* Reserved - Do not use */
unsigned T0IF:1;
unsigned :1;
unsigned INT0E:1; /* Reserved - Do not use */
unsigned T0IE:1;
unsigned GIEL:1; /* Use of this bit could lead to unexpected results */
unsigned GIEH:1; /* Reserved - Do not use */
};
} INTCONbits;
extern near unsigned char PRODL;
extern near unsigned PROD;
extern near unsigned char PRODH;
extern volatile near unsigned char TABLAT;
extern volatile near unsigned char TBLPTRL;
extern volatile near unsigned short long TBLPTR;
extern volatile near unsigned char TBLPTRH;
extern volatile near unsigned char TBLPTRU;
extern volatile near unsigned char PCL;
extern volatile near unsigned short long PC;
extern volatile near unsigned char PCLATH;
extern volatile near unsigned char PCLATU;
extern volatile near unsigned char STKPTR;
extern volatile near union {
struct {
unsigned STKPTR0:1;
unsigned STKPTR1:1;
unsigned STKPTR2:1;
unsigned STKPTR3:1;
unsigned STKPTR4:1;
unsigned :1;
unsigned STKUNF:1;
unsigned STKOVF:1;
};
struct {
unsigned :7;
unsigned STKFUL:1;
};
} STKPTRbits;
extern near unsigned short long TOS;
extern near unsigned char TOSL;
extern near unsigned char TOSH;
extern near unsigned char TOSU;
#if defined(BANKED)
#error *** Error - Invalid 18f8520 header file!
#else
#define UNCHANGEABLE_DEFINITION_AREA 1
#endif
/*-------------------------------------------------------------------------
* Some useful defines for inline assembly stuff
*-------------------------------------------------------------------------*/
#define ACCESS 0
#define BANKED 1
/*-------------------------------------------------------------------------
* Some useful macros for inline assembly stuff
*-------------------------------------------------------------------------*/
#define Nop() {_asm nop _endasm}
#define ClrWdt() {_asm clrwdt _endasm}
#define Sleep() {_asm sleep _endasm}
#define Reset() {_asm reset _endasm}
#define Rlcf(f,dest,access) {_asm movlb f rlcf f,dest,access _endasm}
#define Rlncf(f,dest,access) {_asm movlb f rlncf f,dest,access _endasm}
#define Rrcf(f,dest,access) {_asm movlb f rrcf f,dest,access _endasm}
#define Rrncf(f,dest,access) {_asm movlb f rrncf f,dest,access _endasm}
#define Swapf(f,dest,access) {_asm movlb f swapf f,dest,access _endasm }
/*-------------------------------------------------------------------------
* A fairly inclusive set of registers to save for interrupts.
* These are locations which are commonly used by the compiler.
*-------------------------------------------------------------------------*/
#define INTSAVELOCS TBLPTR, TABLAT, PROD
#endif
/*******************************************************************************
* FILE NAME: ifi_utilities.h
*
* DESCRIPTION:
* This is the include file which corresponds to ifi_utilities.c
* It contains some aliases and function prototypes used in that file.
*
* USAGE:
* This file should not be modified by the user.
* DO NOT EDIT THIS FILE!
*******************************************************************************/
#ifndef __ifi_utilities_h_
#define __ifi_utilities_h_
#ifdef _SNOOP_ON_COM1 /* FOR FUTURE USE */
#define RXINTF PIR3bits.RC2IF
#define RXINTE PIE3bits.RC2IE
#define TXINTF PIR3bits.TX2IF
#define TXINTE PIE3bits.TX2IE
#define RCSTAbits RCSTA2bits
#define RCSTA RCSTA2
#define TXSTA TXSTA2
#define TXREG TXREG2
#define RCREG RCREG2
#define SPBRG SPBRG2
#define OpenUSART Open2USART
#else
#define RXINTF PIR1bits.RCIF
#define RXINTE PIE1bits.RCIE
#define TXINTF PIR1bits.TXIF
#define TXINTE PIE1bits.TXIE
#define RCSTAbits RCSTA1bits
#define RCSTA RCSTA1
#define TXSTA TXSTA1
#define TXREG TXREG1
#define RCREG RCREG1
#define SPBRG SPBRG1
#define OpenUSART Open1USART
#endif
/*******************************************************************************
MACRO DEFINITIONS
*******************************************************************************/
typedef enum
{
baud_19 = 15,
baud_38 = 64,
baud_56 = 42,
baud_115 = 21
} SERIAL_SPEED;
/*******************************************************************************
FUNCTION PROTOTYPES
*******************************************************************************/
void Hex_output(unsigned char temp); /* located in ifi_library.lib */
#ifdef _FRC_BOARD
/* located in ifi_library.lib */
void Generate_Pwms(unsigned char pwm_13,unsigned char pwm_14,
unsigned char pwm_15,unsigned char pwm_16);
#else
/* located in ifi_library.lib */
void Generate_Pwms(unsigned char pwm_1,unsigned char pwm_2,
unsigned char pwm_3,unsigned char pwm_4,
unsigned char pwm_5,unsigned char pwm_6,
unsigned char pwm_7,unsigned char pwm_8);
#endif
/* These routines reside in ifi_utilities.c */
void Wait4TXEmpty(void);
void PrintByte(unsigned char odata);
void PrintWord(unsigned int odata);
void PrintString(char *bufr);
void DisplayBufr(unsigned char *bufr);
void PacketNum_Check(void);
void Initialize_Serial_Comms (void);
void Set_Number_of_Analog_Channels (unsigned char number_of_channels);
unsigned int Get_Analog_Value(unsigned char channel);
#endif
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/*******************************************************************************
*
* TITLE: navigate.h
*
* VERSION: 1.0
*
* DATE: 08-Jan-2004
*
* AUTHOR: Richard D. Petras
*
* COMMENTS:
*
********************************************************************************
*
* CHANGE LOG:
*
* DATE REV DESCRIPTION
* ----------- --- ----------------------------------------------------------
* 03-Dec-2003 0.1
* 08-Jan-2004 1.0 RDP The version used at the 2004 kickoff
*
*******************************************************************************/
#ifndef _navigate_h
#define _navigate_h
#include "tracker.h"
// Navigator state machine values
// These values will be stored in a global variable called
// Navigator_State. As each state transition is detected,
// the state will change to describe how the vehicle should
// operate.
#define WAIT_TO_DRIVE 0
#define DRIVE_TO_CENTER 1
#define TURN_TO_TARGET 2
#define DRIVE_TO_TARGET 3
#define PASSED_TARGET 4
#define AT_TARGET 5
#define OVER_CURRENT 6
// Drive state
// These values are stored in the drive_state variable. They tell
// us where the beacon is with respect to each tracker on the robot.
#define DR_UNDEFINED 0
#define DR_BOTH_LEFT 1
#define DR_BOTH_RIGHT 2
#define DR_BOTH_STRAIGHT 3
#define DR_BOTH_CENTER 4
#define DR_LEFT_STRAIGHT 5
#define DR_RIGHT_STRAIGHT 6
#define DR_REFLECTION 7
// Some values for each individual tracker
#define DR_LEFT 0
#define DR_CENTER 1
#define DR_RIGHT 2
// Which pwms are our tracker servoes and drive motors? It
// is nice to only have to change this in one place.
#define left_servo pwm10
#define right_servo pwm11
#define left_drive pwm14
#define right_drive pwm15
// Simplify the big structure for beacon quality
// from the tracker code.
#define LL Sensor_Stats[0].Beacon_Quality[Tracker_Data[LEFT].Beacon_Type]
#define LR Sensor_Stats[1].Beacon_Quality[Tracker_Data[LEFT].Beacon_Type]
#define RL Sensor_Stats[2].Beacon_Quality[Tracker_Data[RIGHT].Beacon_Type]
#define RR Sensor_Stats[3].Beacon_Quality[Tracker_Data[RIGHT].Beacon_Type]
// The rest of these defines are tweekable parameters to fit
// the characteristics of different drive trains. You might
// want to divide these into a separate set of values for the
// left and right side drives if your motor characteristics
// are sufficiently different. This would require changing
// navigator.c, but the places to make the changes should be
// obvious. :-)
// Stop values
#define LSTOP 127
#define RSTOP 127
// Fast backward
#define FBWD (LSTOP - 90)
// Slow Backward
#define SBWD (LSTOP - 55)
// Very Slow Backward
#define VSBWD (LSTOP - 10)
// Very Slow Forward
#define VSFWD (LSTOP + 10)
// Slow Forward
#define SFWD (LSTOP + 55)
// Fast Forward
#define FFWD (LSTOP + 90)
// Note: All the logic assumes the servo max points right
// Its not too hard to change the code to accomidate the other
// direction, in fact the code started out that way...
// These values are the servo settings (assuming 127 is straight
// ahead) that tells you that the beacon is between the trackers
// and about 1/2 meter ahead. The exact values will depend on the
// baseline of your trackers.
#define LEFT_GOAL 135
#define RIGHT_GOAL 120
// These values tell you when the target is far to the left of the
// left servo, or far to the right of the right servo. We switch
// navigator states at this point
#define LEFT_PASS 60
#define RIGHT_PASS 195
// Adjust these for your drive train
// This is the gain that is multiplied by your pointing error.
// It can be used as part of a feedback loop to steer toward the
// goal. Note: the error calculation is included in the code
// as an example, but was not used in the actual kickoff demo.
// (we wanted to drive straight until we passed the goal)
#define DRIVE_GAIN 2
// This is a timer for the short drive away from the wall before
// we start to turn in place toward the beacon.
#define DRIVE_TO_CENTER_TIME 5
// I bet you didn't know we were using the current sensors in the
// kickoff demo. If the current sensor reading got above this
// value, we might be up against the wall. In that case we might
// want to stop driving for a short time to allow the robot to level
// out.
#define MAX_CURRENT 700
// If we haven't seen the target with any of the trackers for
// a while, just start searching again by turning in place.
#define LOST_TARGET_TIMEOUT 100
// Declaration for the Navigate function
void Navigate(void);
#endif // _navigate_h
/*******************************************************************************
* FILE NAME: printf_lib.h
*
* DESCRIPTION:
* This is the include file which corresponds to printf_lib.c
*
* USAGE:
* If you add your own routines to that file, this is a good place
* to add function prototypes.
*******************************************************************************/
#ifndef __printf_lib_h_
#define __printf_lib_h_
int printf(rom const char *format, ...);
void printid(int data,int crtOn);
void printb(unsigned char data,int crtOn);
void printd(unsigned char data,int crtOn);
void printix(int data,int crtOn);
void printx(unsigned char data,int crtOn);
void debug_print(char *bufr,int data);
void debug_printb(char *bufr,unsigned int data);
void debug_println(char *bufr);
#endif
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/*******************************************************************************
*
* TITLE: receiver.h
*
* VERSION: 1.1
*
* DATE: 04-Feb-2004
*
* AUTHOR: R. Kevin Watson
*
* COMMENTS:
*
********************************************************************************
*
* CHANGE LOG:
*
* DATE REV DESCRIPTION
* ----------- --- ----------------------------------------------------------
* 28-Nov-2003 0.3 RKW Original
* 30-Nov-2003 0.4 RKW - Changed Sensor_Stats definition, making Beacon_Count
* and Beacon_Quality an array.
* 04-Dec-2003 0.5 RKW - Changed timer 1 prescaler to 4:1 from 8:1 to double
* the tracker control rate to 38Hz.
* 07-Dec-2003 0.6 RKW - Turned Sensor_Stats into an array so that the code
* in tracker.c can be simplified.
* 09-Jan-2004 1.0 RKW - This version used for kick-off demo
* 04-Feb-2004 1.1 RKW - Fixed minor bug in the interrupt handlers that
* erroneously incremented Sensor_Stats[n].Beacon_Quality[0]
*
*******************************************************************************/
#ifndef _receiver_h
#define _receiver_h
// function prototypes
void Initialize_Receiver(void);
void Timer_1_Int_Handler(void); // timer 1 interrupt handler
void Int_1_Handler(void); // IR sensor 1 interrupt handler
void Int_2_Handler(void); // IR sensor 2 interrupt handler
void Int_4_Handler(unsigned char); // IR sensor 3 interrupt handler
void Int_5_Handler(unsigned char); // IR sensor 4 interrupt handler
// some handy macros
#define HIBYTE(value) ((unsigned char)(((unsigned int)(value)>>8)&0xFF))
#define LOBYTE(value) ((unsigned char)(value))
// pulse-width discrimination defines
// type 0 average = 2720 clock ticks
#define BEACON_0_LOWER_BOUND 2040 // average-25%
#define BEACON_0_UPPER_BOUND 3400 // average+25%
// type 1 average = 5224 clock ticks
#define BEACON_1_LOWER_BOUND 3918 // average-25%
#define BEACON_1_UPPER_BOUND 6530 // average+25%
// state machine defines
#define WAITING_FOR_UP_EDGE 0
#define WAITING_FOR_DOWN_EDGE 1
// Sensor_Stats definition -- tracker.c/Track_Beacon() directly accesses this data
typedef struct tagSensor_Stats
{
unsigned long Total_Count; // number of IR pulses detected
unsigned long Invalid_Count; // number of IR pulses that couldn't be catagorized
unsigned long Beacon_Count[2]; // number of IR pulses that were type 0 or 1
unsigned char Beacon_Quality[2]; // number of valid type 0 or 1 beacons in the last 26 milliseconds
}Sensor_Stats_Struct;
// variable definitions
extern unsigned int Clock; // in receiver.c
extern Sensor_Stats_Struct Sensor_Stats[4]; // in receiver.c
#endif // _receiver_h
/*******************************************************************************
*
* TITLE: tracker.h
*
* VERSION: 1.0
*
* DATE: 09-Jan-2004
*
* AUTHOR: R. Kevin Watson
*
* COMMENTS:
*
********************************************************************************
*
* CHANGE LOG:
*
* DATE REV DESCRIPTION
* ----------- --- ----------------------------------------------------------
* 03-Dec-2003 0.1 RKW Original
* 07-Dec-2003 0.2 RKW - Modified Track_Beacon() to handle an arbitrary number
* of IR beam tracking assemblies. All state machine
* information is now kept in the Tracker_Data data structure.
* RKW - Cleaned-up Track_Beacon to make it understandable,
* hiding most of the tough-to-grasp code here.
* 09-Jan-2004 1.0 RKW - This version used for kick-off demo
*
*******************************************************************************/
#ifndef _tracker_h
#define _tracker_h
#include "receiver.h"
// type of beacon to search for
#define BEACON_TYPE rc_dig_in07 // this assumes that rc_dig_in07 is a digital input
// assign sensors to the trackers
#define LEFT_TRACKER_LEFT_SENSOR 0 // entry 0 of Sensor_Stats] will provide this beacon data
#define LEFT_TRACKER_RIGHT_SENSOR 1 // entry 1 of Sensor_Stats] will provide this beacon data
#define RIGHT_TRACKER_LEFT_SENSOR 2 // entry 2 of Sensor_Stats] will provide this beacon data
#define RIGHT_TRACKER_RIGHT_SENSOR 3 // entry 3 of Sensor_Stats] will provide this beacon data
// define the PWM channels to use for the tracker servo motors
#define LEFT_TRACKER_SERVO pwm01
#define RIGHT_TRACKER_SERVO pwm02
// define the starting position of the servo motors
#define INITIAL_SERVO_POSITION 127
// define the initial servo motor step size
// this may be a negitive value for some types of servo motors
// if your servo oscillates in the presence of the IR beacon try
// changing the sign
#define INITIAL_SERVO_STEP_SIZE -4
// define the beacon types
#define BEACON_TYPE_0 0
#define BEACON_TYPE_1 1
// define the tracker identification numbers
#define LEFT 0
#define RIGHT 1
// define the tracker states
#define NONE_IN_VIEW 0
#define RIGHT_IN_VIEW 1
#define LEFT_IN_VIEW 2
#define BOTH_IN_VIEW 3
// this expression is the state of the current tracker
#define TRACKER_STATUS Tracker_Data[Tracker].Status
// this expression is the current tracker servo motor position
#define TRACKER_POSITION Tracker_Data[Tracker].Position
// this expression is the step increment for the current trackers servo motor
#define SEARCH_INCREMENT Tracker_Data[Tracker].Search_Increment
// this lengthy expression is just the number of IR beacon pulses received
// by the current trackers left sensor in the last clock period.
#define LEFT_SENSOR Sensor_Stats[Tracker_Data[Tracker].Left_Sensor_Stats_Index].Beacon_Quality[Tracker_Data[Tracker].Beacon_Type]
// this lengthy expression is just the number of IR beacon pulses received
// by the current trackers right sensor in the last clock period.
#define RIGHT_SENSOR Sensor_Stats[Tracker_Data[Tracker].Right_Sensor_Stats_Index].Beacon_Quality[Tracker_Data[Tracker].Beacon_Type]
// function prototypes
void Initialize_Tracker(void);
void Track_Beacon(unsigned char);
// define the tracker data structure
typedef struct tagTracker_Data
{
unsigned char Status; // tracker state (defined above)
unsigned char Position; // current commanded servo motor position
unsigned char Search_Increment; // servo motor search step increment
unsigned char Beacon_Type; // beacon type to search for
unsigned char Left_Sensor_Stats_Index; // which sensor entry, in sensor stats, will provide data
unsigned char Right_Sensor_Stats_Index; // for the left and right sensors of this tracker
}Tracker_Data_Struct;
extern Tracker_Data_Struct Tracker_Data[2];
#endif // _tracker_h
/*******************************************************************************
* FILE NAME: user_routines.h
*
* DESCRIPTION:
* This is the include file which corresponds to user_routines.c and
* user_routines_fast.c
* It contains some aliases and function prototypes used in those files.
*
* USAGE:
* If you add your own routines to those files, this is a good place to add
* your custom macros (aliases), type definitions, and function prototypes.
*******************************************************************************/
#ifndef __user_program_h_
#define __user_program_h_
/*******************************************************************************
MACRO DECLARATIONS
*******************************************************************************/
/* Add your macros (aliases and constants) here. */
/* Do not edit the ones in ifi_aliases.h */
/* Macros are substituted in at compile time and make your code more readable */
/* as well as making it easy to change a constant value in one place, rather */
/* than at every place it is used in your code. */
/*
EXAMPLE CONSTANTS:
#define MAXIMUM_LOOPS 5
#define THE_ANSWER 42
#define TRUE 1
#define FALSE 0
#define PI_VAL 3.1415
EXAMPLE ALIASES:
#define LIMIT_SWITCH_1 rc_dig_int1 (Points to another macro in ifi_aliases.h)
#define MAIN_SOLENOID solenoid1 (Points to another macro in ifi_aliases.h)
*/
/* Used in limit switch routines in user_routines.c */
#define OPEN 1 /* Limit switch is open (input is floating high). */
#define CLOSED 0 /* Limit switch is closed (input connected to ground). */
/*******************************************************************************
TYPEDEF DECLARATIONS
*******************************************************************************/
/* EXAMPLE DATA STRUCTURE */
/*
typedef struct
{
unsigned int NEW_CAPTURE_DATA:1;
unsigned int LAST_IN1:1;
unsigned int LAST_IN2:1;
unsigned int WHEEL_COUNTER_UP:1;
unsigned int :4;
unsigned int wheel_left_counter;
unsigned int wheel_right_counter;
} user_struct;
*/
/*******************************************************************************
FUNCTION PROTOTYPES
*******************************************************************************/
/* These routines reside in user_routines.c */
void User_Initialization(void);
void Process_Data_From_Master_uP(void);
void Default_Routine(void);
/* These routines reside in user_routines_fast.c */
void InterruptHandlerLow (void); /* DO NOT CHANGE! */
void User_Autonomous_Code(void); /* Only in full-size FRC system. */
void Process_Data_From_Local_IO(void);
#endif
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
since you havent given us any indication of what you are talking about, my guess would be something to do with that these lines from the top of the file say:
- USAGE:
- This file should not be modified at all by the user.
- DO NOT MODIFY THIS FILE!
ignore IFIs directions at your own peril
why did you stuff all your auton code into this file?!?! :ahh:
We’ve ignored it and it only ran into the wall a twice.
He ran all his project files together when he posted them rather than zipping the project. He didn’t actually add anything to ifi_startup.c
It would be nice to have some indication of the symptoms you are experiencing.
What happens that isn’t what you expect?
ok guys it wont drive at all… and we are still having troubles with switching between atom mode and navagate
On a quick glance it looks like you call navigate() to direct the robot towards the IR beacon, but then override whatever navigate() told the robot to do based on switch settings on your RC.
So navigate() will probably do nothing for you and the code based on the RC digital inputs will drive around for the full 15 seconds of autonomous.
Navigate() is auto_mode.
It also looks like you’ve mixed the pwm’s you’re using for your motors.
In navigate you use:
#define left_drive pwm14
#define right_drive pwm15
While in User_Autonomous_Code() you use pwm13 & pwm14.
So it would seem you’d actually get pwm13 & 14 from User_Autonomous_Code() (rc_dig_in02 wins all the time by the way) and pwm 15 from navigate().
[edit] I can’t seem to find the navigate.c file in your posting. Did you modify it at all? There are several modifications you should have made. It won’t even begin without at least one important change.
my friend (crashzero) downloaded it form some wehrer on the delphi site
dont know wehre tho
we did make some changes but it was only going zerk when we had the changes
What part(s) did you change? We need to know details to be able to help much. 
ill have to find that out later
the only real change that was made was for it to follow a line and that was made in the user rutines fast.c file. we did not really change anything else. But the entire code is posted above (i can’t for the life of me figure out y omega posted everything and didn’t zip it but anyway) I hope someone can help us cuz the compition starts tommorow. :ahh:
If you’ve settled on line following comment out the call to navigate() and take a look at the code another team posted on this thread:
/t/counting-in-seconds-for-the-autonomous-mode/52406/1
Your code effectively ignores your line sensor on rc_dig_in01 and only attempts to drive using the sensor on rc_dig_in02. It doesn’t tell you the correct direction to turn to reacquire the line.
that link doesn’t work!
Sorry, try it now.
The code is towards the bottom.
thanks!!
ya uh we need more help then that
thz anymore
/* Add your own autonomous code here. */
Navigate();
if(rc_dig_in01 ==1 )
{
pwm13 = 137;
pwm14=100;
}
else
{
pwm13 = pwm14 = 140;
}
if(rc_dig_in02 == 1)
{
pwm13 = 100;
pwm14 = 137;
}
else
{
pwm13 = pwm14 = 140;
}
This code will ignore the rc_dig_in01 as the if(rc_dig_in02 == 1) overwrites the values. You need to create 4 states for this or at least determine what you want to happen for each of the 4 states that can happen with two digital inputs:
rc_dig_in01 == 0, rc_dig_in02 == 0
rc_dig_in01 == 0, rc_dig_in02 == 1
rc_dig_in01 == 1, rc_dig_in02 == 0
rc_dig_in01 == 1, rc_dig_in02 == 1
I assume here that these are the inputs from a light sensor that indicates which light is seeing the tape, depending on how far away each sensor is it may not be possible to get both on at the same time. Then you are down to only 3 states. For simplicity lets define
Left == (rc_dig_in01 == 1);
Right == (rc_dig_in02 ==1);
Now:
if (Left)
{
turn right
}
else if (right)
{
turn left
}
else
{
go straight
}
if both left and right can be on at the same time then check for that first
if (Left && Right)
{
}
else if (Left)
{
}
else if (Right)
{
}
else
{
}
Hope this helps,
Dave
SBotz