/********************************************************************
* 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)
{
ADCON1 |= 0x0F; // Default all pins to digital
#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 - (platform).h, and that an appropriate I/O pin
// has been mapped to it.
#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.
}//end InitializeSystem
/*******************************************************************
* Function: void USBCBInitEP(uint8_t ConfigurationIndex)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: This function is called when the device becomes
* initialized, which occurs after the host sends a
* SET_CONFIGURATION request. This
* callback function should initialize the endpoints
* for the device's usage according to the current
* configuration.
*
* Note: If the host ever "unconfigures" the device, it will
* set the configuration to '0'. In this case, this
* callback gets called with ConfigurationIndex == 0, where
* the firmware should disable all non-EP0 endpoints (until
* the next non-zero SET_CONFIGURATION request is received,
* which will cause this callback to execute again).
*******************************************************************/
void USBCBInitEP(uint8_t ConfigurationIndex)
{
//Check what configuration "index" the host has requested us to select.
//Configuration index 0 is special and represents that the device should be
//un-configured. However, when the host sets the confguration (with index
//matching the valid/implemenented configuration from the configuration descriptor),
//the firmware should enable the application endpoints associated with that
//configuration, and (re)initialize all application state variables associated
//with the USB application endpoints operation.
if(ConfigurationIndex == 1) //This application only implements one configuration, with index == 1.
{
//The host sent us a non-zero set configuration index. In this
//case we should prepare the application endpoints to be ready
//to use, and to (re-)initialize any application variables associated
//with the endpoints.
HIDInitEP();
//(Re-)Initialize the application variables associated with the USB interface
UserInit(); // See BootPIC[xxxx].c. Initializes the bootloader firmware state machine variables.
}
//else the host set the configuration back to 0 (indicating unconfigured), or
//to some higher (non-implemented value). In either case, we don't need to
//do anything specifically, unless the application requires some kind of
//"safe shutdown" code to execute after the host has deconfigured the device.
}
/********************************************************************
* Function: static void InitializeSystem(void)
* 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.
*******************************************************************/
static void InitializeSystem(void)
{
ANSELA = 0x00;
ANSELB = 0x00;
ANSELC = 0x00;
TRISA = 0;
LATA = 0;
TRISB = 0;
LATB = 0;
TRISC = 0;
LATC = 0;
LCDReset();
// 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 - (platform).h, and that an appropriate I/O pin
// has been mapped to it.
#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.
}//end InitializeSystem
/******************************************************************************
* 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)
{
ADCON1 |= 0x0F; // Default all pins to digital
mInitializeUSBDriver(); // See usbdrv.h
UserInit(); // See user.c & .h
}//end InitializeSystem
/******************************************************************************
* 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)
{
// 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
// usbcfg.h file.
#if defined(USE_USB_BUS_SENSE_IO)
tris_usb_bus_sense = INPUT_PIN; // See io_cfg.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 usbcfg.h, and that an appropriate I/O pin has been mapped
// to it in io_cfg.h.
#if defined(USE_SELF_POWER_SENSE_IO)
tris_self_power = INPUT_PIN;
#endif
//Initialize oscillator settings compatible with USB operation. Note,
//these may be application specific!
#if defined(PIC18F4550_PICDEM_FS_USB_K50)
OSCTUNE = 0x80; //3X PLL ratio mode selected
OSCCON = 0x70; //Switch to 16MHz HFINTOSC
OSCCON2 = 0x10; //Enable PLL, SOSC, PRI OSC drivers turned off
while(OSCCON2bits.PLLRDY != 1); //Wait for PLL lock
ACTCON = 0x90; //Enable active clock tuning for USB operation
//*((unsigned char*)0xFB5) = 0x90; //Enable active clock tuning for USB operation
#endif
mInitializeUSBDriver(); // See usbdrv.h
UserInit(); // See user.c & .h
mInitAllLEDs(); //Init them off.
}//end InitializeSystem
//#define analogTime 10
//static RunEveryData asyncSched = {0,analogTime};
void runDyIOMain(void) {
startScheduler();
AVR_Bowler_HAL_Init();
Bowler_Init();// Com Stack Init. Sets up timeout timer, uart 0 and if debug enabled, uart 1
UserInit();// User code init
while (1) {
//start = getMs();
UserRun();
server();
// //float one = getMs();
// if(FlagAsync == FLAG_OK ){
// if(checkDigital())
// server();
// }else{
// //println_I("Skipping D async");
// }
// //float two = getMs();
// server();
// //float three = getMs();
// if(FlagAsync == FLAG_OK ){
// if (RunEvery(&asyncSched)>0){
// if(checkAnalog())
// server();
// }else{
// now = getMs();
// if(!((asyncSched.MsTime >= 0) && (asyncSched.MsTime <= now))){
//#if ! defined(__AVR_ATmega324P__)
// println_E("Reseting async time, was=");p_fl_E(asyncSched.MsTime);print_E(" is=");p_fl_E(now);
// println_E("Timer in ticks:");p_int_E(GetTimeTicks());
//#endif
// asyncSched.setPoint = analogTime;
// asyncSched.MsTime=now;
// server();
// }
//
// }
// }else{
// //println_I("Skipping A async");
// }
// //float four = getMs();
// server();
// float five = getMs();
// println_I("TOTAL ");p_fl_I(start-five);
// println_I("\t\tDone servo ");p_fl_I(start-one);
// println_I("\t\tDone Dig ");p_fl_I(one-two);
// println_I("\t\tDone Server 1");p_fl_I(two-three);
// println_I("\t\tDone Analog ");p_fl_I(three-four);
// println_I("\t\tDone Server 2");p_fl_I(four-five);
}
}
static void InitializeSystem(void)
{
AD1PCFG = 0xFFFF;
SYSTEMConfigPerformance(80000000);
UserInit();
USBDeviceInit(); // Initializes USB module SFRs and firmware
// variables to known states.
ConfigINT0(EXT_INT_PRI_6 | RISING_EDGE_INT | EXT_INT_ENABLE);
mPMPOpen(PMP_CONTROL, PMP_MODE, PMP_PORT, PMP_INT);
PMPSetAddress(0x4000);
}
/********************************************************************
* 初期化関数
********************************************************************
*/
static void InitializeSystem(void)
{
#if RAM_SERIAL
extern void set_serial_number(void);
set_serial_number();
#endif
#if defined(__18F14K50)
// 入力ピンをデジタルモードにする.
ANSEL=0;
ANSELH=0;
#endif
ADCON1 = 0x0F; //Need to make sure RB4 can be used as a digital input pin
#if 1
// HIDaspx , PICwriter用 portb,portcを全入力にする.
TRISB = 0xFF;
TRISC = 0xFF;
#endif
#if defined(USE_USB_BUS_SENSE_IO)
tris_usb_bus_sense = INPUT_PIN;
#endif
#if defined(USE_SELF_POWER_SENSE_IO)
tris_self_power = INPUT_PIN;
#endif
mInitializeUSBDriver();
UserInit();
#if USE_PS2KEYBOARD // PS/2キーボードI/F を使用する.
kbd_init();
#endif
#if TIMER2_INTERRUPT
// timer2_init(0x80 |(15<<3)| 2,255); // 割り込みON,postscale 1/16,prescale 1/16,1/256 = 183.10 H
// timer2_init(0x80 |(14<<3)| 2,249); // 割り込みON,postscale 1/15,prescale 1/16,1/250 = 200Hz
// timer2_init(0x80 |(14<<3)| 2, 49); // 割り込みON,postscale 1/15,prescale 1/16,1/50 = 1000Hz
timer2_init(0x80 |(14<<3)| 2, 4); // 割り込みON,postscale 1/15,prescale 1/16,1/5 = 10kHz
// 割り込み許可.
InitTimer2InterruptLow(); // Timer2割り込みを low Priorityに設定する.
#else
INTCONbits.GIEL = 0; // Low Priority 割り込みを禁止.
INTCONbits.GIEH = 0; // High Priority 割り込みを禁止.
#endif
}
/**
* main(void) - Main entry point of the firmware
*
* This is the main entrance of the firmware and it creates the mail loop.
**/
void main(void)
{
/**
* Inits the PIC
**/
UserInit();
/**
* Inits the USB
*
* Full-speed mode and sets pull-up internal resistances of PORTB
* Starts the USB DEATACHED, no wake ups, and no configured.
* Configuring the USB is the job of the host.
**/
UCFG = 0x14;
deviceState = DETACHED;
remoteWakeup = 0x00;
currentConfiguration = 0x00;
adval = 'b';
ADCON0=0x00;
ADCON0bits.CHS0=0; //Select ADC Channel
ADCON0bits.CHS1=1; //Select ADC Channel
ADCON0bits.CHS2=1; //Select ADC Channel
ADCON0bits.CHS3=0; //Select ADC Channel
while (1) {
/**
* Make sure the USB is available
**/
EnableUSBModule();
/**
* As soon as we get out of test mode (UTEYE)
* we process USB transactions
**/
if (UCFGbits.UTEYE != 1)
ProcessUSBTransactions();
/**
* Now we can make our work
**/
ProcessIO();
//adval=ADCRead(7); //Read Channel 7
//delay(100);
//status();
}
}
BOOL CUDP_MFC_ClientDlg::OnInitDialog()
{
CDialogEx::OnInitDialog();
// 设置此对话框的图标。 当应用程序主窗口不是对话框时，框架将自动
// 执行此操作
SetIcon(m_hIcon, TRUE); // 设置大图标
SetIcon(m_hIcon, FALSE); // 设置小图标
ShowWindow(SW_NORMAL);
// TODO: 在此添加额外的初始化代码
UserInit();
return TRUE; // 除非将焦点设置到控件，否则返回 TRUE
}
static void InitializeSystem(void)
{
ADCON1 |= 0x0F; // Default all pins to digital
#if defined(USE_USB_BUS_SENSE_IO)
tris_usb_bus_sense = INPUT_PIN; // See HardwareProfile.h
#endif
#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
}//end InitializeSystem
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
return -1;
if (!m_wndStatusBar.Create(this))
{
TRACE0("Failed to create status bar\n");
return -1; // fail to create
}
m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT));
UserInit();
return 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)
{
ADCON1 |= 0x0F; // Default all pins to digital
#if defined(USE_USB_BUS_SENSE_IO)
tris_usb_bus_sense = INPUT_PIN; // See io_cfg.h
#endif
#if defined(USE_SELF_POWER_SENSE_IO)
tris_self_power = INPUT_PIN;
#endif
mInitializeUSBDriver(); // See usbdrv.h
UserInit(); // See user.c & .h
}//end InitializeSystem
void
Agent::Init()
{
mMib->add(new sysGroup( "Smart-SNMPd, Agent++ based snmpd version " SMART_SNMP_VERSION_STRING,
SM_SMART_SNMPD_MIB "." SMART_SNMP_VERSION_STRING, 10 ) );
mMib->add(new snmpGroup());
mMib->add(new snmp_target_mib());
mMib->add(new snmp_notification_mib());
for( vector<MibModule *>::size_type i = 0; i < mMibModules.size(); ++i )
{
MibModule *modInfo = mMibModules[i];
if( !modInfo->RegisterMibs( *mMib ) )
{
LOG_BEGIN(loggerModuleName, ERROR_LOG | 1);
LOG("Agent::~Agent(): mibs module registering failed at (index)");
LOG(i);
LOG_END;
}
}
UserInit();
#ifdef AGENTPP_USE_THREAD_POOL
int numberOfJobThreads = Config::getInstance().getNumberOfJobThreads();
if( numberOfJobThreads > 0 )
{
QueuedThreadPool *tp = new QueuedThreadPool(numberOfJobThreads);
mMib->set_thread_pool(tp);
tp->start();
}
#endif
mMib->init();
#ifdef AGENTPP_USE_THREAD_POOL
if( numberOfJobThreads <= 0 )
{
mMib->delete_thread_pool();
}
#endif
mReqList->set_snmp(mSnmp);
VacmInit();
}
/**
* 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.
*
*/
static void InitializeSystem(void)
{
ADCON1 |= 0x0F; // Default all pins to digital
/////////////////////////////////////////////////
//Setup timer2 as a 1ms timer
/*
//Prescaler of 16 at 48MHz = 48,000,000 / 16 = 3,000,000 hz
//Postcaler of 12 at 48MHz = 3,000,000 / 12 = 250,000
//Set PR2 = 249. This causes timer to reset when it reaches 249 = 250,000 / 250 = 1000hz = 1ms
T2CON = 0x5e; //xxxx xx10 - Prescaler = 16
//xxxx x1xx - Tmr2 on
//x101 1xxx - Postscaler = 11 (0=1, 1=2 ... 11=12)
PR2 = 249;
*/
//Prescaler of 4 at 12MHz = 12,000,000 / 16 = 3,000,000 hz
//Postcaler of 12 at 12MHz = 3,000,000 / 12 = 250,000
//Set PR2 = 249. This causes timer to reset when it reaches 249 = 250,000 / 250 = 1000hz = 1ms
T2CON = 0x5d; //xxxx xx01 - Prescaler = 4
//xxxx x1xx - Tmr2 on
//x101 1xxx - Postscaler = 11 (0=1, 1=2 ... 11=12)
//PR2 = 249;
PR2 = 249;
PIE1bits.TMR2IE = 1; //Enable Timer2 interrupt
/////////////////////////////////////////////////
//USB stack defines
#if defined(USE_USB_BUS_SENSE_IO)
tris_usb_bus_sense = INPUT_PIN; // See io_cfg.h
#endif
#if defined(USE_SELF_POWER_SENSE_IO)
tris_self_power = INPUT_PIN;
#endif
mInitializeUSBDriver(); // See usbdrv.h
UserInit(); // See user.c & .h
/////////////////////////////////////////////////
//Global interrupt enable
INTCONbits.PEIE = 1; //Enable Peripheral interrups (TMR2, ....)
INTCONbits.GIE = 1; //Global interrupt enable
}
/********************************************************************
* 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)
{
#if defined(_PIC14E)
ANSELA = 0x00;
ANSELB = 0x00;
ANSELC = 0x00;
TRISA = 0x00;
TRISB = 0x00;
TRISC = 0x00;
OSCTUNE = 0;
#if defined (USE_INTERNAL_OSC)
OSCCON = 0x7C; // PLL enabled, 3x, 16MHz internal osc, SCS external
OSCCONbits.SPLLMULT = 1; // 1=3x, 0=4x
ACTCON = 0x90; // Clock recovery on, Clock Recovery enabled; SOF packet
#else
OSCCON = 0x3C; // PLL enabled, 3x, 16MHz internal osc, SCS external
OSCCONbits.SPLLMULT = 0; // 1=3x, 0=4x
ACTCON = 0x00; // Clock recovery off, Clock Recovery enabled; SOF packet
#endif
#endif
#if (defined(__18CXX) & !defined(PIC18F87J50_PIM) & !defined(PIC18F97J94_FAMILY))
ADCON1 |= 0x0F; // Default all pins to digital
#endif
// Make sure that the device does not source current to host.
#if defined(USE_USB_BUS_SENSE_IO)
tris_usb_bus_sense = INPUT_PIN; // See HardwareProfile.h
#endif
#if defined(USE_SELF_POWER_SENSE_IO)
tris_self_power = INPUT_PIN; // See HardwareProfile.h
#endif
USBGenericOutHandle = 0;
USBGenericInHandle = 0;
UserInit(); //Application related initialization.
USBDeviceInit(); //usb_device.c. Initializes USB module SFRs and firmware
//variables to known states.
}//end InitializeSystem
static void InitializeSystem(void) {
ADCON1 |= 0x0F; // Default all pins to digital
{
unsigned int pll_startup_counter = 600;
OSCTUNEbits.PLLEN = 1; //Enable the PLL and wait 2+ms until the PLL locks before enabling USB module
while (pll_startup_counter--);
}
ANCON0 = 0xFF; // Default all pins to digital
ANCON1 = 0xFF; // Default all pins to digital
// Configura PORTC<0> como salida de test
TRISCbits.TRISC0 = 0;
// COnfigura PORTB<4> como entrada para el conector USB
TRISBbits.TRISB4 = 1;
UserInit();
USBDeviceInit(); //usb_device.c. Initializes USB module SFRs and firmware
//variables to known states.
}//end InitializeSystem
/*!
* @brief
* The main function of the project.
* @param
* void
* @return
* int
*/
int main(void)
/*lint -restore Enable MISRA rule (6.3) checking. */
{
/* Write your local variable definition here */
/*** Processor Expert internal initialization. DON'T REMOVE THIS CODE!!! ***/
PE_low_level_init();
/*** End of Processor Expert internal initialization. ***/
/* Write your code here */
/* For example: for(;;) { } */
(void)TestApp_Init(); /* Initialize the USB Test Application */
/* Initialize on-chip and peripheral devices */
#if DEBUG
GPIOTest();
printf("+UserInit begins...\n");
#endif
UserInit();
#if DEBUG
printf("-UserInit finished.\n");
#endif
#if DEBUG
GPIOTest();
#endif
Init_State = 200;//Init is OK
/* The main loop */
MainLoop();
/*** Don't write any code pass this line, or it will be deleted during code generation. ***/
/*** RTOS startup code. Macro PEX_RTOS_START is defined by the RTOS component. DON'T MODIFY THIS CODE!!! ***/
#ifdef PEX_RTOS_START
PEX_RTOS_START(); /* Startup of the selected RTOS. Macro is defined by the RTOS component. */
#endif
/*** End of RTOS startup code. ***/
/*** Processor Expert end of main routine. DON'T MODIFY THIS CODE!!! ***/
for(;;){}
/*** Processor Expert end of main routine. DON'T WRITE CODE BELOW!!! ***/
} /*** End of main routine. DO NOT MODIFY THIS TEXT!!! ***/
static void InitializeSystem(void)
{
// all pins digital mode, except RC2, which has a Thermistor on it
ANSELA = 0x00;
ANSELB = 0x00;
ANSELC = 0x04;
#if defined (USE_INTERNAL_OSC)
OSCTUNE = 0;
OSCCON = 0xFC; //16MHz HFINTOSC with 3x PLL enabled (48MHz operation)
ACTCON = 0x90; //Enable active clock tuning with USB
#endif
USBGenericOutHandle = 0;
USBGenericInHandle = 0;
WQI = WQX = 0;
UserInit();
USBDeviceInit(); //usb_device.c. Initializes USB module SFRs and firmware
//variables to known states.
}//end InitializeSystem
// **************************************************
int main (int argc, char** argv) {
srand(iRandomSeed);
glutInit(&argc,argv);
glutInitWindowPosition(100,100);
glutInitWindowSize(iScreenWidth,iScreenHeight);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
int win = glutCreateWindow("Project 4 - Raytracer");
glutSetWindow(win);
glutKeyboardFunc(keyFunc);
glutDisplayFunc(display);
SetupMenu();
UserInit();
glutMainLoop();
UserCleanup();
return 0;
}
//#define analogTime 10
// RunEveryData asyncSched = {0,analogTime};
void runDyIOMain(void) {
UCSR1B=0;
UCSR1C=0;
UCSR1A=0;
//
// UCSR0B=0;
// UCSR0C=0;
// UCSR0A=0;
startScheduler();
AVR_Bowler_HAL_Init();
Bowler_Init();// Com Stack Init. Sets up timeout timer, uart 0 and if debug enabled, uart 1
UserInit();// User code init
setPrintLevelWarningPrint();
// GetIOChannelCountFromPacket(&Packet);
// FixPacket(&Packet);
// printPacket(&Packet,WARN_PRINT);
while (1) {
//Run from Interrupts only
Server();
}
}
void CGame::Start(char *APP_NAME,Uint16 _flags) {
flags=_flags;
G_QUIT=false;
Log=0;
GFX=0;
SND=0;
Log=new CLog(va("%s.log",APP_NAME));
Log->AddEntry("------------------------------------------------------");
Log->AddEntry(va("%s! Started...",APP_NAME));
if(flags&G_SDL) {
GFX = new CSDL_Wrap(APP_NAME,screen_width,screen_height,screen_colors, flags, "gfx/icon.bmp");
if(!GFX) ShutDown();
if(!GFX->InitSuccess) {
Log->AddEntry("GFX Subsystem Init FAILURE!");
ShutDown();
return;
}
}
Log->AddEntry("GFX Subsystem Initialized...");
if(flags&G_FMOD) {
SND = new CFMOD();
Log->AddEntry("SND Subsystem Initialized...");
}
srand(time(NULL));
UserInit();
Log->AddEntry("UserInit() Completed...");
}
static void InitializeSystem( void )
{
UserInit();
USBDeviceInit();
}
/********************************************************************
* 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)
{
ADCON1 |= 0x0F; // Default all pins to digital
// Configure global interrupts
RCONbits.IPEN = 1; // Enable interrupt priority discrimination
INTCONbits.GIEH = 1; // Globally enable high-priority interrupts
INTCONbits.GIEL = 1; // Globally enable low-priority interrupts
IPR2bits.USBIP = 1; // USB interrupt events are high priority
// Configure and enable Timer2 @ 100 kHz... see PIC18F14k50 docs for details
IPR1bits.TMR2IP = 0; // Select low-priority interrupts
T2CON = 0; // 1:1 postscale, prescale = 1, timer disabled
PIE1bits.TMR2IE = 1; // Generate interrupts
PR2 = 120 - 1; // Timer2 period = 120; FOSC/4 * 120 = 10us
PIR1bits.TMR2IF = 0; // Clear interrupt flag
// 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.
T2CONbits.TMR2ON = 1; // Timer2 enable
}//end InitializeSystem
/********************************************************************
* 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)
{
#if (defined(__18CXX) & !defined(PIC18F87J50_PIM))
ADCON1 |= 0x0F; // Default all pins to digital
#elif defined(__C30__)
#if defined(__PIC24FJ256DA210__) || defined(__PIC24FJ256GB210__)
ANSA = 0x0000;
ANSB = 0x0000;
ANSC = 0x0000;
ANSD = 0x0000;
ANSE = 0x0000;
ANSF = 0x0000;
ANSG = 0x0000;
#elif defined(__dsPIC33EP512MU810__)
ANSELA = 0x0000;
ANSELB = 0x0000;
ANSELC = 0x0000;
ANSELD = 0x0000;
ANSELE = 0x0000;
ANSELG = 0x0000;
// The dsPIC33EP512MU810 features Peripheral Pin
// select. The following statements map UART2 to
// device pins which would connect to the the
// RX232 transciever on the Explorer 16 board.
RPINR19 = 0;
RPINR19 = 0x64;
RPOR9bits.RP101R = 0x3;
#else
AD1PCFGL = 0xFFFF;
#endif
#elif defined(__C32__)
AD1PCFG = 0xFFFF;
#endif
#if defined(PIC18F87J50_PIM) || defined(PIC18F46J50_PIM) || defined(PIC18F_STARTER_KIT_1) || defined(PIC18F47J53_PIM)
//On the PIC18F87J50 Family of USB microcontrollers, the PLL will not power up and be enabled
//by default, even if a PLL enabled oscillator configuration is selected (such as HS+PLL).
//This allows the device to power up at a lower initial operating frequency, which can be
//advantageous when powered from a source which is not gauranteed to be adequate for 48MHz
//operation. On these devices, user firmware needs to manually set the OSCTUNE<PLLEN> bit to
//power up the PLL.
{
unsigned int pll_startup_counter = 600;
OSCTUNEbits.PLLEN = 1; //Enable the PLL and wait 2+ms until the PLL locks before enabling USB module
while(pll_startup_counter--);
}
//Device switches over automatically to PLL output after PLL is locked and ready.
#endif
#if defined(PIC18F87J50_PIM)
//Configure all I/O pins to use digital input buffers. The PIC18F87J50 Family devices
//use the ANCONx registers to control this, which is different from other devices which
//use the ADCON1 register for this purpose.
WDTCONbits.ADSHR = 1; // Select alternate SFR location to access ANCONx registers
ANCON0 = 0xFF; // Default all pins to digital
ANCON1 = 0xFF; // Default all pins to digital
WDTCONbits.ADSHR = 0; // Select normal SFR locations
#endif
#if defined(DSPIC33EP512MU810_PIM)
// Configure the device PLL to obtain 60 MIPS operation. The crystal
// frequency is 8MHz. Divide 8MHz by 2, multiply by 60 and divide by
// 2. This results in Fosc of 120MHz. The CPU clock frequency is
// Fcy = Fosc/2 = 60MHz. Wait for the Primary PLL to lock and then
// configure the auxilliary PLL to provide 48MHz needed for USB
// Operation.
PLLFBD = 58; /* M = 60 */
CLKDIVbits.PLLPOST = 0; /* N1 = 2 */
CLKDIVbits.PLLPRE = 0; /* N2 = 2 */
OSCTUN = 0;
/* Initiate Clock Switch to Primary
* Oscillator with PLL (NOSC= 0x3)*/
__builtin_write_OSCCONH(0x03);
__builtin_write_OSCCONL(0x01);
while (OSCCONbits.COSC != 0x3);
// Configuring the auxiliary PLL, since the primary
// oscillator provides the source clock to the auxiliary
// PLL, the auxiliary oscillator is disabled. Note that
// the AUX PLL is enabled. The input 8MHz clock is divided
// by 2, multiplied by 24 and then divided by 2. Wait till
// the AUX PLL locks.
ACLKCON3 = 0x24C1;
ACLKDIV3 = 0x7;
ACLKCON3bits.ENAPLL = 1;
while(ACLKCON3bits.APLLCK != 1);
#endif
#if defined(PIC18F46J50_PIM) || defined(PIC18F_STARTER_KIT_1) || defined(PIC18F47J53_PIM)
//Configure all I/O pins to use digital input buffers. The PIC18F87J50 Family devices
//use the ANCONx registers to control this, which is different from other devices which
//use the ADCON1 register for this purpose.
ANCON0 = 0xFF; // Default all pins to digital
ANCON1 = 0xFF; // Default all pins to digital
#endif
#if defined(PIC24FJ64GB004_PIM) || defined(PIC24FJ256DA210_DEV_BOARD)
//On the PIC24FJ64GB004 Family of USB microcontrollers, the PLL will not power up and be enabled
//by default, even if a PLL enabled oscillator configuration is selected (such as HS+PLL).
//This allows the device to power up at a lower initial operating frequency, which can be
//advantageous when powered from a source which is not gauranteed to be adequate for 32MHz
//operation. On these devices, user firmware needs to manually set the CLKDIV<PLLEN> bit to
//power up the PLL.
{
unsigned int pll_startup_counter = 600;
CLKDIVbits.PLLEN = 1;
while(pll_startup_counter--);
}
//Device switches over automatically to PLL output after PLL is locked and ready.
#endif
// 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.
}//end InitializeSystem
/******************************************************************************
* 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)
{
OSCCON = 0x60; //Clock switch to primary clock source. May not have been running
//from this if the bootloader is called from the application firmware.
//On the PIC18F87J50 Family of USB microcontrollers, the PLL will not power up and be enabled
//by default, even if a PLL enabled oscillator configuration is selected (such as HS+PLL).
//This allows the device to power up at a lower initial operating frequency, which can be
//advantageous when powered from a source which is not gauranteed to be adequate for 48MHz
//operation. On these devices, user firmware needs to manually set the OSCTUNE<PLLEN> bit to
//power up the PLL.
#if defined(__18F87J50)||defined(__18F86J55)|| \
defined(__18F86J50)||defined(__18F85J50)|| \
defined(__18F67J50)||defined(__18F66J55)|| \
defined(__18F66J50)||defined(__18F65J50)
OSCTUNEbits.PLLEN = 1; //Enable the PLL and wait 2+ms until the PLL locks before enabling USB module
pll_startup_counter = 600;
while(pll_startup_counter--)
{
ClrWdt();
}
//Device switches over automatically to PLL output after PLL is locked and ready.
#else
#error Double Click this message. Please make sure the InitializeSystem() function correctly configures your hardware platform.
//Also make sure the correct board is selected in usbcfg.h. If
//everything is correct, comment out the above "#error ..." line
//to suppress the error message.
#endif
//USB module may have already been on if the application firmware calls the bootloader
//without first disabling the USB module. If this happens, need
//to temporarily soft-detach from the host, wait a delay (allows cable capacitance
//to discharge, and to allow host software to recognize detach), then
//re-enable the USB module, so the host knows to re-enumerate the
//USB device.
if(UCONbits.USBEN == 1)
{
UCONbits.SUSPND = 0;
UCON = 0;
LongDelay();
}
// 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
// usbcfg.h file.
#if defined(USE_USB_BUS_SENSE_IO)
tris_usb_bus_sense = INPUT_PIN; // See io_cfg.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 usbcfg.h, and that an appropriate I/O pin has been mapped
// to it in io_cfg.h.
#if defined(USE_SELF_POWER_SENSE_IO)
tris_self_power = INPUT_PIN;
#endif
mInitializeUSBDriver(); // See usbdrv.h
UserInit(); // See user.c & .h
led_count = 0; //Initialize variable used to toggle LEDs
mInitAllLEDs(); //Init them off.
//Turn off digital input buffers on analog pins to minimize power consumption
//if the I/O pins happen to be floating in the target application.
WDTCONbits.ADSHR = 1; //ANCON registers in shared address space region
ANCON0 = 0x00; //All analog, to disable the digital input buffers
ANCON1 = 0x00; //All analog, digital input buffers off
WDTCONbits.ADSHR = 0;
//Also to minimize sleep current consumption (sleep used in this bootloader
//firmware during USB Suspend conditions), use REGSLP feature
WDTCONbits.REGSLP = 1;
}//end InitializeSystem
/******************************************************************************
* 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
*****************************************************************************/
void InitializeSystem(void)
{
//Initialize oscillator settings compatible with USB operation. Note,
//these may be application specific!
#if defined(PIC18F4550_PICDEM_FS_USB_K50)
OSCTUNE = 0x80; //3X PLL ratio mode selected
OSCCON = 0x70; //Switch to 16MHz HFINTOSC
OSCCON2 = 0x10; //Enable PLL, SOSC, PRI OSC drivers turned off
while(OSCCON2bits.PLLRDY != 1); //Wait for PLL lock
ACTCON = 0x90; //Enable active clock tuning for USB operation
#endif
//The USB specifications require that USB peripheral devices must never source
//current onto the +5V 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 - note weak pull down, ex: 100k,
//should also be placed on the PCB on VBUS to ensure low/non-floating reading).
//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
//usb_config.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, and it can consume >100mA from VBUS, 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. If using this feature, make sure "USE_SELF_POWER_SENSE_IO"
//has been defined in usb_config.h, and that an appropriate I/O pin has been mapped
//to it in HardwareProfile.h. This feature is optionional and is not required
//to be implemented on bus powered only or self/bus powered device that never
//take more than 100mA from VBUS.
#if defined(USE_SELF_POWER_SENSE_IO)
tris_self_power = INPUT_PIN;
#endif
UserInit(); //Initialize bootloader application variables (see Bootxxxx.c file)
#if defined(ENABLE_USB_LED_BLINK_STATUS)
mLED1 = 0; //LED off initially
mLED1Tris = 0; //Configure pin as output
#endif
//Initialize USB module only after oscillator and other settings are compatible with USB operation
USBDeviceInit(); //Initializes USB module SFRs and firmware
//variables to known states.
}//end InitializeSystem
/******************************************************************************
* 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)
{
OSCCON = 0x60; //Clock switch to primary clock source. May not have been running
//from this if the bootloader is called from the application firmware.
//On the PIC18F46J50 Family of USB microcontrollers, the PLL will not power up and be enabled
//by default, even if a PLL enabled oscillator configuration is selected (such as HS+PLL).
//This allows the device to power up at a lower initial operating frequency, which can be
//advantageous when powered from a source which is not gauranteed to be adequate for 48MHz
//operation. On these devices, user firmware needs to manually set the OSCTUNE<PLLEN> bit to
//power up the PLL.
#if defined(__18F24J50)||defined(__18F25J50)|| \
defined(__18F26J50)||defined(__18F44J50)|| \
defined(__18F45J50)||defined(__18F46J50)|| \
defined(__18LF24J50)||defined(__18LF44J50)|| \
defined(__18LF25J50)||defined(__18LF45J50)|| \
defined(__18LF26J50)||defined(__18LF46J50)
OSCTUNEbits.PLLEN = 1; //Enable the PLL and wait 2+ms until the PLL locks before enabling USB module
uint_delay_counter = 600;
while(uint_delay_counter--);
//Device switches over automatically to PLL output after PLL is locked and ready.
#else
#error Double Click this message. Please make sure the InitializeSystem() function correctly configures your hardware platform.
//Also make sure the correct board is selected in usbcfg.h. If
//everything is correct, comment out the above "#error ..." line
//to suppress the error message.
#endif
// 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
// usbcfg.h file.
#if defined(USE_USB_BUS_SENSE_IO)
tris_usb_bus_sense = INPUT_PIN; // See io_cfg.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 usbcfg.h, and that an appropriate I/O pin has been mapped
// to it in io_cfg.h.
#if defined(USE_SELF_POWER_SENSE_IO)
tris_self_power = INPUT_PIN;
#endif
mInitializeUSBDriver(); // See usbdrv.h
UserInit(); // See BootPIC[xxxx].c. Initializes the bootloader firmware state machine variables.
mInitAllLEDs(); //Init them off.
//Initialize I/O pins for "lowest" power. When in USB suspend mode, total +5V VBUS current consumption
//should reduce to <2.5mA in order to meet USB compliance specifications.
//Ordinarily, to initialize I/O pins for lowest power, any unused I/O pins would be configured
//as outputs and driven either high or low. However, if this code is left unmodified, but is used in a real
//application, I/O pins as outputs could cause contention with externally connected signals. Therefore
//this code does not actually drive unused I/Os as outputs, but uses "softer" methods, like making
//analog capable pins as analog (to disable the digital input buffer, which wastes power when left floating)
//This code should be replaced with code more specific to the intended target application I/O pin usage.
//The below code by itself will not achieve the lowest possible power consumption.
ANCON0 = 0x00; //All analog, to disable the digital input buffers
ANCON1 = 0x00; //All analog, digital input buffers off, bandgap off
}//end InitializeSystem
/********************************************************************
* 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)
{
//ADCON1 |= 0x0F; // Default all pins to digital
//On the PIC18F87J50 Family of USB microcontrollers, the PLL will not power up and be enabled
//by default, even if a PLL enabled oscillator configuration is selected (such as HS+PLL).
//This allows the device to power up at a lower initial operating frequency, which can be
//advantageous when powered from a source which is not gauranteed to be adequate for 48MHz
//operation. On these devices, user firmware needs to manually set the OSCTUNE<PLLEN> bit to
//power up the PLL.
{
unsigned int pll_startup_counter = 600;
OSCTUNEbits.PLLEN = 1; //Enable the PLL and wait 2+ms until the PLL locks before enabling USB module
while(pll_startup_counter--);
}
//Device switches over automatically to PLL output after PLL is locked and ready.
//Configure all I/O pins to use digital input buffers. The PIC18F87J50 Family devices
//use the ANCONx registers to control this, which is different from other devices which
//use the ADCON1 register for this purpose.
ANCON0 = 0xFF; // Default all pins to digital
ANCON1 = 0xFF; // Default all pins to digital
// 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();
}//end InitializeSystem
/******************************************************************************
* 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)
{
#if defined(PIC18F97J94_FS_USB_PIM) || defined(PIC18F87J94_FS_USB_PIM)
//Make sure to select oscillator settings consistent with USB operation.
//If the user application firmware entered the bootloader through the absolute
//entry point, it is possible the clock source may not have already been compatible
//with USB operation. In this case we need to switch as appropriate.
OSCCON2bits.CLKLOCK = 0; //Deassert clock setting lock
OSCCON3 = 0x01; //FRC/2 setting (4MHz)
OSCCON4 = 0x00; //1:1
OSCCON = 0x01; //FRC+PLL selected
//Enable INTOSC active clock tuning if full speed
ACTCON = 0x90; //Enable active clock self tuning for USB operation
while(OSCCON2bits.LOCK == 0) //Make sure PLL is locked/frequency is compatible
{
ClrWdt();
}
#else
#error Double Click this message. Please make sure the InitializeSystem() function correctly configures your hardware platform.
//Also make sure the correct board is selected in usbcfg.h. If
//everything is correct, comment out the above "#error ..." line
//to suppress the error message.
#endif
//USB module may have already been on if the application firmware calls the bootloader
//without first disabling the USB module. If this happens, need
//to temporarily soft-detach from the host, wait a delay (allows cable capacitance
//to discharge, and to allow host software to recognize detach), then
//re-enable the USB module, so the host knows to re-enumerate the
//USB device.
if(UCONbits.USBEN == 1)
{
UCONbits.SUSPND = 0;
UCON = 0;
LongDelay();
}
// 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
// usbcfg.h file.
#if defined(USE_USB_BUS_SENSE_IO)
tris_usb_bus_sense = INPUT_PIN; // See io_cfg.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 usbcfg.h, and that an appropriate I/O pin has been mapped
// to it in io_cfg.h.
#if defined(USE_SELF_POWER_SENSE_IO)
tris_self_power = INPUT_PIN;
#endif
mInitializeUSBDriver(); // See usbdrv.h
UserInit(); // See user.c & .h
led_count = 0; //Initialize variable used to toggle LEDs
mInitAllLEDs(); //Init them off.
//Turn off digital input buffers on analog pins to minimize power consumption
//if the I/O pins happen to be floating in the target application.
ANCON1 = 0xFF; //All analog, digital input buffers off
ANCON2 = 0xFF; //All analog, digital input buffers off
ANCON3 = 0xFF; //All analog, digital input buffers off
}//end InitializeSystem
