int main(void) {
unsigned int wait = 0;
int readcount = 0;
SERIAL_Init();
INTEnableSystemMultiVectoredInt();
mJTAGPortEnable(0);
printf("\r\nUno A/D Test Harness\r\nThis will initialize all A/D pins and read them %d times", TIMES_TO_READ);
printf("Value of pcfg before test: %X",AD1PCFG);
AD_Init(AD_PORTV3 | AD_PORTV4 | AD_PORTV5 | AD_PORTV6 | AD_PORTW4 | AD_PORTW3 | BAT_VOLTAGE | PINA);
unsigned char cur = 0;
while (readcount <= TIMES_TO_READ) {
for (wait = 0; wait <= 100000; wait++)
asm("nop");
printf("\r\nAN0\tAN1\tAN2\tAN3\tAN4\tAN5\tAN11\tAN10\n");
printf("%d\t", ReadADPin(PINA));
printf("%d\t", ReadADPin(BAT_VOLTAGE));
printf("%d\t", ReadADPin(AD_PORTV3));
printf("%d\t", ReadADPin(AD_PORTV4));
printf("%d\t", ReadADPin(AD_PORTV5));
printf("%d\t", ReadADPin(AD_PORTV6));
printf("%d\t", ReadADPin(AD_PORTW4));
printf("%d\t", ReadADPin(AD_PORTW3));
readcount++;
}
printf("Done Reading Them\r\n");
AD_End();
printf("Value of pcfg after test: %X",AD1PCFG);
return 0;
}
int main(void) {
unsigned int wait = 0;
int readcount = 0;
SERIAL_Init();
INTEnableSystemMultiVectoredInt();
mJTAGPortEnable(0);
printf("\r\nUno A/D Test Harness\r\nThis will initialize all A/D pins and read them %d times", TIMES_TO_READ);
printf("Value of pcfg before test: %X",AD1PCFG);
AD_Init(AD_PORTV3 | AD_PORTV4 | AD_PORTV5 | AD_PORTV6 | AD_PORTV7 | AD_PORTV8 | AD_PORTW3 | AD_PORTW4 | AD_PORTW5 | AD_PORTW6 | AD_PORTW7 | AD_PORTW8 | BAT_VOLTAGE);
char numtoread = 13;
unsigned char cur = 0;
while (readcount <= TIMES_TO_READ) {
for (wait = 0; wait <= 100000; wait++)
asm("nop");
// printf("\r\nAN2\tAN3\tAN4\tAN5\tAN8\tAN9\tAN11\tAN10\tAN13\tAN12\tAN15\tAN14\tAN1\n");
for (cur = 0; cur < numtoread; cur++) {
printf("%d\t", ReadADPin(1 << cur));
}
printf("\r\n");
readcount++;
}
printf("Done Reading Them\r\n");
AD_End();
printf("Value of pcfg after test: %X",AD1PCFG);
return 0;
}
int main(void) {
// Initialize LED, sound and the program button pins.
maximite_init();
// Initial setup of the I/O ports.
AD1PCFG = 0xFFFF; // Default all pins to digital.
mJTAGPortEnable(0); // Turn off JTAG.
// Setup the CPU.
// System config performance.
SYSTEMConfigPerformance(CLOCKFREQ);
// Fix the peripheral bus to the main clock speed.
mOSCSetPBDIV(OSC_PB_DIV_1);
INTEnableSystemMultiVectoredInt(); // Allow vectored interrupts.
usb_init();
keyboard_init(); // Initialise and startup the keyboard routines.
rk86_video_init(); // Start the video state machine.
delay_us(1000);
while (keyboard_inkey() != -1);
i8080_pic32_run();
panic(PANIC_EMULATION_TERMINATED);
return 0;
}
int main(void)
{
int i;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Configure the device for maximum performance but do not change the PBDIV
// Given the options, this function will change the flash wait states, RAM
// wait state and enable prefetch cache but will not change the PBDIV.
// The PBDIV value is already set via the pragma FPBDIV option above..
SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
// Explorer16 LEDs are on lower 8-bits of PORTA and to use all LEDs, JTAG port must be disabled.
mJTAGPortEnable(DEBUG_JTAGPORT_OFF);
// Make all lower 8-bits of PORTA as output. Turn them off before changing
// direction so that we don't have unexpected flashes
mPORTAClearBits(BIT_7 | BIT_6 | BIT_5 | BIT_5 | BIT_4 | \
BIT_3 | BIT_2 | BIT_1 | BIT_0 );
mPORTASetPinsDigitalOut( BIT_7 | BIT_6 | BIT_5 | BIT_5 | BIT_4 | \
BIT_3 | BIT_2 | BIT_1 | BIT_0 );
// Now blink all LEDs ON/OFF forever.
while(1)
{
mPORTAToggleBits(BIT_7 | BIT_6 | BIT_5 | BIT_5 | BIT_4 | \
BIT_3 | BIT_2 | BIT_1 | BIT_0 );
// Insert some delay
i = 1024*1024*10;
while(i--);
}
}
// *--------------------------------------------------------------------------------*
int main(){
mJTAGPortEnable(0); // JTAG des-habilitado
SYSTEMConfigPerformance(GetSystemClock()); // Activa pre-cache.-
AD1PCFG = 0xFFFF;
LED1_OUTPUT();
LED2_OUTPUT();
SW1_INPUT();
SW2_INPUT();
buttonCount = 0;
buttonPressed = FALSE;
stringPrinted = TRUE;
USBDeviceInit();
while(1){
#if defined(USB_INTERRUPT)
if(USB_BUS_SENSE && (USBGetDeviceState() == DETACHED_STATE)){
USBDeviceAttach();
}
#endif
#if defined(USB_POLLING)
// Check bus status and service USB interrupts.
USBDeviceTasks();
#endif
ProcessIO();
}
}
int main()
{
mJTAGPortEnable(0);
mPORTASetPinsDigitalOut(BIT_0|BIT_1|BIT_2|BIT_3|BIT_4|BIT_5|BIT_6|BIT_7);
mPORTAClearBits(BIT_0|BIT_1|BIT_2|BIT_3|BIT_4|BIT_5|BIT_6|BIT_7);
INTCONSET=0x1000;
INTEnableSystemMultiVectoredInt();
IEC0 =0;
IFS0 = 0;
INTCONCLR = 0x00000018;
IEC0SET = 0x00088000;
IPC3 = 0x1F000000;
IPC4 = 0X17000000;
lcdconfig();
while(1)
{
if(IFS0 & 0x8000==1)
{
lcddata('3');
PORTA=0X0F;
}
if(IFS0 & 0x80000==1)
{
lcddata('4');
PORTA=0XFF;
}
}
}
void vParTestInitialise( void )
{
/* All LEDs output. */
TRISA = ptOUTPUT;
PORTA = ptALL_OFF;
mJTAGPortEnable( 0 );
}
/********************************************************************
* Function: static void InitializeSystem(void)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: InitializeSystem is a centralize initialization
* routine. All required USB initialization routines
* are called from here.
*
* User application initialization routine should
* also be called from here.
*
* Note: None
*******************************************************************/
static void InitializeSystem(void)
{
AD1PCFG = 0xFFFF;
// The USB specifications require that USB peripheral devices must never source
// current onto the Vbus pin. Additionally, USB peripherals should not source
// current on D+ or D- when the host/hub is not actively powering the Vbus line.
// When designing a self powered (as opposed to bus powered) USB peripheral
// device, the firmware should make sure not to turn on the USB module and D+
// or D- pull up resistor unless Vbus is actively powered. Therefore, the
// firmware needs some means to detect when Vbus is being powered by the host.
// A 5V tolerant I/O pin can be connected to Vbus (through a resistor), and
// can be used to detect when Vbus is high (host actively powering), or low
// (host is shut down or otherwise not supplying power). The USB firmware
// can then periodically poll this I/O pin to know when it is okay to turn on
// the USB module/D+/D- pull up resistor. When designing a purely bus powered
// peripheral device, it is not possible to source current on D+ or D- when the
// host is not actively providing power on Vbus. Therefore, implementing this
// bus sense feature is optional. This firmware can be made to use this bus
// sense feature by making sure "USE_USB_BUS_SENSE_IO" has been defined in the
// HardwareProfile.h file.
#if defined(USE_USB_BUS_SENSE_IO)
tris_usb_bus_sense = INPUT_PIN; // See HardwareProfile.h
#endif
// If the host PC sends a GetStatus (device) request, the firmware must respond
// and let the host know if the USB peripheral device is currently bus powered
// or self powered. See chapter 9 in the official USB specifications for details
// regarding this request. If the peripheral device is capable of being both
// self and bus powered, it should not return a hard coded value for this request.
// Instead, firmware should check if it is currently self or bus powered, and
// respond accordingly. If the hardware has been configured like demonstrated
// on the PICDEM FS USB Demo Board, an I/O pin can be polled to determine the
// currently selected power source. On the PICDEM FS USB Demo Board, "RA2"
// is used for this purpose. If using this feature, make sure "USE_SELF_POWER_SENSE_IO"
// has been defined in HardwareProfile.h, and that an appropriate I/O pin has been mapped
// to it in HardwareProfile.h.
#if defined(USE_SELF_POWER_SENSE_IO)
tris_self_power = INPUT_PIN; // See HardwareProfile.h
#endif
UserInit();
USBDeviceInit(); //usb_device.c. Initializes USB module SFRs and firmware
//variables to known states.
// Configure the proper PB frequency and the number of wait states
SYSTEMConfigWaitStatesAndPB(80000000L);
// Enable the cache for the best performance
CheKseg0CacheOn();
mJTAGPortEnable(0);
PMCONbits.ON = 0;
}//end InitializeSystem
/**
* @fn void gpioInit( void );
* @brief Configuration des GPIO
*/
void gpioInit( void ) {
// Désactivation du JTAG pour accéder aux LEDs
mJTAGPortEnable( DEBUG_JTAGPORT_OFF );
// RD1 en sortie
PORTSetPinsDigitalOut( IOPORT_D, BIT_1 );
// Initialisation de RD1 au niveau bas
mPORTDClearBits( BIT_1 );
}
// *--------------------------------------------------------------------------------*
int main(){
UINT16 Count=0;
mJTAGPortEnable(0); // JTAG des-habilitado
SYSTEMConfigPerformance(GetSystemClock()); // Activa pre-cache.-
LED1_OUTPUT();
LED2_OUTPUT();
INTEnableSystemMultiVectoredInt();
deviceAttached = FALSE;
//Initialize the stack
USBInitialize(0);
while(1){
//USB stack process function
USBTasks();
if(++Count==0){
LED1_TOGGLE();
}
//if thumbdrive is plugged in
if(USBHostMSDSCSIMediaDetect()){
deviceAttached = TRUE;
LED1_OFF();
//now a device is attached
//See if the device is attached and in the right format
if(FSInit()){
//Opening a file in mode "w" will create the file if it doesn't
// exist. If the file does exist it will delete the old file
// and create a new one that is blank.
myFile = FSfopen("test.txt","w");
//Write some data to the new file.
FSfwrite("This is a test.",1,15,myFile);
//Always make sure to close the file so that the data gets
// written to the drive.
FSfclose(myFile);
//Just sit here until the device is removed.
while(deviceAttached == TRUE){
USBTasks();
if(++Count==0){
LED2_TOGGLE();
}
}
LED2_OFF();
}
}
}
}
void InitializeSystem()
{
SYSTEMConfigWaitStatesAndPB(CLOCK_FREQ);
mOSCSetPBDIV(OSC_PB_DIV_4); // Set to get 20MHz PB clock
//mOSCSetPBDIV(OSC_PB_DIV_2);
CheKseg0CacheOn();
mJTAGPortEnable(0);
// Initialize the pins to all digital output and driven to ground.
// Exception is RE7 and RE6 which are switch inputs
PORTSetPinsDigitalIn(IOPORT_E, BIT_6);
PORTSetPinsDigitalIn(IOPORT_E, BIT_7);
mPORTASetPinsDigitalOut(0xFFFF);
mPORTBSetPinsDigitalOut(0xFFFF);
mPORTCSetPinsDigitalOut(0xFFFF);
mPORTDSetPinsDigitalOut(0xFFFF);
mPORTESetPinsDigitalOut(0xFF3F);
mPORTFSetPinsDigitalOut(0xFFFF);
mPORTGSetPinsDigitalOut(0xFFFF);
mPORTAClearBits(0xFFFF);
mPORTBClearBits(0xFFFF);
mPORTCClearBits(0xFFFF);
mPORTDClearBits(0xFFFF);
mPORTEClearBits(0xFF3F);
mPORTESetBits(0x000F); // LED latches need to be set high for off
mPORTFClearBits(0xFFFF);
mPORTGClearBits(0xFFFF);
INTEnableSystemMultiVectoredInt();
#ifdef SANITY_CHECK
mLED_Green_On();
#endif
//LCD_Initialize();
//WIFI_Initialize();
//SPRINKLER_Initialize();
//RTCC_Initialize();
//SERIALUSB_Initialize();
SDCARD_Initialize();
TCPIP_Initialize();
}
void SYS_Initialize ( void* data )
{
SYSTEMConfig(GetSystemClock(), SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
/* Disable JTAG to free up PORTA pins */
mJTAGPortEnable(DEBUG_JTAGPORT_OFF);
BSP_Initialize();
INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
INTEnableInterrupts();
BSP_WriteString("*** UART Interrupt-driven Application Example ***\r\n");
BSP_WriteString("*** Type some characters and observe echo ***\r\n");
/* Initialize the Application */
APP_Initialize ( );
}
int main()
{
mJTAGPortEnable(DEBUG_JTAGPORT_OFF);
mPORTFClearBits(BIT_0);
// Make all lower 8-bits of PORTA as output
mPORTFSetPinsDigitalOut( BIT_0 );
// Start timer1, Fpb/256, max period
OpenTimer1(T1_ON | T1_PS_1_256 | T1_SOURCE_INT, 0xFFFF);
// The main loop
while( 1)
{
WriteTimer1(0);
while ( TMR1 < LONG_DELAY);
PORTF ^= BIT_0;
}
}
int main()
{
mJTAGPortEnable(DEBUG_JTAGPORT_OFF);
mPORTFClearBits(BIT_0);
// Make all lower 8-bits of PORTA as output
mPORTFSetPinsDigitalOut( BIT_0 );
TRISE=0x0;
PORTE = 0x0f;
// Start timer1, Fpb/256, max period
OpenTimer1(T1_ON | T1_PS_1_256 | T1_SOURCE_INT, 0xFFFF);
// The main loop
PORTSetPinsDigitalIn(IOPORT_D, BIT_5);
mCNOpen(CN_ON, CN14_ENABLE, 0);
// Read the port to clear any mismatch on change notice pins
int dummy = PORTD;
// Clear change notice interrupt flag
ConfigIntCN(CHANGE_INT_ON | CHANGE_INT_PRI_2);
INTEnableSystemMultiVectoredInt();
uart1_init(115200);
setbuf(stdin, NULL); //no input buffer (for scanf)
setbuf(stdout, NULL); //no output buffer (for printf)
printf ("Hello World!\r\n");
while( 1)
{
putchar(getchar());
WriteTimer1(0);
while ( TMR1 < LONG_DELAY);
PORTE+=1;
}
}
int main()
{
char arry[255]={0};
mJTAGPortEnable(0);
lcd_config();
lcd_ini();
chip_select(); //select the slavehhjhjkhk
unsigned short address=0x0000;
unsigned char da_ta=0x20;
unsigned char loc=0x80;
for(i=0x0000,n=0;n<255;i++,n++)
{
lcd_ini();
arry[n]=read_ext_eeprom(i);
}
}
// *--------------------------------------------------------------------------------*
int main(){
UINT8 k=0;
UINT16 Conversion;
mJTAGPortEnable(0); // JTAG des-habilitado
SYSTEMConfigPerformance(GetSystemClock()); // Activa pre-cache.-
LED1_OUTPUT();
LED2_OUTPUT();
LED3_OUTPUT();
LED4_OUTPUT();
SW1_INPUT();
SW2_INPUT();
PORTSetPinsDigitalOut(IOPORT_D, BIT_1); // Backlight del TFT
mPORTDSetBits(BIT_1);
vLCDTFTInit();
vLCDTFTFillScreen(ColorWhite);
vADC_Init();
while(1){
if(SW1_STATUS()==0){
vLCDTFTRectangle(0,0,200,319,1,Colores[k]);
if(++k==6){k=0;}
DelayMs(250);
}
if(SW2_STATUS()==0){
LED2_TOGGLE();
LED4_TOGGLE();
DelayMs(250);
}
Conversion=ADC_Conversion();
vLCDTFTRectangle(201,0,239,319,1,ColorWhite);
// 1023 -> 0; 0 -> 239
vLCDTFTRectangle(202,((-0.31183*Conversion)+319.0),238,319,1,ColorRed);
DelayMs(50);
}
}
/**
* @fn void userInit( void );
* @brief Configuration des périphériques
*/
void userInit( void ) {
unsigned int periphBusClk;
// Config Système
// Cache (wait states) et bus périphériques
// retourne la vitesse de travail du bus périphérque (non utilisée)
periphBusClk = SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
// Désactivation du JTAG pour accéder aux LEDs
mJTAGPortEnable( DEBUG_JTAGPORT_OFF );
// Config UART
uartInit();
// uartPutString("UART configured\r\n");
//Config GPIO
gpioInit();
// uartPutString("GPIO configured\r\n");
// Config PWM
timerInit();
pwmInit();
// uartPutString("PWM configured\r\n");
// Config SPI
spiChannel = ads7885Pic32Open( CHN_SPI, 20 );
// uartPutString("SPI configured\r\n");
// Init du l'algorithme de commande
mesure[2][pMesure]=ads7885Pic32Read( CHN_SPI,3);//data_VO;
init_stockage(mesure[2][pMesure],pwm,ref);
// Config CAN1
CAN1Init();
// uartPutString("CAN configured\r\n");
}
int main(void) {
// Initial setup of the I/O ports.
AD1PCFG = 0xFFFF; // Default all pins to digital.
mJTAGPortEnable(0); // Turn off JTAG.
// Setup the CPU.
// System config performance.
SYSTEMConfigPerformance(CLOCKFREQ);
#if defined(MAXIMITE) || (defined(UBW32) && defined(__DEBUG)) || \
defined(DUINOMITE)
// Fix the peripheral bus to the main clock speed.
mOSCSetPBDIV(OSC_PB_DIV_1);
#endif
INTEnableSystemMultiVectoredInt(); // Allow vectored interrupts.
keyboard_init(); // Initialise and startup the keyboard routines.
video_init(); // Start the video state machine.
video_clear_screen(); // Clear the video buffer.
DelayUs(1*1000*1000);
while (keyboard_inkey() != -1);
video_display_string("MAXIMITE console\r\n");
while (1) {
int ch = input_key();
video_put_char(ch);
{
static char buf[10];
sprintf(buf, "<%02X>", ch);
video_display_string(buf);
}
if (ch == '\n') video_put_char('\r');
}
}
int main(void)
{
unsigned int wait = 0;
int readcount = 0;
unsigned int CurPin = 0;
unsigned int PinListing = 0;
char FunctionResponse = 0;
char TestFailed = FALSE;
//SERIAL_Init();
//INTEnableSystemMultiVectoredInt();
BOARD_Init();
mJTAGPortEnable(0);
printf("\r\nUno A/D Test Harness\r\nThis will initialize all A/D pins and read them %d times\r\n", TIMES_TO_READ);
//printf("Value of pcfg before test: %X\r\n", AD1PCFG);
// while(!IsTransmitEmpty());
//AD_Init(BAT_VOLTAGE);
//AD_Init();
printf("Testing functionality before initialization\r\n");
/*adding pins individually */
printf("AD_AddPins on each pin indvidually which results in failure: ");
for (CurPin = 1; CurPin < ALLADPINS; CurPin <<= 1) {
FunctionResponse = AD_AddPins(CurPin);
if (FunctionResponse != ERROR) {
TestFailed = TRUE;
break;
}
}
if (TestFailed) {
printf("FAIL\r\n");
} else {
printf("PASSED\r\n");
}
TestFailed = FALSE;
/*removing pins individually*/
printf("AD_RemovePins on each pin indvidually which results in failure: ");
for (CurPin = 1; CurPin < ALLADPINS; CurPin <<= 1) {
FunctionResponse = AD_RemovePins(CurPin);
if (FunctionResponse != ERROR) {
TestFailed = TRUE;
break;
}
}
if (TestFailed) {
printf("FAIL\r\n");
} else {
printf("PASSED\r\n");
}
TestFailed = FALSE;
/*listing pins while inactive*/
printf("AD_ActivePins which should return 0: ");
PinListing = AD_ActivePins();
if (PinListing != 0x0) {
printf("FAILED\r\n");
} else {
printf("PASSED\r\n");
}
// /*calling ned when inactive*/
// printf("AD_End which should fail: ");
// FunctionResponse = AD_End();
// if (FunctionResponse != ERROR) {
// printf("FAILED\r\n");
// } else {
// printf("PASSED\r\n");
// }
/*activating module*/
printf("initializing using AD_Init: ");
FunctionResponse = AD_Init();
if (FunctionResponse != SUCCESS) {
printf("FAILED\r\n");
} else {
printf("PASSED\r\n");
}
/*attempting to reactivate*/
printf("initializing using AD_Init again returns error: ");
FunctionResponse = AD_Init();
if (FunctionResponse != ERROR) {
printf("FAILED\r\n");
} else {
printf("PASSED\r\n");
}
printf("Testing Functionality after initialization\r\n");
/*active pins after activation only has battery*/
printf("Ad_ActivePins should only return BAT_VOLTAGE: ");
PinListing = AD_ActivePins();
if (PinListing == BAT_VOLTAGE) {
printf("PASSED\r\n");
} else {
printf("FAILED\r\n");
}
/*each pin added should succeed*/
printf("Adding each pin using AD_AddPins indivdually: ");
for (CurPin = 1; CurPin < ALLADMINUSBATT; CurPin <<= 1) {
PinListing = AD_ActivePins();
FunctionResponse = AD_AddPins(CurPin);
if (FunctionResponse != SUCCESS) {
TestFailed = TRUE;
break;
}
while (AD_ActivePins() != (PinListing | CurPin));
}
if (TestFailed) {
printf("FAIL\r\n");
} else {
printf("PASSED\r\n");
}
/*removing each pin should succeed */
printf("Removing each pin using AD_RemovePins indivdually: ");
for (CurPin = 1; CurPin < ALLADMINUSBATT; CurPin <<= 1) {
PinListing = AD_ActivePins();
FunctionResponse = AD_AddPins(CurPin);
if (FunctionResponse != SUCCESS) {
TestFailed = TRUE;
break;
}
while (AD_ActivePins() != (PinListing | CurPin));
}
if (TestFailed) {
printf("FAIL: %X\r\n", 0xFEED);
} else {
printf("PASSED\r\n");
}
while (1);
printf("We will now add the odd pins and wait for them to be activated");
AD_AddPins(ODD_ACTIVE);
while (!(AD_ActivePins() & ODD_ACTIVE)) {
if (IsTransmitEmpty()) {
printf("%X\r\n", AD_ActivePins());
}
}
printf("The Odd pins are now active as shown by Active pins: %X\r\n", AD_ActivePins());
printf("We will now enable the even pins and wait for them to be activated");
AD_AddPins(EVEN_ACTIVE);
while (!(AD_ActivePins() & EVEN_ACTIVE));
printf("The Even pins are now active as shown by Active pins: %X\r\n", AD_ActivePins());
char numtoread = NUM_AD_PINS;
unsigned char cur = 0;
DELAY(400000)
while (readcount <= TIMES_TO_READ) {
DELAY(100000);
printf("\r\n");
for (cur = 0; cur < numtoread; cur++) {
printf("%d\t", AD_ReadADPin(1 << cur));
}
printf("\r\n");
readcount++;
}
printf("Done Reading Them\r\n");
AD_End();
printf("Value of pcfg after test: %X", AD1PCFG);
return 0;
}
int main(int argc, char *argv[]) {
register char *s, *p;
register char *pn = argv[0];
// configure the I/O ports
AD1PCFG = 0xFFFF; // Default all pins to digital
mJTAGPortEnable(0); // turn off jtag
// setup the CPU
SYSTEMConfigPerformance(CLOCKFREQ); // System config performance
mOSCSetPBDIV(OSC_PB_DIV_1); // fix the peripheral bus to half main clock speed
INTEnableSystemMultiVectoredInt();
TRISBbits.TRISB15 = 0;
// TRISDbits.TRISD11 = 0;
// ODCDbits.ODCD11 = 1;
// LATDbits.LATD11=0;
TRISBbits.TRISB13 = 0;
ODCBbits.ODCB13 = 1;
PORTBbits.RB13=0;
#ifdef UARTConsole
UARTInit();
#endif
initKeyboard();
#ifdef UseVideo
initVideo();
#endif
#ifdef CPU_SPEED
f_flag = CPU_SPEED;
tmax = CPU_SPEED * 10000;
#endif
argc = 0;
while (--argc > 0 && (*++argv)[0] == '-')
for (s = argv[0] + 1; *s != '\0'; s++)
switch (*s) {
case 's': /* save core and CPU on exit */
s_flag = 1;
break;
case 'l': /* load core and CPU from file */
l_flag = 1;
break;
#ifdef Z80_UNDOC
case 'z': /* trap undocumented Z80 ops */
z_flag = 1;
break;
#endif
case 'i': /* trap I/O on unused ports */
i_flag = 1;
break;
case 'm': /* initialize Z80 memory */
m_flag = exatoi(s + 1);
s += strlen(s + 1);
break;
case 'f': /* set emulation speed */
f_flag = atoi(s + 1);
s += strlen(s + 1);
tmax = f_flag * 10000;
break;
case 'x': /* get filename with Z80 executable */
x_flag = 1;
s++;
p = xfn;
while (*s)
*p++ = *s++;
*p = '\0';
s--;
break;
case '?':
goto usage;
default:
printf("illegal option %c\n", *s);
#ifndef Z80_UNDOC
usage:
printf("usage:\t%s -s -l -i -mn -fn -xfilename\n", pn);
#else
usage:
printf("usage:\t%s -s -l -i -z -mn -fn -xfilename\n", pn);
#endif
puts("\ts = save core and cpu");
puts("\tl = load core and cpu");
puts("\ti = trap on I/O to unused ports");
#ifdef Z80_UNDOC
puts("\tz = trap on undocumented Z80 ops");
#endif
puts("\tm = init memory with n");
puts("\tf = CPU frequenzy n in MHz");
puts("\tx = load and execute filename");
exit(1);
}
putchar('\n');
puts("####### ##### ### ##### ### # #");
puts(" # # # # # # # # ## ##");
puts(" # # # # # # # # # # #");
puts(" # ##### # # ##### ##### # # # #");
puts(" # # # # # # # # #");
puts(" # # # # # # # # # #");
puts("####### ##### ### ##### ### # #");
printf("\nRelease %s, %s\n", RELEASE, COPYR);
printf("\nPort to PIC32 By kenseglerdesigns.com\n");
if (f_flag > 0)
printf("\nCPU speed is %d MHz\n", f_flag);
else
printf("\nCPU speed is unlimited\n");
#ifdef USR_COM
printf("\n%s Release %s, %s\n", USR_COM, USR_REL, USR_CPR);
#endif
fflush(stdout);
wrk_ram = PC = ram;
STACK = ram +0xffff;
memset((char *) ram, m_flag, 65536);
if (l_flag)
if (load_core())
return (1);
int_on();
init_io();
mon();
if (s_flag)
save_core();
exit_io();
int_off();
return (0);
}
/*******************************************************************************
* Function: BoardInit(void)
* PreCondition:None
* Input: None
* Output: None
* Overview: SPI pins and SFR, Maintenance Tasks Timer, External Interrupts,
* and other board issues initialization.
* Note: This routine needs to be called before initialising MiWi stack
* or invoking other function that operates on MiWi stack.
******************************************************************************/
void BoardInit(void){
#if defined(__PIC32MX__)
// RADIO INTERFACES & SPI INIT -------------------------------------------//
#if defined HARDWARE_SPI
/* Peripheral Bus Frequency = System Clock / PB Divider */
unsigned int pbFreq;
pbFreq = (DWORD) CLOCK_FREQ/(1 << mOSCGetPBDIV());
unsigned int SPI_Clk_Freq;
unsigned char SPI_Brg;
#endif
#if defined MRF24J40
PHY_CS_TRIS = OUTPUT_PIN;
PHY_CS = 1;
PHY_RESETn_TRIS = OUTPUT_PIN;
PHY_RESETn = 1;
MRF24J40_INT_TRIS = INPUT_PIN;
SDI_TRIS = INPUT_PIN;
SDO_TRIS = OUTPUT_PIN;
SCK_TRIS = OUTPUT_PIN;
SPI_SDO = 0;
SPI_SCK = 0;
PHY_WAKE_TRIS = OUTPUT_PIN;
PHY_WAKE = 1;
MRF24J40_PWR_TRIS = OUTPUT_PIN;
MRF24J40_PWR = 1;
SPICONCLR = 0xFFFFFFFF; // Clear SPIxCON register
#ifdef HARDWARE_SPI
/* Enable SPI, Set to Master Mode & Set CKE bit : Serial output
* data changes on transition from active clock state to Idle
* clock state */
SPICON = 0x00008120;
/* PB Frequency can be maximum 40 MHz */
if(pbFreq > (2 * MAX_SPI_CLK_FREQ_FOR_P2P)){
SPI_Brg = 1;
/* Continue the loop till you find SPI Baud Rate Reg Value */
while(1){
/* SPI Clock Calculation as per PIC32 Manual */
SPI_Clk_Freq = pbFreq / (2 * (SPI_Brg + 1));
if(SPI_Clk_Freq <= MAX_SPI_CLK_FREQ_FOR_P2P){
break;
}
SPI_Brg++;
}
#if defined MRF24J40_IN_SPI1
mSpiChnSetBrg (1, SPI_Brg);
#elif defined MRF24J40_IN_SPI2
mSpiChnSetBrg (2, SPI_Brg);
#elif defined MRF24J40_IN_SPI3
mSpiChnSetBrg (1A, SPI_Brg);
#elif defined MRF24J40_IN_SPI4
mSpiChnSetBrg (3A, SPI_Brg);
#endif
}
else{
#if defined MRF24J40_IN_SPI1
mSpiChnSetBrg (1, 0);
#elif defined MRF24J40_IN_SPI2
mSpiChnSetBrg (2, 0);
#elif defined MRF24J40_IN_SPI3
mSpiChnSetBrg (1A, 0);
#elif defined MRF24J40_IN_SPI4
mSpiChnSetBrg (3A, SPI_Brg);
#endif
}
#endif
#endif
#if defined(MRF49XA_1)
// pruebas de funcionamiento
/* MRF49XA_1_PHY_CS_TRIS = OUTPUT_PIN;
MRF49XA_1_PHY_CS = 0;
MRF49XA_1_PHY_CS = 1;
MRF49XA_1_PHY_RESETn_TRIS = OUTPUT_PIN;
MRF49XA_1_PHY_RESETn = 0;
MRF49XA_1_PHY_RESETn = 1;
MRF49XA_1_INT_TRIS = OUTPUT_PIN;
MRF49XA_1_INT_PIN = 0;
MRF49XA_1_INT_PIN = 1;
MRF49XA_1_SDI_TRIS = OUTPUT_PIN;
MRF49XA_1_SPI_SDI = 0;
MRF49XA_1_SPI_SDI = 1;
MRF49XA_1_SDO_TRIS = OUTPUT_PIN;
MRF49XA_1_SPI_SDO = 0;
MRF49XA_1_SPI_SDO = 1;
MRF49XA_1_SCK_TRIS = OUTPUT_PIN;
MRF49XA_1_SPI_SCK = 0;
MRF49XA_1_SPI_SCK = 1;
MRF49XA_1_nFSEL_TRIS = OUTPUT_PIN;
MRF49XA_1_nFSEL = 0;
MRF49XA_1_nFSEL = 1;
MRF49XA_1_FINT_TRIS = OUTPUT_PIN;
MRF49XA_1_FINT = 0;
MRF49XA_1_FINT = 1;
*/
// configuration. Juan: Added; Agus: Modified to a standard way
MRF49XA_1_PHY_CS_TRIS = OUTPUT_PIN;
MRF49XA_1_PHY_CS = 1;
MRF49XA_1_PHY_RESETn_TRIS = OUTPUT_PIN;
MRF49XA_1_PHY_RESETn = 1;
MRF49XA_1_INT_TRIS = INPUT_PIN;
MRF49XA_1_SDI_TRIS = INPUT_PIN;
MRF49XA_1_SDO_TRIS = OUTPUT_PIN;
MRF49XA_1_SCK_TRIS = OUTPUT_PIN;
MRF49XA_1_SPI_SDO = 0;
MRF49XA_1_SPI_SCK = 0;
MRF49XA_1_nFSEL_TRIS = OUTPUT_PIN;
MRF49XA_1_FINT_TRIS = INPUT_PIN;
MRF49XA_1_nFSEL = 1; // nFSEL inactive
#ifdef cNGD_PLATFORM
// MRF49XA_1_PWR_TRIS = OUTPUT_PIN;
// MRF49XA_1_PWR = 1;
#endif
MRF49XA_1_SPICONCLR = 0xFFFFFFFF; //Clear SPIxCON register
#ifdef HARDWARE_SPI
/* Enable SPI1, Set to Master Mode & Set CKE bit : Serial output
* data changes on transition from active clock state to Idle
* clock state */
MRF49XA_1_SPICON = 0x00008120;
/* PB Frequency can be maximum 40 MHz */
if(pbFreq > (2 * MAX_SPI_CLK_FREQ_FOR_P2P)){
SPI_Brg = 1;
/* Continue the loop till you find SPI Baud Rate Reg Value */
while(1){
/* SPI Clock Calculation as per PIC32 Manual */
SPI_Clk_Freq = pbFreq / (2 * (SPI_Brg + 1));
if(SPI_Clk_Freq <= MAX_SPI_CLK_FREQ_FOR_P2P){
break;
}
SPI_Brg++;
}
#if defined MRF49XA_1_IN_SPI1
mSpiChnSetBrg (1, SPI_Brg);
#elif defined MRF49XA_1_IN_SPI2
mSpiChnSetBrg (2, SPI_Brg);
#elif defined MRF49XA_1_IN_SPI3
mSpiChnSetBrg (1A, SPI_Brg);
#endif
}
else{
#if defined MRF49XA_1_IN_SPI1
mSpiChnSetBrg (1, 0);
#elif defined MRF49XA_1_IN_SPI2
mSpiChnSetBrg (2, 0);
#elif defined MRF49XA_1_IN_SPI3
mSpiChnSetBrg (1A, 0);
#endif
}
#endif
#endif
#if defined(MRF49XA_2)
MRF49XA_2_PHY_CS_TRIS = OUTPUT_PIN;
MRF49XA_2_PHY_CS = 1;
MRF49XA_2_PHY_RESETn_TRIS = OUTPUT_PIN;
MRF49XA_2_PHY_RESETn = 1;
MRF49XA_2_INT_TRIS = 1;
MRF49XA_2_SDI_TRIS = INPUT_PIN;
MRF49XA_2_SDO_TRIS = OUTPUT_PIN;
MRF49XA_2_SCK_TRIS = OUTPUT_PIN;
MRF49XA_2_SPI_SDO = 0;
MRF49XA_2_SPI_SCK = 0;
MRF49XA_2_nFSEL_TRIS = OUTPUT_PIN;
MRF49XA_2_FINT_TRIS = INPUT_PIN;
MRF49XA_2_nFSEL = 1; // nFSEL inactive
#ifdef cNGD_PLATFORM
MRF49XA_2_PWR_TRIS = OUTPUT_PIN;
MRF49XA_2_PWR = 1;
#endif
MRF49XA_2_SPICONCLR = 0xFFFFFFFF; // Clear SPIxCON register
#ifdef HARDWARE_SPI
/* Enable SPI1, Set to Master Mode & Set CKE bit : Serial output
* data changes on transition from active clock state to Idle
* clock state */
MRF49XA_2_SPICON = 0x00008120;
/* PB Frequency can be maximum 40 MHz */
if(pbFreq > (2 * MAX_SPI_CLK_FREQ_FOR_P2P)){
SPI_Brg = 1;
/* Continue the loop till you find SPI Baud Rate Reg Value */
while(1){
/* SPI Clock Calculation as per PIC32 Manual */
SPI_Clk_Freq = pbFreq / (2 * (SPI_Brg + 1));
if(SPI_Clk_Freq <= MAX_SPI_CLK_FREQ_FOR_P2P){
break;
}
SPI_Brg++;
}
#if defined MRF49XA_2_IN_SPI1
mSpiChnSetBrg (1, SPI_Brg);
#elif defined MRF49XA_2_IN_SPI2
mSpiChnSetBrg (2, SPI_Brg);
#elif defined MRF49XA_2_IN_SPI3
mSpiChnSetBrg (1A, SPI_Brg);
#endif
}
else{
#if defined MRF49XA_2_IN_SPI1
mSpiChnSetBrg (1, 0);
#elif defined MRF49XA_2_IN_SPI2
mSpiChnSetBrg (2, 0);
#elif defined MRF49XA_2_IN_SPI3
mSpiChnSetBrg (1A, 0);
#endif
}
#endif
#endif
#if defined MRF89XA
Data_nCS_TRIS = 0;
Config_nCS_TRIS = 0;
Data_nCS = 1;
Config_nCS = 1;
PHY_IRQ1_TRIS = 1;
//... REVIEW...
#endif
// SPI & EXTERNAL INTERRUPTS PINS AND CONFIGURATION ----------------------//
/* Set the SPI Port Directions (SDO, SDI, SCK) for every SPI module.*/
#if defined SPI1_IN_USE
SDI1_TRIS = INPUT_PIN; //DIGITAL IN
SDO1_TRIS = OUTPUT_PIN; //DIGITAL OUT
SCK1_TRIS = OUTPUT_PIN; //DIGITAL OUT
#endif
#if defined SPI2_IN_USE
SDI2_TRIS = INPUT_PIN; //DIGITAL IN
SDO2_TRIS = OUTPUT_PIN; //DIGITAL OUT
SCK2_TRIS = OUTPUT_PIN; //DIGITAL OUT
#endif
#if defined SPI3_IN_USE
SDI3_TRIS = INPUT_PIN; //DIGITAL IN
SDO3_TRIS = OUTPUT_PIN; //DIGITAL OUT
SCK3_TRIS = OUTPUT_PIN; //DIGITAL OUT
#endif
#if defined SPI4_IN_USE
SDI4_TRIS = INPUT_PIN; //DIGITAL IN
SDO4_TRIS = OUTPUT_PIN; //DIGITAL OUT
SCK4_TRIS = OUTPUT_PIN; //DIGITAL OUT
#endif
/* Set the external interrups Pin Directions and Priority*/
#if defined INT1_IN_USE
INT1_TRIS = INPUT_PIN; // DIGITAL IN
mINT1SetIntPriority(4);
mINT1SetIntSubPriority(2);
mINT1SetEdgeMode(0); //0: Falling Edge.
// Enable INT1
mINT1IntEnable(1);
#endif
#if defined INT2_IN_USE
INT2_TRIS = INPUT_PIN; // DIGITAL IN
mINT2SetIntPriority(4);
mINT2SetIntSubPriority(2);
mINT2SetEdgeMode(0); //0: Falling Edge.
/* Enable INT2 */
mINT2IntEnable(1);
#endif
#if defined INT3_IN_USE
INT3_TRIS = INPUT_PIN; // DIGITAL IN
mINT3SetIntPriority(4);
mINT3SetIntSubPriority(2);
mINT3SetEdgeMode(0); //0: Falling Edge.
/* Enable INT3 */
mINT3IntEnable(1);
#endif
#if defined INT4_IN_USE
INT4_TRIS = INPUT_PIN; // DIGITAL IN
mINT4SetIntPriority(4);
mINT4SetIntSubPriority(2);
mINT4SetEdgeMode(0); //0: Falling Edge.
/* Enable INT4 */
mINT4IntEnable(1);
#endif
// LEDs
#ifdef cNGD_PLATFORM
mJTAGPortEnable(0); //Needed due to multiplexed pins
LED1_TRIS = OUTPUT_PIN;
LED2_TRIS = OUTPUT_PIN;
LED3_TRIS = OUTPUT_PIN;
LED1 = 0;
LED2 = 0;
LED3 = 0;
#endif
// TIMER 1 FOR TIME_SYNC -------------------------------------------------//
#if defined(ENABLE_TIME_SYNC)
//TIMER 1 MAY BE USED FOR SLEEP MODE AND/OR FOR STACKS MAINTENANCE. IT
//NEEDS ADAPTATION BEFORE ENABLING TIME_SYNC WITH TIMER 1 TOO!
T1CON = 0;
T1CON = 0x0012;
T1CONSET = 0x8000;
PR1 = 0xFFFF;
IFS0bits.T1IF = 0;
mT1IntEnable(1);
mT1SetIntPriority(4);
while(T1CONbits.TWIP);
TMR1 = 0;
#endif
// TIMER 1 FOR NODE STACKS AUTO-MAINTENANCE ------------------------------//
#if defined NODE_DOES_MAINTENANCE_TASKS
T1CON = 0x0070; //Disable timer, PBCLK source, PS=256
TMR1 = 0x0000; //Reset count
PR1 = MAINTENANCE_PERIOD; //Set period.
IPC1SET = 0x00000005; //Set Priority level 1, Subpriority level 1
IFS0CLR = 0x00000010; //Clear T1IF
IEC0SET = 0x00000010; //Set T1IE
//Timer will be triggered after initialization.
#endif
//************************************* TODO
// IOPORT CN - For waking up the node manually. --------------------------//
mPORTDSetPinsDigitalIn(BIT_5); // CN14
CNCON = 0x8000; //Module enabled.
CNEN = 0x00004000; //Enable CN14
CNPUE = 0x00004000; //Enable CN14 weak pull-up.
ReadBUTTONS(); //Clear PORT mismatch condition.
IFS1CLR = 0x00000001; //Clear the CN interrupt flag status bit
IPC6SET = 0x00180000; //Set CN priority 6, subpriority 0.
//It will be enabled only during sleep mode time interval
//------------------------------------------------------------------------//
// Lo modifico en el wifi config
#if defined(ENABLE_NVM) //REVIEW
//EE_nCS_TRIS = 0;//FERNANDO, CUIDADO NO SE SI LA PILA REALMENTE FUNCIONA CON FLASH MEMORY
//EE_nCS = 1;
#endif
// INTERRUPTION FLAGS AND EXT_INT PIN FINAL SETTINGS ---------------------//
#if defined MRF49XA_1
MRF49XA_1_IF = 0;
if(MRF49XA_1_INT_PIN == 0){
MRF49XA_1_IF = 1;
}
#endif
#if defined MRF49XA_2
MRF49XA_2_IF = 0;
if(MRF49XA_2_INT_PIN == 0){
MRF49XA_2_IF = 1;
}
#endif
#if defined MRF89XA
PHY_IRQ1 = 0;
#endif
#if defined MRF24J40
MRF24J40_IF = 0;
if(MRF24J40_INT_PIN == 0){
MRF24J40_IF = 1;
}
#endif
#else //Not PIC32.
#error "Unknown target board."
#endif
}
void InitializeSystem() {
#ifdef BOARD_UBW32
// Disable ADC port (allows PORTB to be used for digital I/O)
AD1PCFG = 0xFFFF;
TRISE = 0x0000;
TRISB = 0x0000;
TRISC = 0x0000;
TRISD = 0x0000;
LATE = 0x0000;
LATB = 0x0000;
LATC = 0x0000;
LATD = 0x0000;
#endif
#ifdef BOARD_HEXLIGHT
ANSELA = 0x0000;
ANSELB = 0x0000;
#endif
LATA = 0x0000;
LATB = 0x0000;
// Ensure LED drivers are driven low as soon as possible
// _TRIS(PIO_OC1) = 0;
// _TRIS(PIO_OC2) = 0;
// _TRIS(PIO_OC3) = 0;
// _TRIS(PIO_OC4) = 0;
// _LAT(PIO_OC1) = OUTPUT;
// _LAT(PIO_OC2) = OUTPUT;
// _LAT(PIO_OC3) = OUTPUT;
// _LAT(PIO_OC4) = OUTPUT;
// Force disconnect of USB bootloader
U1CON = 0x00000000;
U1PWRC = 0x00000000;
// LEDs
// _TRIS(PIO_LED1) = OUTPUT;
// _TRIS(PIO_LED2) = OUTPUT;
#ifdef BOARD_UBW32
_TRIS(PIO_LED3) = OUTPUT;
_TRIS(PIO_LED_USB) = OUTPUT;
_TRIS(PIO_BTN_PGM) = 1;
_TRIS(PIO_BTN_USR) = 1;
#elif BOARD_HEXLIGHT
_TRIS(PIO_BTN1) = INPUT;
_TRIS(PIO_BTN2) = INPUT;
#endif
// _TRIS(PIO_USBP) = INPUT;
// _TRIS(PIO_USBN) = INPUT;
// _LAT(PIO_LED1) = LOW;
// _LAT(PIO_LED2) = LOW;
#ifdef BOARD_UBW32
_LAT(PIO_LED3) = HIGH;
_LAT(PIO_LED_USB) = LOW;
#endif
mJTAGPortEnable(0);
// Initializethe PIC32 core
//OSCConfig(OSC_POSC_PLL, OSC_PLL_MULT_20, OSC_PLL_POST_2, OSC_FRC_POST_2);
sys_clock = F_SYSCLK;
mOSCSetPBDIV(OSC_PB_DIV_1);
pb_clock = SYSTEMConfig(sys_clock, SYS_CFG_ALL);
INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
INTEnableInterrupts();
// Initialize core time base
SystickInit();
}
main()
{
// Disable JTAG (on RA0 and RA1 )
mJTAGPortEnable( DEBUG_JTAGPORT_OFF );
// Configure the device for maximum performance but do not change the PBDIV
// Given the options, this function will change the flash wait states, RAM
// wait state and enable prefetch cache but will not change the PBDIV.
// The PBDIV value is already set via the pragma FPBDIV option above..
SYSTEMConfig(GetSystemClock(), SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
initializeUART();
initializeADC();
initializeLCD();
initializeRPG();
/* Initialize SD card */
setup_SDSPI();
SD_setStart();
/* Fill tempBuffer[] with int 0 to 63
* Write it to the current block.
* Empty tempBuffer[] to all 0.
* Read from the current block to make sure that it returns the right value.
*/
fillTempBuffer();
testSDReadWrite(tempBuffer);
curr_read_block = curr_block;
ConfigTimer1(); // Enable Timer1 for second counts
configureInterrupts();
// T2CON = 0x8030; // TMR1 on, prescale 1:256 PB
mPORTASetPinsDigitalOut( LED_MASK ); // LEDs = output
mPORTDSetPinsDigitalIn( PB_MASK_D ); // PBs on D = input
curr_state = READY;
// enable interrupts
INTEnableInterrupts();
int i = 0;
while( 1 )
{
if (getPrintToUARTFlag() == 1){
LCDMenuControl();
//mPORTAToggleBits( LED_MASK );
convertAndPrintIntegerToString("i => ", i++);
convertAndPrintIntegerToString("timeElapse => ", timeElapsed);
convertAndPrintIntegerToString("timeElapsedLEDSample => ", timeElapsedLEDSample);
convertAndPrintIntegerToString("timeElapsedLEDTurnedOff => ", timeElapsedLEDTurnedOff);
convertAndPrintIntegerToString("sampleLEDNow => ", sampleLEDNow);
convertAndPrintIntegerToString(" ADC Value => ", getChannel5Value());
printShadowDetect();
printLightLevel();
drawLightDetectedBar();
controlPowerRelay();
switch(curr_state) {
case READY : WriteString("State => READY ");
break;
case SLEEP : WriteString("State => SLEEP ");
break;
case HIBERNATE : WriteString("State => HIBERNATE");
break;
case BUSY : WriteString("State => BUSY ");
break;
}
WriteString("\r");
setPrintToUARTFlag(0);
}
if (NEW_BYTE_RECEIVED == 1){
curr_state = READY;
NEW_BYTE_RECEIVED = 0;
//mPORTAToggleBits( LED_MASK );
char tempArray[] = "g";
tempArray[0] = characterByteReceived;
WriteString(tempArray);
if(curr_state = HIBERNATE) {
addByteToBuffer(characterByteReceived);
}
else {
PutCharacter(characterByteReceived);
}
}
if(bufferIndex == 512) {
SDWriteBlock(currBlock);
currBlock++;
bufferIndex = 0;
}
if((curr_state == READY) && (timeElapsed >= SLEEP_TIMEOUT) && (timeElapsed < HIBERNATE_TIMEOUT)) {
curr_state = SLEEP;
}
else if((curr_state == SLEEP) && (timeElapsed >= HIBERNATE_TIMEOUT)) {
curr_state = HIBERNATE;
timeElapsed = 0;
}
if (transmitDataFromSDCard == 1) {
transmitDataFromSDCard = 0;
forwardDataToPrinter();
}
} // main (while) loop
return 0;
} // main
//******************************************************************************
//******************************************************************************
// Main
//******************************************************************************
//******************************************************************************
int main (void)
{
BYTE i;
DWORD temp;
int value;
value = SYSTEMConfigWaitStatesAndPB( GetSystemClock() );
mJTAGPortEnable(DEBUG_JTAGPORT_OFF);
// Enable the cache for the best performance
CheKseg0CacheOn();
value = OSCCON;
while (!(value & 0x00000020))
{
value = OSCCON; // Wait for PLL lock to stabilize
}
InitKeyboardDriver();
INTEnableSystemMultiVectoredInt();
// Init status LED
mPORTCSetBits(BIT_0);
mPORTCSetPinsDigitalOut(BIT_0);
//DBINIT();
// Initialize USB layers
USBInitialize(0);
while (1)
{
USBTasks();
App_Detect_Device();
switch (App_State_Keyboard)
{
case DEVICE_NOT_CONNECTED:
mPORTCSetBits(BIT_0);
USBTasks();
if (DisplayDeatachOnce == FALSE)
{
DBPRINTF("Device Detached\n");
DisplayDeatachOnce = TRUE;
}
if (USBHostHID_ApiDeviceDetect()) /* True if report descriptor is parsed with no error */
{
DBPRINTF("Device Attached\n");
App_State_Keyboard = DEVICE_CONNECTED;
DisplayConnectOnce = FALSE;
}
break;
case DEVICE_CONNECTED:
mPORTCClearBits(BIT_0);
App_State_Keyboard = READY_TO_TX_RX_REPORT;
if (DisplayConnectOnce == FALSE)
{
DisplayConnectOnce = TRUE;
DisplayDeatachOnce = FALSE;
}
InitializeTimer(); // start 10ms timer to schedule input reports
break;
case READY_TO_TX_RX_REPORT:
if (!USBHostHID_ApiDeviceDetect())
{
App_State_Keyboard = DEVICE_NOT_CONNECTED;
// DisplayOnce = FALSE;
}
break;
case GET_INPUT_REPORT:
if (USBHostHID_ApiGetReport(Appl_raw_report_buffer.Report_ID, Appl_ModifierKeysDetails.interfaceNum,
Appl_raw_report_buffer.ReportSize, Appl_raw_report_buffer.ReportData))
{
/* Host may be busy/error -- keep trying */
}
else
{
App_State_Keyboard = INPUT_REPORT_PENDING;
}
USBTasks();
break;
case INPUT_REPORT_PENDING:
if (USBHostHID_ApiTransferIsComplete(&ErrorDriver, &NumOfBytesRcvd))
{
if (ErrorDriver || (NumOfBytesRcvd != Appl_raw_report_buffer.ReportSize ))
{
ErrorCounter++ ;
if (MAX_ERROR_COUNTER <= ErrorDriver)
App_State_Keyboard = ERROR_REPORTED;
else
App_State_Keyboard = READY_TO_TX_RX_REPORT;
}
else
{
ErrorCounter = 0;
ReportBufferUpdated = TRUE;
App_State_Keyboard = READY_TO_TX_RX_REPORT;
if (DisplayConnectOnce == TRUE)
{
for (i = 0; i < Appl_raw_report_buffer.ReportSize; i++)
{
if (Appl_raw_report_buffer.ReportData[i] != 0)
{
//LCDClear();
//LCDL1Home();
DisplayConnectOnce = FALSE;
}
}
}
App_ProcessInputReport();
App_PrepareOutputReport();
}
}
break;
case SEND_OUTPUT_REPORT: /* Will be done while implementing Keyboard */
if (USBHostHID_ApiSendReport(Appl_LED_Indicator.reportID, Appl_LED_Indicator.interfaceNum, Appl_LED_Indicator.reportLength,
(BYTE*) & Appl_led_report_buffer))
{
/* Host may be busy/error -- keep trying */
}
else
{
App_State_Keyboard = OUTPUT_REPORT_PENDING;
}
USBTasks();
break;
case OUTPUT_REPORT_PENDING:
if (USBHostHID_ApiTransferIsComplete(&ErrorDriver, &NumOfBytesRcvd))
{
if (ErrorDriver)
{
ErrorCounter++ ;
if (MAX_ERROR_COUNTER <= ErrorDriver)
App_State_Keyboard = ERROR_REPORTED;
// App_State_Keyboard = READY_TO_TX_RX_REPORT;
}
else
{
ErrorCounter = 0;
App_State_Keyboard = READY_TO_TX_RX_REPORT;
}
}
break;
case ERROR_REPORTED:
break;
default:
break;
}
}
}