int main(void) { InitializeSystem(); // Wait for reset button to be released while (_PORT(PIO_BTN1) == HIGH) { } //ADCInitialize(); PWMInitialize(); PWMEnable(); USBDeviceInit(); //ADCStartCapture(); _LAT(PIO_LED1) = HIGH; ColourEngine::Initialize(); //ColourEngine::PowerOn(1000); // Fade in ColourEngine::SetPower(power, 0); //_LAT(PIO_LED2) = HIGH; while (1) { USBDeviceTasks(); USBUserProcess(); } return 0; }
void prepareUSB(void) { USBDeviceInit(); //usb_device.c. Initializes USB module SFRs and firmware //variables to known states. USBDeviceAttach(); // Activate USB Interruptions }
/******************************************************************** * 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
int main(void){ unsigned long timer; #define longDelay(x) timer=x; while(timer--) CLKDIV = 0x0000; // Set PLL prescaler (1:1) init(); //setup the crystal, pins, hold the FPGA in reset usbbufflush(); //setup the USB byte buffer USBDeviceInit();//setup usb while(1){ USBDeviceTasks(); if((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1)) continue; usbbufservice();//load any USB data into byte buffer //send data from the FPGA receive buffer to USB //if((mUSBUSARTIsTxTrfReady()) && (uartincnt > 0)){ // putUSBUSART(&buf[0], uartincnt); //} CDCTxService(); }//end while }//end main
/******************************************************************** * Function: void main(void) * * PreCondition: None * * Input: None * * Output: None * * Side Effects: None * * Overview: Main program entry point. * * Note: None *******************************************************************/ MAIN_RETURN main(void) { SYSTEM_Initialize(SYSTEM_STATE_USB_START); USBDeviceInit(); USBDeviceAttach(); setup(); while(1) { SYSTEM_Tasks(); #if defined(USB_POLLING) // Interrupt or polling method. If using polling, must call // this function periodically. This function will take care // of processing and responding to SETUP transactions // (such as during the enumeration process when you first // plug in). USB hosts require that USB devices should accept // and process SETUP packets in a timely fashion. Therefore, // when using polling, this function should be called // regularly (such as once every 1.8ms or faster** [see // inline code comments in usb_device.c for explanation when // "or faster" applies]) In most cases, the USBDeviceTasks() // function does not take very long to execute (ex: <100 // instruction cycles) before it returns. USBDeviceTasks(); #endif //Application specific tasks APP_DeviceCDCBasicDemoTasks(); }//end while }//end main
/******************************************************************** * 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 USBInit(void) { USBGenericOutHandle = 0; USBGenericInHandle = 0; USBDeviceInit(); //usb_device.c. Initializes USB module SFRs and firmware //variables to known states. }//end InitializeSystem
// *--------------------------------------------------------------------------------* 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(); } }
/* App initialisation * init ADC * init timer 1 * init interrupts */ void InitApp(void) { cur_State = LIPO_ALGO_STARTED; strncpy(battery.battery_type,"LIPO\0",5); battery.charge.restore_Lowest_Voltage = 5; battery.number_of_cells = 1; battery.charge.restore_Charge_Current = 0.5; seconds = 0; OpenADC( ADC_FOSC_64 & ADC_RIGHT_JUST & ADC_6_TAD, ADC_CH0 & ADC_INT_OFF & ADC_REF_VDD_VSS, ADC_1ANA ); /* open timers */ OpenTimer1( TIMER_INT_ON & T1_8BIT_RW & T1_SOURCE_EXT & T1_PS_1_1 & T1_OSC1EN_ON & T1_SYNC_EXT_OFF ); //ei(); USBDeviceInit(); //usb_device.c #if defined(USB_INTERRUPT) USBDeviceAttach(); //usb_device.c #endif /* TODO init PI structure */ PI.Ki = 2; PI.Kp = 35; /* TODO init analog port */ }
/******************************************************************** * 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
/* * Main program entry point. */ int main (void) { AD1PCFG = 0xFFFF; //Initialize all of the LED pins LATE |= 0x000F; TRISE &= 0xFFF0; USBDeviceInit(); //usb_device.c. Initializes USB module SFRs and firmware //variables to known states. PMCON = 0; for (;;) { // Check bus status and service USB interrupts. USBDeviceTasks(); // Interrupt or polling method. If using polling, must call // this function periodically. This function will take care // of processing and responding to SETUP transactions // (such as during the enumeration process when you first // plug in). USB hosts require that USB devices should accept // and process SETUP packets in a timely fashion. Therefore, // when using polling, this function should be called // frequently (such as once about every 100 microseconds) at any // time that a SETUP packet might reasonably be expected to // be sent by the host to your device. In most cases, the // USBDeviceTasks() function does not take very long to // execute (~50 instruction cycles) before it returns. // Application-specific tasks. // Blink the LEDs according to the USB device status BlinkUSBStatus(); // User Application USB tasks if (USBDeviceState >= CONFIGURED_STATE && ! (U1PWRC & PIC32_U1PWRC_USUSPEND)) { unsigned nbytes_read; static unsigned char inbuf[64], outbuf[64]; static unsigned led3_count = 0; // Pull in some new data if there is new data to pull in nbytes_read = getsUSBUSART ((char*) inbuf, 64); if (nbytes_read != 0) { snprintf (outbuf, sizeof(outbuf), "Received %d bytes: %02x...\r\n", nbytes_read, inbuf[0]); putUSBUSART ((char*) outbuf, strlen (outbuf)); mLED_2_Toggle(); mLED_3_On(); led3_count = 10000; } if (led3_count) { // Turn off LED3 when timeout expired. led3_count--; if (led3_count == 0) mLED_3_Off(); } CDCTxService(); } } }
int32_t main(void) { DDPCONbits.JTAGEN = 0; // Disable the JTAG programming port /* SYS_CFG_WAIT_STATES (configures flash wait states from system clock) SYS_CFG_PB_BUS (configures the PB bus from the system clock) SYS_CFG_PCACHE (configures the pCache if used) SYS_CFG_ALL (configures the flash wait states, PB bus, and pCache)*/ /* TODO Add user clock/system configuration code if appropriate. */ SYSTEMConfig(SYS_FREQ, SYS_CFG_ALL); /*Configure Multivector Interrupt Mode. Using Single Vector Mode is expensive from a timing perspective, so most applications should probably not use a Single Vector Mode*/ INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR); /* TODO <INSERT USER APPLICATION CODE HERE> */ // initialise the IO pins and PWM outputs TRISD = 0; pickerBusTRIS = 0x00; pickerBus = 0x00; OpenOC1( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0); // vibration motor OpenOC2( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0); // head led OpenOC3( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0); // base led OpenTimer2( T2_ON | T2_PS_1_4 | T2_SOURCE_INT, 1024); SetDCOC1PWM(0); SetDCOC2PWM(0); SetDCOC3PWM(0); setVac1off; setVac2off; USBOutHandle = 0; USBInHandle = 0; USBDeviceInit(); //usb_device.c. Initializes USB module SFRs and firmware USBDeviceAttach(); init_component_picker(); /*while(1) { LATBbits.LATB0 = feederXHome; LATBbits.LATB1 = feederZHome; //ProcessIO(); }*/ }
MAIN_RETURN main(void) { SYSTEM_Initialize(SYSTEM_STATE_USB_START); USBDeviceInit(); USBDeviceAttach(); IPR1 = 0; //All others interrupt sources will be Low priority IPR2 = 32; //USB interrupt is High priority RCONbits.IPEN = 1; //Enabling interrupt priority ADCON1bits.PCFG = 0x0F; //By default all I/O digital CMCONbits.CM = 7; //Comparators off by default while(1) { SYSTEM_Tasks(); #if defined(USB_POLLING) // Interrupt or polling method. If using polling, must call // this function periodically. This function will take care // of processing and responding to SETUP transactions // (such as during the enumeration process when you first // plug in). USB hosts require that USB devices should accept // and process SETUP packets in a timely fashion. Therefore, // when using polling, this function should be called // regularly (such as once every 1.8ms or faster** [see // inline code comments in usb_device.c for explanation when // "or faster" applies]) In most cases, the USBDeviceTasks() // function does not take very long to execute (ex: <100 // instruction cycles) before it returns. USBDeviceTasks(); #endif /* If the USB device isn't configured yet, we can't really do anything * else since we don't have a host to talk to. So jump back to the * top of the while loop. */ if( USBGetDeviceState() < CONFIGURED_STATE ) { /* Jump back to the top of the while loop. */ continue; } /* If we are currently suspended, then we need to see if we need to * issue a remote wakeup. In either case, we shouldn't process any * keyboard commands since we aren't currently communicating to the host * thus just continue back to the start of the while loop. */ if( USBIsDeviceSuspended() == true ) { /* Jump back to the top of the while loop. */ continue; } //Application specific tasks APP_DeviceCustomHIDTasks(); }//end while }//end main
void preflight(void) { printf("Initialising USB\r\n"); USBDeviceInit(); //usb_device.c. Initializes USB module SFRs and firmware variables to known states. #if defined(USB_INTERRUPT) USBDeviceAttach(); #endif }
/******************************************************************** * Function: void main(void) *******************************************************************/ MAIN_RETURN main(void) { SYSTEM_Initialize(); USBDeviceInit(); USBDeviceAttach(); while(1) { SYSTEM_Tasks(); #if defined(USB_POLLING) USBDeviceTasks(); #endif /* If the USB device isn't configured yet, we can't really do anything * else since we don't have a host to talk to. So jump back to the * top of the while loop. */ if( USBGetDeviceState() < CONFIGURED_STATE ) { /* Jump back to the top of the while loop. */ continue; } /* If we are currently suspended, then we need to see if we need to * issue a remote wakeup. In either case, we shouldn't process any * keyboard commands since we aren't currently communicating to the host * thus just continue back to the start of the while loop. */ if( USBIsDeviceSuspended() == true ) { /* Jump back to the top of the while loop. */ continue; } // implement nMCLR button if ( BUTTON_IsPressed(BUTTON_S1)) { LUNSoftDetach(0); // mark the media as temporarily unavailable ICSP_nMCLR = SLAVE_RESET; LED_Off(GREEN_LED); // turn off RED LED to indicate ready for download LED_On (RED_LED); DIRECT_Initialize(); // reset the programming state machine } else { // simply act as a slave reset LUNSoftAttach(0); // mark the media as available if ( !DIRECT_ProgrammingInProgress()) { // do not release during prog.! ICSP_nMCLR = SLAVE_RUN; LED_On(GREEN_LED); // turn off RED LED to indicate ready for download LED_Off(RED_LED); } } //Application specific tasks APP_DeviceMSDTasks(); APP_DeviceCDCEmulatorTasks(); }//end while }//end main
void usb_tty_init(void){ /* queue para o envio de string pela usb * usada principalmente por: * - printf * - usb_tty_print */ usb_buffer_queue = xQueueCreate(8, sizeof(USB_BUFFER)); USBDeviceInit(); }
void CDC_init() { USBDeviceInit(); // Initializes USB module SFRs and firmware #if defined(__32MX220F032D__)||defined(__32MX250F128B__)||defined(__32MX220F032B__) // nothing to do #else USBDeviceAttach(); #endif Delayms(1500); }
/*************************************************** * Function: void Init(void) * * OverView: All calling related to Initialized functions. * * Note: None ***************************************************/ void Init(void) { InitializeSystem(); // Initialize Related to connect usb port. InitializeUser(); // Initialize for User Variables. InitializeDevice(); // Initialize PICF4550 LED, PWM, ADC Ports USBDeviceInit(); // Initialize USB Module. #if defined(USB_INTERRUPT) USBDeviceAttach(); // Enable to find USB Device #endif }
// Initialise the PIC void initialisePic(void) { // PIC port set up -------------------------------------------------------- // Default all pins to digital ANSEL = 0x00; // Configure ports as inputs (1) or outputs(0) /* TRISA = 0b11111111; TRISB = 0b11111111; TRISC = 0b11111111; #if defined(__18F4550) TRISD = 0b00000000; TRISE = 0b00000000; #endif // Clear all ports PORTA = 0b00000000; PORTB = 0b00000000; PORTC = 0b00000000; #if defined(__18F4550) PORTD = 0b00000000; PORTE = 0b00000000; #endif*/ PORTC = 0x00; LATC = 0x00; TRISC = 0x04; // If you have a VBUS sense pin (for self-powered devices when you // want to detect if the USB host is connected) you have to specify // your input pin in HardwareProfile.h #if defined(USE_USB_BUS_SENSE_IO) tris_usb_bus_sense = INPUT_PIN; #endif // In the case of a device which can be both self-powered and bus-powered // the device must respond correctly to a GetStatus (device) request and // tell the host how it is currently powered. // // To do this you must device a pin which is high when self powered and low // when bus powered and define this in HardwareProfile.h #if defined(USE_SELF_POWER_SENSE_IO) tris_self_power = INPUT_PIN; #endif // Application specific initialisation applicationInit(); // Initialise the USB device USBDeviceInit(); }
/** * InitializeSystem: **/ static void InitializeSystem(void) { #if defined(__18F46J50) /* Enable the PLL and wait 2+ms until the PLL locks * before enabling USB module */ unsigned int pll_startup_counter = 600; OSCTUNEbits.PLLEN = 1; while (pll_startup_counter--); /* default all pins to digital */ ANCON0 = 0xFF; ANCON1 = 0xFF; #elif defined(__18F4550) /* default all pins to digital */ ADCON1 = 0x0F; #endif /* set RA0, RA1 to output (freq scaling), * set RA2, RA3 to output (color select), * set RA5 to input (frequency counter), * (RA6 is "don't care" in OSC2 mode) * set RA7 to input (OSC1, HSPLL in) */ TRISA = 0xf0; /* set RB0 to RB3 to input (h/w revision) others input (unused) */ TRISB = 0xff; /* set RC0 to RC2 to input (unused) */ TRISC = 0xff; /* set RD0 to RD7 to input (unused) */ TRISD = 0xff; /* set RE0, RE1 output (LEDs) others input (unused) */ TRISE = 0x3c; /* set the LED state initially */ PORTE = CH_STATUS_LED_RED; /* only turn on the USB module when the device has power */ #if defined(USE_USB_BUS_SENSE_IO) tris_usb_bus_sense = INPUT_PIN; #endif /* we're self powered */ #if defined(USE_SELF_POWER_SENSE_IO) tris_self_power = INPUT_PIN; #endif /* Initializes USB module SFRs and firmware variables to known states */ USBDeviceInit(); }
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); }
int main(void) #endif { InitializeSystem(); USBDeviceInit(); while(1) { USBDeviceTasks(); ProcessIO(); } }
void __init() { 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 InitializeUSART(); USBInitCDC(); USBDeviceInit(); }
void preflight(void) { printf("Initialising USB\r\n"); USBDeviceInit(); //usb_device.c. Initializes USB module SFRs and firmware variables to known states. #if defined(USB_INTERRUPT) USBDeviceAttach(); #endif delay_ms(100); printf("Preflight setup\r\n"); while (U1OTGSTATbits.VBUSVD) { #if defined(USB_POLLING) // Check bus status and service USB interrupts. USBDeviceTasks(); // Interrupt or polling method. If using polling, must call // this function periodically. This function will take care // of processing and responding to SETUP transactions // (such as during the enumeration process when you first // plug in). USB hosts require that USB devices should accept // and process SETUP packets in a timely fashion. Therefore, // when using polling, this function should be called // regularly (such as once every 1.8ms or faster** [see // inline code comments in usb_device.c for explanation when // "or faster" applies]) In most cases, the USBDeviceTasks() // function does not take very long to execute (ex: <100 // instruction cycles) before it returns. #endif // User Application USB tasks if ((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1)) { // do nothing } else { #if (USE_MSD == 1) MSDTasks(); #endif #if (USE_CDC == 1) CDCTasks(); #endif } #if (CONSOLE_UART != 0) console(); #endif } led_off(LED_RED); led_off(LED_BLUE); led_off(LED_GREEN); led_off(LED_ORANGE); printf("Preflight complete\r\n"); }
/* * Main program entry point. */ int main (void) { /* Unlock CFGCON register. */ SYSKEY = 0; SYSKEY = 0xAA996655; SYSKEY = 0x556699AA; CFGCON &= (1 << 13); // clear IOLOCK /* Disable JTAG ports, to make more pins available. */ CFGCON &= (1 << 3); // clear JTAGEN /* Use all ports as digital. */ ANSELA = 0; ANSELB = 0; ANSELC = 0; // Activate all of the LED pins. LATBSET = MASKB_LED1; TRISBCLR = MASKB_LED1; LATASET = MASKA_LED2; TRISACLR = MASKA_LED2; USBDeviceInit(); //usb_device.c. Initializes USB module SFRs and firmware //variables to known states. PMCON = 0; for (;;) { // Check bus status and service USB interrupts. USBDeviceTasks(); // Interrupt or polling method. If using polling, must call // this function periodically. This function will take care // of processing and responding to SETUP transactions // (such as during the enumeration process when you first // plug in). USB hosts require that USB devices should accept // and process SETUP packets in a timely fashion. Therefore, // when using polling, this function should be called // frequently (such as once about every 100 microseconds) at any // time that a SETUP packet might reasonably be expected to // be sent by the host to your device. In most cases, the // USBDeviceTasks() function does not take very long to // execute (~50 instruction cycles) before it returns. // Application-specific tasks. // Blink the LEDs according to the USB device status blink_status(); // User Application USB tasks if (USBDeviceState >= CONFIGURED_STATE && ! (U1PWRC & PIC32_U1PWRC_USUSPEND)) { send_receive(); } } }
/** * prepare system on boot */ static void InitializeSystem(void) { #if defined(__18CXX) SetupTimer(); INTCONbits.GIEH = 1; #endif InitLED(); LED_Off(); InitReceiver(); ReceiverOff(); USBDeviceInit(); }
// Initialise the PIC static void initialisePic(void) { // PIC port set up -------------------------------------------------------- // Default all pins to digital ADCON1 = 0x0F; // Configure ports as inputs (1) or outputs(0) TRISA = 0b00000000; TRISB = 0b00000000; TRISC = 0b00000000; TRISD = 0b00000000; TRISE = 0b00000000; // Clear all ports PORTA = 0b00000000; PORTB = 0b00000000; PORTC = 0b00000000; PORTD = 0b00000000; PORTE = 0b00000000; // initialise the atmega IC atmegaFeederRunningTRIS = 1; atmegaResetPin = 1; // initialise i2c communication OpenI2C( MASTER, SLEW_OFF); SSPADD = 0x70; // Application specific initialisation applicationInit(); // Initialise the USB device USBDeviceInit(); // Initialise the output pins setVac1off; setVac2off; setVibrationoff; OpenTimer2( TIMER_INT_OFF & T2_PS_1_1); // load pwm values from eeprom led1_duty_cycle = Read_b_eep(baseLED_EEPROM_address); led2_duty_cycle = Read_b_eep(headLED_EEPROM_address); // initialise the stepper driver and start timer 0 at 1 microsecond intervals }
MAIN_RETURN main(void) { gpio_init(); timer_init(); SYSTEM_Initialize(SYSTEM_STATE_USB_START); USBDeviceInit(); USBDeviceAttach(); while (1) { SYSTEM_Tasks(); #if defined(USB_POLLING) USBDeviceTasks(); #endif //APP_DeviceCDCBasicDemoTasks(); serial_update(); } }
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
static void InitializeSystem(void) { ADCON1 |= 0x0F; // TRISCbits.TRISC6=0; // TRISCbits.TRISC7 =0; // LATCbits.LATC6 =0; // LATCbits.LATC7=0; USBDeviceInit(); #if defined(USE_UART) Init_UART(BAUD_RATE); Init_Tran_UART(); Init_Rec_UART(); #endif #if defined(USE_LCD) Init_PORTS(); Init_LCD(); #endif }
void Usb_UserInit( void ) { #ifndef DONT_USE_DEBUG_CONSOLE Debug_PrintConst_Initializing(); Debug_PrintRom_( "USB" ); Debug_PrintConst_Dots(); #endif // Reset variables usb_outHandle = 0; usb_inHandle = 0; // Initialize USB module USBDeviceInit(); #ifndef DONT_USE_DEBUG_CONSOLE Debug_PrintConst_Ok(); Debug_PrintConst_NewLine(); #endif }