Subversion Repositories svnkaklik

CCS PCH C Compiler, Version 4.090, 47914               15-V-10 23:31

               Filename: D:\svnKaklik\programy\C\PIC_C\mereni\inertial\main.lst

               ROM used: 9690 bytes (30%)

                         Largest free fragment is 23074

               RAM used: 1650 (81%) at main() level

                         1869 (91%) worst case

               Stack:    17 worst case (8 in main + 9 for interrupts)

*

0000:  GOTO   1F62

*

0008:  MOVWF  05

000A:  MOVFF  FD8,06

000E:  MOVFF  FE0,07

0012:  MOVLB  0

0014:  MOVFF  FE9,0D

0018:  MOVFF  FEA,08

001C:  MOVFF  FE1,09

0020:  MOVFF  FE2,0A

0024:  MOVFF  FD9,0B

0028:  MOVFF  FDA,0C

002C:  MOVFF  FF3,14

0030:  MOVFF  FF4,15

0034:  MOVFF  FFA,16

0038:  MOVFF  00,0F

003C:  MOVFF  01,10

0040:  MOVFF  02,11

0044:  MOVFF  03,12

0048:  MOVFF  04,13

004C:  BTFSS  FF2.5

004E:  GOTO   0058

0052:  BTFSC  FF2.2

0054:  GOTO   025E

0058:  BTFSS  FA0.5

005A:  GOTO   0064

005E:  BTFSC  FA1.5

0060:  GOTO   1274

0064:  MOVFF  0F,00

0068:  MOVFF  10,01

006C:  MOVFF  11,02

0070:  MOVFF  12,03

0074:  MOVFF  13,04

0078:  MOVFF  0D,FE9

007C:  MOVFF  08,FEA

0080:  BSF    08.7

0082:  MOVFF  09,FE1

0086:  MOVFF  0A,FE2

008A:  MOVFF  0B,FD9

008E:  MOVFF  0C,FDA

0092:  MOVFF  14,FF3

0096:  MOVFF  15,FF4

009A:  MOVFF  16,FFA

009E:  MOVF   05,W

00A0:  MOVFF  07,FE0

00A4:  MOVFF  06,FD8

00A8:  RETFIE 0

.................... #include "main.h" 

.................... #include <18F4550.h> 

.................... //////// Standard Header file for the PIC18F4550 device //////////////// 

.................... #device PIC18F4550 

.................... #list 

....................  

.................... #device adc=10 

....................  

.................... #FUSES NOWDT                    //No Watch Dog Timer 

.................... #FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale 

.................... #FUSES HSPLL                    //Crystal/Resonator with PLL enabled 

.................... #FUSES NOPROTECT                //Code not protected from reading 

.................... #FUSES NOBROWNOUT               //No brownout reset 

.................... #FUSES BORV20                   //Brownout reset at 2.0V 

.................... #FUSES NOPUT                    //No Power Up Timer 

.................... #FUSES NOCPD                    //No EE protection 

.................... #FUSES STVREN                   //Stack full/underflow will cause reset 

.................... #FUSES NODEBUG                  //No Debug mode for ICD 

.................... #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O 

.................... #FUSES NOWRT                    //Program memory not write protected 

.................... #FUSES NOWRTD                   //Data EEPROM not write protected 

.................... #FUSES IESO                     //Internal External Switch Over mode enabled 

.................... #FUSES FCMEN                    //Fail-safe clock monitor enabled 

.................... #FUSES PBADEN                   //PORTB pins are configured as analog input channels on RESET 

.................... #FUSES NOWRTC                   //configuration not registers write protected 

.................... #FUSES NOWRTB                   //Boot block not write protected 

.................... #FUSES NOEBTR                   //Memory not protected from table reads 

.................... #FUSES NOEBTRB                  //Boot block not protected from table reads 

.................... #FUSES NOCPB                    //No Boot Block code protection 

.................... #FUSES MCLR                     //Master Clear pin enabled 

.................... #FUSES LPT1OSC                  //Timer1 configured for low-power operation 

.................... #FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode) 

.................... #FUSES PLL5                    //Divide By 5(20MHz oscillator input) 

.................... #FUSES CPUDIV4                  //System Clock by 4 

.................... #FUSES USBDIV                   //USB clock source comes from PLL divide by 2 

.................... #FUSES VREGEN                   //USB voltage regulator enabled 

.................... #FUSES ICPRT                    //ICPRT enabled 

....................  

.................... #use delay(clock=24000000) 

....................  

....................  

....................  

.................... #define REV "$Rev$" 

....................  

.................... unsigned int32 time;   // pocitadlo preteceni casovace 

....................  

.................... #define BUFLEN 100 

....................  

.................... #int_RTCC 

.................... void  RTCC_isr(void)    // preruseni od pretekleho casovace  

.................... { 

....................   time++; 

*

025E:  MOVLW  01

0260:  ADDWF  19,F

0262:  BTFSC  FD8.0

0264:  INCF   1A,F

0266:  BTFSC  FD8.2

0268:  INCF   1B,F

026A:  BTFSC  FD8.2

026C:  INCF   1C,F

.................... } 

....................  

.................... // Includes all USB code and interrupts, as well as the CDC API 

.................... #include <usb_cdc.h> 

.................... ///////////////////////////////////////////////////////////////////////// 

.................... ////                                                                 //// 

.................... ////                            usb_cdc.h                            //// 

.................... ////                                                                 //// 

.................... //// Library for adding a virtual COM port on your PC over USB using //// 

.................... //// the standard Communication Device Class (CDC) specification.    //// 

.................... //// Including this file in your code will add all USB code,         //// 

.................... //// interrupts, descriptors and handlers required.  No other        //// 

.................... //// modifications need to be made.                                  //// 

.................... ////                                                                 //// 

.................... //// This library creates a virtual RS232 link between the PC and    //// 

.................... //// the PIC, therefore the library provided will be familiar to     //// 

.................... //// anyone with standard UART stream I/O:                           //// 

.................... ////                                                                 //// 

.................... //// usb_cdc_kbhit() - Returns TRUE if there is one or more          //// 

.................... ////      character received and waiting in the receive buffer.      //// 

.................... ////                                                                 //// 

.................... //// usb_cdc_getc() - Gets a character from the receive buffer.  If  //// 

.................... ////      there is no data in the receive buffer it will wait until  //// 

.................... ////      there is data in the receive buffer.  If you do not want   //// 

.................... ////      to wait in an infinit loop, use usb_cdc_kbhit() first to   //// 

.................... ////      check if there is data before calling usb_cdc_getc().      //// 

.................... ////                                                                 //// 

.................... //// usb_cdc_putc(char c) - Puts a character into the transmit       //// 

.................... ////      buffer.  If the transmit buffer is full it will wait until //// 

.................... ////      the transmit buffer is not full before putting the char    //// 

.................... ////      into the transmit buffer.  The transmit buffer is read by  //// 

.................... ////      the PC very quickly, and therefore the buffer should only  //// 

.................... ////      be full for a few milli-seconds.  If you are concerned     //// 

.................... ////      and don't want to be stuck in a long or infinite loop,     //// 

.................... ////      use usb_cdc_putready() to see if there is space in the     //// 

.................... ////      transmit buffer before putting data into the transmit      //// 

.................... ////      buffer.                                                    //// 

.................... ////                                                                 //// 

.................... //// usb_cdc_putready() - Returns TRUE if there is room left in the  //// 

.................... ////      transmit buffer for another character.                     //// 

.................... ////                                                                 //// 

.................... //// usb_cdc_connected() - Returns TRUE if we received a             //// 

.................... ////      Set_Line_Coding.  On most serial terminal programs (such   //// 

.................... ////      as Hyperterminal), they will send a Set_Line_Coding        //// 

.................... ////      message when the program starts and it opens the virtual   //// 

.................... ////      COM port.  This is a simple way to determine if the PC     //// 

.................... ////      is ready to display data on a serial terminal program,     //// 

.................... ////      but is not garaunteed to work all the time or on other     //// 

.................... ////      terminal programs.                                         //// 

.................... ////                                                                 //// 

.................... //// usb_cdc_putc_fast(char c) - Similar to usb_cdc_putc(), except   //// 

.................... ////      if the transmit buffer is full it will skip the char.      //// 

.................... ////                                                                 //// 

.................... //// usb_cdc_line_coding - A structure used for Set_Line_Coding and  //// 

.................... ////       Get_Line_Coding.  Most of the time you can ignore this.   //// 

.................... ////                                                                 //// 

.................... //// usb_cdc_break - If the PC has sent a break command, this will   //// 

.................... ////       hold the break time (in milli-seconds).  If the PC sends  //// 

.................... ////       a value of 0xFFFF the device is supposed to hold the      //// 

.................... ////       break until it sends a value of 0                         //// 

.................... ////                                                                 //// 

.................... //// usb_cdc_carrier - Where Set_Control_Line_State value is stored. //// 

.................... ////       Of most relevance is the field dte_present, which is the  //// 

.................... ////       DTR setting.                                              //// 

.................... ////                                                                 //// 

.................... //// The following functions are also provided, and are ports of the //// 

.................... //// I/O functions in input.c.  See input.c and the CCS manual for   //// 

.................... //// documentation:                                                  //// 

.................... ////   get_float_usb() - Read a float number from the user           //// 

.................... ////   get_long_usb() - Read a long number from the user             //// 

.................... ////   get_int_usb() - Read an integer number from the user          //// 

.................... ////   get_string_usb(char *s, int max) - Read a string from the user. //// 

.................... ////   gethex_usb() - Read a byte, in HEX, from the user             //// 

.................... ////   gethex1_usb() - Read a HEX character                          //// 

.................... ////                                                                 //// 

.................... //// This driver will load all the rest of the USB code, and a set   //// 

.................... //// of descriptors that will properly describe a CDC device for a   //// 

.................... //// virtual COM port (usb_desc_cdc.h)                               //// 

.................... ////                                                                 //// 

.................... //// An .INF file is provided (cdc_NTXP.inf) that will load the      //// 

.................... //// standard CDC drivers for a virtual COM port in Windows          //// 

.................... //// NT/2000/XP and above.                                           //// 

.................... ////                                                                 //// 

.................... ///////////////////////////////////////////////////////////////////////// 

.................... ////                                                                 //// 

.................... //// VERSION HISTORY                                                 //// 

.................... ////                                                                 //// 

.................... //// March 5th, 2009:                                                //// 

.................... ////   Cleanup for Wizard.                                           //// 

.................... ////   PIC24 Initial release.                                        //// 

.................... ////                                                                 //// 

.................... //// Nov 26th, 2007:                                                 //// 

.................... ////              usb_cdc_put_buffer_free() should be more stable.   //// 

.................... ////              Fixed a hang-up that would happen if you sent      //// 

.................... ////                 exactly 64 bytes.                               //// 

.................... ////                                                                 //// 

.................... //// Nov 6th, 2007:                                                  //// 

.................... ////              Compatabible with latest pic18_usb.h, which        //// 

.................... ////                 reduces RAM footprint of USB driver.            //// 

.................... ////              This driver now fits on 18F4450/2450 PICs.         //// 

.................... ////                                                                 //// 

.................... //// October 27th, 2005: Changed the way incoming packets are        //// 

.................... ////               handled in that CDC driver will not flush         //// 

.................... ////               endpoint until user has handled all data.  This   //// 

.................... ////               will prevent overflows as the USB will NAK        //// 

.................... ////               incoming packets until it is ready to receive     //// 

.................... ////               more.                                             //// 

.................... ////            When using 18F4550 family, the RX buffer is          //// 

.................... ////               mapped directly to the endpoint buffer - this     //// 

.................... ////               saves a chunk of RAM.                             //// 

.................... ////            When using the 18F4550 family, you can increase      //// 

.................... ////               the TX and RX size over 64 bytes.                 //// 

.................... ////            No longer send 0len packets in the TBE interrupt.    //// 

.................... ////            Hopefully fixed bugs that caused random crashes      //// 

.................... ////               if you tried sending more than 64 bytes.          //// 

.................... ////                                                                 //// 

.................... //// July 6th, 2005: Global interrupts disabled when writing to TX   //// 

.................... ////                   buffer.                                       //// 

.................... ////                                                                 //// 

.................... //// July 1st, 2005: Initial Release.                                //// 

.................... ////                                                                 //// 

.................... ///////////////////////////////////////////////////////////////////////// 

.................... ////        (C) Copyright 1996,2005 Custom Computer Services         //// 

.................... //// This source code may only be used by licensed users of the CCS  //// 

.................... //// C compiler.  This source code may only be distributed to other  //// 

.................... //// licensed users of the CCS C compiler.  No other use,            //// 

.................... //// reproduction or distribution is permitted without written       //// 

.................... //// permission.  Derivative programs created using this software    //// 

.................... //// in object code form are not restricted in any way.              //// 

.................... ///////////////////////////////////////////////////////////////////////// 

....................  

....................  

.................... //api for the user: 

.................... #define usb_cdc_kbhit() (usb_cdc_get_buffer_status.got) 

.................... #define usb_cdc_putready() (usb_cdc_put_buffer_nextin<USB_CDC_DATA_IN_SIZE) 

.................... #define usb_cdc_connected() (usb_cdc_got_set_line_coding) 

026E:  BCF    FF2.2

0270:  GOTO   0064

.................... void usb_cdc_putc_fast(char c); 

.................... char usb_cdc_getc(void); 

.................... void usb_cdc_putc(char c); 

....................  

.................... //input.c ported to use CDC: 

.................... float get_float_usb(); 

.................... signed long get_long_usb(); 

.................... signed int get_int_usb(); 

.................... void get_string_usb(char* s, unsigned int max); 

.................... BYTE gethex_usb(); 

.................... BYTE gethex1_usb(); 

....................  

.................... //functions automatically called by USB handler code 

.................... void usb_isr_tkn_cdc(void); 

.................... void usb_cdc_init(void); 

.................... void usb_isr_tok_out_cdc_control_dne(void); 

.................... void usb_isr_tok_in_cdc_data_dne(void); 

.................... void usb_isr_tok_out_cdc_data_dne(void); 

....................  

.................... void usb_cdc_flush_out_buffer(void); 

....................  

.................... ///////////////////////////////////////////////////////////////////////////// 

.................... // 

.................... // Include the CCS USB Libraries.  See the comments at the top of these 

.................... // files for more information 

.................... // 

.................... ///////////////////////////////////////////////////////////////////////////// 

.................... #ifndef __USB_PIC_PERIF__ 

.................... #define __USB_PIC_PERIF__   1 

.................... #endif 

....................  

.................... #if __USB_PIC_PERIF__ 

....................    #if defined(__PCH__) 

....................     #include <pic18_usb.h>   //Microchip 18Fxx5x hardware layer for usb.c 

.................... ///////////////////////////////////////////////////////////////////////// 

.................... ////                          pic18_usb.h                            //// 

.................... ////                                                                 //// 

.................... //// Hardware layer for CCS's USB library.  This hardware layer      //// 

.................... //// supports the USB peripheral on the PIC18 family chips.  Current //// 

.................... //// supported families are:                                         //// 

.................... ////     PIC18F2455/2550/4455/4550                                   //// 

.................... ////     PIC18F2450/4450                                             //// 

.................... ////     PIC18F2458/2553/4458/4553                                   //// 

.................... ////     PIC18F13K50/14K50                                           //// 

.................... ////     PIC18F65J50/66J50/66J55/67J50/85J50/86J50/86J55/87J50       //// 

.................... ////                                                                 //// 

.................... //// This file is part of CCS's PIC USB driver code.  See USB.H      //// 

.................... //// for more documentation and a list of examples.                  //// 

.................... ////                                                                 //// 

.................... //// See the section labeled EXTRA USER FUNCTIONS for functions      //// 

.................... //// that are specific to only this HW peripheral that you may       //// 

.................... //// find useful to use in your application.                         //// 

.................... ////                                                                 //// 

.................... ////   *********** NOTE ABOUT 18F2450/4450 LIMITATIONS **********    //// 

.................... ////  Due to the limited USB RAM of this family, a limitation of     //// 

.................... ////  this driver is that there are only 3 endpoints (0, 1 and 2).   //// 

.................... ////  The HW actually supports more endpoints, but to simplify       //// 

.................... ////  driver development this driver will only support the first 3   //// 

.................... ////  so there is an easier memory block to work with.               //// 

.................... ////                                                                 //// 

.................... ////  USB_MAX_EP0_PACKET_LENGTH will also be set to 8 regardless     //// 

.................... ////  of USB speed, to save RAM.                                     //// 

.................... ////                                                                 //// 

.................... ////   ************** NOTE ABOUT HW REQUIREMENTS ****************    //// 

.................... ////  If you are not using internal pullups, you will need to put    //// 

.................... ////  an internal pullup resistor on D+ or D+ depending on if you    //// 

.................... ////  want to use slow speed or full speed.  This code configures    //// 

.................... ////  the device to use internal pullups, see usb_init() if you      //// 

.................... ////  want to change that.                                           //// 

.................... ////                                                                 //// 

.................... ////  You need approximately 470nF cap on Vusb, even if you are      //// 

.................... ////  using the internal 3.3V USB regulator.                         //// 

.................... ////                                                                 //// 

.................... ////  To run at full speed, you must use the oscillator              //// 

.................... ////  configuration (PLLx) to set the PLL divide to 4MHz.  You can   //// 

.................... ////  configure the MCU clock to any speed (up to 48MHz) but the     //// 

.................... ////  PLL must run at 4Mhz to provide the USB peripheral with a      //// 

.................... ////  96MHz clock.  See the datasheet for details.                   //// 

.................... ////                                                                 //// 

.................... ////  To run at slow speed you must configure your MCU to run at     //// 

.................... ////  24Mhz.  See the datasheet for details.                         //// 

.................... ////                                                                 //// 

.................... ////   ****************  NOTE ABOUT INTERRUPTS  ******************   //// 

.................... //// This driver uses INT_USB.  It requires INT_USB to interrupt the //// 

.................... //// PIC when an event has happened on the USB Bus.  Therfore        //// 

.................... //// this code enables interrupts.  A user modification can be made  //// 

.................... //// to poll the USB interrupt flag instead of relying on an         //// 

.................... //// interrupt.                                                      //// 

.................... ////                                                                 //// 

.................... ///////////////////////////////////////////////////////////////////////// 

.................... ////                                                                 //// 

.................... //// Version History:                                                //// 

.................... ////                                                                 //// 

.................... //// March 5th, 2009:                                                //// 

.................... ////   18F14K50 family added.                                        //// 

.................... ////   Cleanup for Wizard.                                           //// 

.................... ////   PIC24 Initial release.                                        //// 

.................... ////                                                                 //// 

.................... //// Nov 3rd, 2008:                                                  //// 

.................... ////  * 4553 family added.                                           //// 

.................... ////                                                                 //// 

.................... //// Dec 18, 2007:                                                   //// 

.................... ////  * usb_kbhit() moved to device driver.                          //// 

.................... ////  * USB Token handler changed to workaround a flaw in the USB    //// 

.................... ////     peripheral to prevent the USB peripheral from               //// 

.................... ////     inadvertantly STALLing the endpoint.  Happened most often   //// 

.................... ////     in bulk demo applications, especially CDC.                  //// 

.................... ////                                                                 //// 

.................... ////   11-6-07:  Fixed a bug where usb_data_buffer[] was reserving   //// 

.................... ////                 too much RAM.                                   //// 

.................... ////             USB_MAX_EP0_PACKET_LENGTH value can be overwritten. ////  

.................... ////                 For the 18F4450/2450 family this should be 8    //// 

.................... ////                 because of limited RAM.  Reducing this value    ////  

.................... ////                 frees RAM for application.                      //// 

.................... ////             Based upon which endpoints have been configured for //// 

.................... ////                 use, will free up unused USB data RAM for       //// 

.................... ////                 application dynamically.  This should free up   //// 

.................... ////                 at least 128 bytes of RAM.                      //// 

.................... ////             CDC now fits on a 18F4450/2450                      //// 

.................... ////                                                                 //// 

.................... ////   09-19-07: Fixed problems with 18F4450 family.                 //// 

.................... ////                                                                 //// 

.................... ////   07-17-07: Added 18F4450,2450 support                          //// 

.................... ////                                                                 //// 

.................... ////   07-13-07: Added 87J50 family support                          //// 

.................... ////                                                                 //// 

.................... ////   11-01-05: usb_detach(), usb_attach() and usb_init_cs()        //// 

.................... ////               changed for the better.                           //// 

.................... ////                                                                 //// 

.................... ////   10-28-05: Added usb_rx_packet_size()                          //// 

.................... ////                                                                 //// 

.................... ////   07-13-05: usb_put_packet() changed for 16bit packet sizes     //// 

.................... ////             usb_flush_in() changed for 16bit packet sizes       //// 

.................... ////             usb_get_packet() changed for 16bit packet sizes     //// 

.................... ////             usb_flush_out() changed for 16bit packet sizes      //// 

.................... ////             usb_set_configured() changed for 16bit packet sizes //// 

.................... ////                                                                 //// 

.................... ////   06-30-05: usb_tbe() added                                     //// 

.................... ////             The way endpoint 0 DTS is set has been changed.     //// 

.................... ////                                                                 //// 

.................... ////   06-20-05: Initial Release                                     //// 

.................... ////                                                                 //// 

.................... ////   05-13-05: Beta Release (Full Speed works)                     //// 

.................... ////                                                                 //// 

.................... ////   03-21-05: Initial Alpha Release                               //// 

.................... ////                                                                 //// 

.................... ///////////////////////////////////////////////////////////////////////// 

.................... ////        (C) Copyright 1996,2005 Custom Computer Services         //// 

.................... //// This source code may only be used by licensed users of the CCS  //// 

.................... //// C compiler.  This source code may only be distributed to other  //// 

.................... //// licensed users of the CCS C compiler.  No other use,            //// 

.................... //// reproduction or distribution is permitted without written       //// 

.................... //// permission.  Derivative programs created using this software    //// 

.................... //// in object code form are not restricted in any way.              //// 

.................... ///////////////////////////////////////////////////////////////////////// 

....................  

.................... #IFNDEF __PIC18_USB_H__ 

.................... #DEFINE __PIC18_USB_H__ 

....................  

.................... #DEFINE __USB_HARDWARE__ 

....................  

.................... //let the USB Stack know that we are using a PIC with internal USB peripheral 

.................... #DEFINE __PIC__   1 

....................  

.................... #ifndef USB_USE_FULL_SPEED 

....................  #define USB_USE_FULL_SPEED   TRUE 

.................... #endif 

....................  

.................... #ifndef USB_MAX_EP0_PACKET_LENGTH 

.................... #if ((getenv("DEVICE")=="PIC18F2450") || (getenv("DEVICE")=="PIC18F4450")) 

....................    //due to limited ram, force max packet length to 8 for this chip 

....................    #define USB_MAX_EP0_PACKET_LENGTH   8 

.................... #else 

....................    #if USB_USE_FULL_SPEED==FALSE 

....................       //slow speed requires 8byte max packet size for endpoint 0 

....................       #DEFINE USB_MAX_EP0_PACKET_LENGTH   8 

....................    #else 

....................       //for full speed you can still use 8bytes, but 64 will be faster 

....................       #DEFINE USB_MAX_EP0_PACKET_LENGTH   64 

....................    #endif 

.................... #endif 

.................... #endif 

....................  

.................... #if (!USB_USE_FULL_SPEED && (USB_MAX_EP0_PACKET_LENGTH!=8)) 

....................  #error Slow speed devices must use a max packet size of 8 for endpoint 0! 

.................... #endif 

....................  

.................... #if USB_MAX_EP0_PACKET_LENGTH < 8 

....................  #error Max Endpoint 0 length can't be less than 8! 

.................... #endif 

....................  

.................... #if USB_MAX_EP0_PACKET_LENGTH > 64 

....................  #error Max Endpoint 0 length can't be greater than 64! 

.................... #endif 

....................  

.................... #include <usb_hw_layer.h> 

.................... /////////////////////////////////////////////////////////////////////////// 

.................... ////                         usb_hw_layer.h                            //// 

.................... ////                                                                   //// 

.................... //// HW Layer for the USB Stack.                                       //// 

.................... ////                                                                   //// 

.................... //// HW drivers for the USB stack must support this API.               //// 

.................... ////                                                                   //// 

.................... //// The HW driver must also have a token handler that will call       //// 

.................... //// usb_token_reset() when the device is init/reset, will call        //// 

.................... //// usb_isr_tok_setup_dne() when it receives a setup packet,          //// 

.................... //// will call usb_isr_tok_out_dne() when a new packet is received,    //// 

.................... //// and will call usb_isr_tok_in_dne() when a new packet is sent.     //// 

.................... //// See usb.h for documentation of these functions.                   //// 

.................... ////                                                                   //// 

.................... /////////////////////////////////////////////////////////////////////////// 

.................... ////                                                                   //// 

.................... //// Version History:                                                  //// 

.................... ////                                                                   //// 

.................... //// March 5th, 2009:                                                  //// 

.................... ////   Cleanup for Wizard.                                             //// 

.................... ////   PIC24 Initial release.                                          //// 

.................... ////                                                                   //// 

.................... /////////////////////////////////////////////////////////////////////////// 

.................... ////        (C) Copyright 1996,2009 Custom Computer Services           //// 

.................... //// This source code may only be used by licensed users of the CCS    //// 

.................... //// C compiler.  This source code may only be distributed to other    //// 

.................... //// licensed users of the CCS C compiler.  No other use,              //// 

.................... //// reproduction or distribution is permitted without written         //// 

.................... //// permission.  Derivative programs created using this software      //// 

.................... //// in object code form are not restricted in any way.                //// 

.................... /////////////////////////////////////////////////////////////////////////// 

....................  

.................... #ifndef __USB_HW_LAYER_H__ 

.................... #define __USB_HW_LAYER_H__ 

....................  

.................... enum USB_DTS_BIT {USB_DTS_DATA1=1, USB_DTS_TOGGLE=2, USB_DTS_DATA0=0, 

....................                    USB_DTS_STALL=3, USB_DTS_USERX=4}; 

....................  

....................  

.................... // USER LEVEL FUNCTIONS: 

....................  

.................... /***************************************************************************** 

.................... /* usb_init() 

.................... /* 

.................... /* Summary: See API section of USB.H for documentation. 

.................... /* 

.................... /*****************************************************************************/ 

.................... void usb_init(void); 

....................  

.................... /***************************************************************************** 

.................... /* usb_init_cs() 

.................... /* 

.................... /* Summary: See API section of USB.H for documentation. 

.................... /* 

.................... /*****************************************************************************/ 

.................... void usb_init_cs(void); 

....................  

.................... /***************************************************************************** 

.................... /* usb_task() 

.................... /* 

.................... /* Summary: See API section of USB.H for documentation. 

.................... /* 

.................... /*****************************************************************************/ 

.................... void usb_task(void); 

....................  

.................... /****************************************************************************** 

.................... /* usb_attach() 

.................... /* 

.................... /* Summary: Attach the D+/D- lines to the USB bus.  Enable the USB peripheral. 

.................... /* 

.................... /* You should wait until UCON_SE0 is clear before enabling reset/idle interrupt. 

.................... /*  

.................... /* Shouldn't be called by user, let usb_task() handle this. 

.................... /* 

.................... /* NOTE: If you are writing a new HW driver, this routine should call  

.................... /*       usb_token_reset() to reset the CH9 stack. 

.................... /* 

.................... /*****************************************************************************/ 

.................... void usb_attach(void); 

....................  

.................... /****************************************************************************** 

.................... /* usb_detach() 

.................... /* 

.................... /* Summary: Remove the D+/D- lines from the USB bus.  Basically, disable USB. 

.................... /* 

.................... /* Shouldn't be called by user, let usb_task() handle this. 

.................... /* 

.................... /* If the user does call this function while USB is connected, the USB  

.................... /* peripheral will be disabled only momentarily because usb_task() will 

.................... /* reconnect.  But this is a great way to cause the PC/HOST to cause a USB 

.................... /* reset of the device. 

.................... /* 

.................... /* NOTE: If you are writing a new HW driver, this routine should call  

.................... /*       usb_token_reset() to reset the CH9 stack. 

.................... /* 

.................... /*****************************************************************************/ 

.................... void usb_detach(void); 

....................  

.................... /****************************************************************************** 

.................... /* usb_put_packet() 

.................... /* 

.................... /* Input: endpoint - endpoint to send packet to (0..15). 

.................... /*        ptr - points to data to send. 

.................... /*        len - amount of data to send. 

.................... /*        toggle - whether to send data with a DATA0 pid, a DATA1 pid,  

.................... /*                 or toggle from the last DATAx pid. 

.................... /* 

.................... /* Output: TRUE if data was sent correctly, FALSE if it was not.  The only  

.................... /*         reason it will return FALSE is if because the TX buffer is still full  

.................... /*         from the last time it tried to send a packet. 

.................... /* 

.................... /* Summary: Sends one packet out the EP to the host.  Notice that there is a  

.................... /*          difference between a packet and a message.  If you wanted to send a  

.................... /*          512 byte message on an endpoint that only supported 64 byte packets, 

.................... /*          this would be accomplished this by sending 8 64-byte packets,  

.................... /*          followed by a 0 length packet.  If the last (or only packet) being  

.................... /*          sent is less than the max packet size defined in your descriptor  

.................... /*          then you do not need to send a 0 length packet to identify 

.................... /*          an end of message. 

.................... /* 

.................... /*          usb_puts() (provided in usb.c) will send a multi-packet message  

.................... /*          correctly and know if a 0 lenght packet needs to be sent. 

.................... /* 

.................... /* The result will be invalid if the specified input has not been configured for 

.................... /* use by the API with USB_EPx_TX_SIZE 

.................... /* 

.................... /*****************************************************************************/ 

.................... int1 usb_put_packet(int8 endpoint, int8 * ptr, unsigned int16 len, USB_DTS_BIT tgl); 

....................  

.................... /******************************************************************************* 

.................... /* usb_get_packet(endpoint, *ptr, max) 

.................... /* 

.................... /* Input: endpoint - endpoint to get data from 

.................... /*        ptr - where to save data to local PIC RAM 

.................... /*        max - max amount of data to receive from buffer 

.................... /* 

.................... /* Output: the amount of data taken from the buffer and saved to ptr. 

.................... /* 

.................... /*         NOTE - IF THERE IS NO PACKET TO GET YOU WILL GET INVALID RESULTS! 

.................... /*                VERIFY WITH USB_KBHIT() BEFORE YOU CALL USB_GET_PACKET()! 

.................... /* 

.................... /* Summary: Gets a packet of data from the USB endpoint buffer. 

.................... /*          Until this is called, if there is data in the receive buffer the 

.................... /*          PC/HOST will be prevented from sending more data.  Upon completion 

.................... /*          of this call, the endpoint will be freed and the PC/HOST will be 

.................... /*          allowed to send a new packet.  Only receives one packet, if you need  

.................... /*          to receive multiple packets or handle 0-length terminator packets, 

.................... /*          then use usb_gets(). 

.................... /* 

.................... /* The result will be invalid if the specified input has not been configured for 

.................... /* use by the API with USB_EPx_RX_SIZE 

.................... /* 

.................... /********************************************************************************/ 

.................... unsigned int16 usb_get_packet(int8 endpoint, int8 * ptr, unsigned int16 max); 

....................  

.................... /**************************************************************************** 

.................... /* usb_kbhit(endpoint) 

.................... /* 

.................... /* Input: endpoint - endpoint to check (0..15) 

.................... /* 

.................... /* Output: TRUE if there is new data in RX buffer, FALSE if there is not. 

.................... /* 

.................... /* Summary: Similar to kbhit(), sees if there is new data in the RX USB buffers. 

.................... /*          See API section of USB.H for more information. 

.................... /* 

.................... /* The result will be invalid if the specified input has not been configured for 

.................... /* use by the API with USB_EPx_RX_SIZE 

.................... /* 

.................... /*****************************************************************************/ 

.................... int1 usb_kbhit(int8 en); 

....................  

.................... /****************************************************************************** 

.................... /* usb_tbe(endpoint) 

.................... /* 

.................... /* Input: endpoint - endpoint to check 

.................... /*        ptr - where to save data to local PIC RAM 

.................... /*        max - max amount of data to receive from buffer 

.................... /* 

.................... /* Output: returns TRUE if this endpoint's IN buffer (PIC-PC) is empty and ready 

.................... /*         returns FALSE if this endpoint's IN buffer is still processing the last 

.................... /*         transmit or if this endpoint is invalid. 

.................... /* 

.................... /* The result will be invalid if the specified input has not been configured for 

.................... /* use by the API with USB_EPx_TX_SIZE 

.................... /* 

.................... /*****************************************************************************/ 

.................... int1 usb_tbe(int8 en); 

....................  

.................... //////////////// END USER LEVEL FUNCTIONS ///////////////////////////////////// 

....................  

....................  

.................... /// 

.................... /// BEGIN STACK LEVEL FUNCTIONS: These functions are meant to be called by 

.................... ///            the USB stack, and are not meant to be called by the  

.................... ///            user/application. 

.................... /// 

....................  

.................... /***************************************************************************** 

.................... /* usb_stall_ep() 

.................... /* 

.................... /* Input: endpoint - endpoint to stall. 

.................... /*                   top most bit indicates direction (set is IN, clear is OUT) 

.................... /* 

.................... /* Summary: Stalls specified endpoint.  If endpoint is stalled it will 

.................... /*          send STALL packet if the host tries to access this endpoint's  

.................... /*          buffer. 

.................... /* 

.................... /* NOTE: WE ASSUME ENDPOINT IS VALID.  USB.C SHOULD CHECK IF VALID BEFORE 

.................... /*       CALLING THIS ROUTINE. 

.................... /* 

.................... /*****************************************************************************/ 

.................... void usb_stall_ep(int8 endpoint); 

....................  

....................  

.................... /***************************************************************************** 

.................... /* usb_unstall_ep(endpoint, direction) 

.................... /* 

.................... /* Input: endpoint - endpoint to un-stall. 

.................... /*                   top most bit indicates direction (set is IN, clear is OUT) 

.................... /* 

.................... /* Summary: Un-stalls endpoint. 

.................... /* 

.................... /* NOTE: WE ASSUME ENDPOINT IS VALID.  USB.C SHOULD CHECK IF VALID BEFORE 

.................... /*       CALLING THIS ROUTINE. 

.................... /* 

.................... /*****************************************************************************/ 

.................... void usb_unstall_ep(int8 endpoint); 

....................  

.................... /***************************************************************************** 

.................... /* usb_endpoint_stalled() 

.................... /* 

.................... /* Input: endpoint - endpoint to check 

.................... /*                   top most bit indicates direction (set is IN, clear is OUT) 

.................... /* 

.................... /* Output: returns a TRUE if endpoint is stalled, FALSE if it is not. 

.................... /* 

.................... /* Summary: Looks to see if an endpoint is stalled, or not.  Does not look to 

.................... /*          see if endpoint has been issued a STALL, just whether or not it is 

.................... /*          configured to STALL on the next packet.  See Set_Feature and  

.................... /*          Clear_Feature Chapter 9 requests. 

.................... /* 

.................... /* NOTE: WE ASSUME ENDPOINT IS VALID.  USB.C SHOULD CHECK IF VALID BEFORE 

.................... /*       CALLING THIS ROUTINE. 

.................... /* 

.................... /*****************************************************************************/ 

.................... int1 usb_endpoint_stalled(int8 endpoint); 

....................  

.................... /***************************************************************************** 

.................... /* usb_set_address(address) 

.................... /* 

.................... /* Input: address - address the host specified that we use 

.................... /* 

.................... /* Summary: Configures the USB Peripheral for the specified device address.   

.................... /*          The host will now talk to use with the following address. 

.................... /* 

.................... /*****************************************************************************/ 

.................... void usb_set_address(int8 address); 

....................  

.................... /****************************************************************************** 

.................... /* usb_set_configured() 

.................... /* 

.................... /* Input: config - Configuration to use.  0 to uncofigure device. 

.................... /* 

.................... /* Summary: Configures or unconfigures device.  If configuring device it will 

.................... /*          enable all the endpoints the user specified for this configuration. 

.................... /*          If un-configuring device it will disable all endpoints. 

.................... /* 

.................... /*          NOTE: CCS only provides code to handle 1 configuration. 

.................... /* 

.................... /*****************************************************************************/ 

.................... void usb_set_configured(int8 config); 

....................  

.................... /****************************************************************************** 

.................... /* usb_disable_endpoints() 

.................... /* 

.................... /* Summary: Disables endpoints (all endpoints but 0) 

.................... /* 

.................... /*****************************************************************************/ 

.................... void usb_disable_endpoints(void); 

....................  

....................  

.................... /******************************************************************************* 

.................... /* usb_disable_endpoint() 

.................... /* 

.................... /* Input: Endpoint to disable (0..15) 

.................... /* 

.................... /* Summary: Disables specified endpoint 

.................... /* 

.................... /********************************************************************************/ 

.................... void usb_disable_endpoint(int8 en); 

....................  

.................... /************************************************************** 

.................... /* usb_request_send_response(len) 

.................... /* usb_request_get_data() 

.................... /* usb_request_stall() 

.................... /* 

.................... /* Input: len - size of packet to send 

.................... /* 

.................... /* Summary: One of these 3 functions will be called by the USB stack after 

.................... /*          handling a SETUP packet. 

.................... /*           

.................... /*          After we process a SETUP request, we have 1 of three responses: 

.................... /*            1.) send a response IN packet 

.................... /*            2.) wait for followup OUT packet(s) with data 

.................... /*            3.) stall because we don't support that SETUP request 

.................... /* 

.................... /*          If we are sending data, the array usb_ep0_tx_buffer[] will hold 

.................... /*          the response and the USB Request handler code will call 

.................... /*          usb_request_send_response() to let us know how big the packet is. 

.................... /* 

.................... /*          If we are waiting for more data, usb_request_get_data() will 

.................... /*          be called by the USB request handler code to configure the EP0 OUT 

.................... /*          endpoint to be ready for more data 

.................... /* 

.................... /*          If we don't support a request, usb_request_stall() will be called 

.................... /*          by the USB request handler code to stall the endpoint 0. 

.................... /* 

.................... /*          The operation of these functions depends on how SETUP packets 

.................... /*          are handled in the hardware layer. 

.................... /* 

.................... /***************************************************************/ 

.................... void usb_request_send_response(unsigned int8 len); 

.................... void usb_request_get_data(void); 

.................... void usb_request_stall(void); 

....................  

....................  

.................... #endif 

....................  

....................  

.................... //////////////////////// EXTRA USER FUNCTIONS ///////////////////////////////// 

....................  

.................... /************************************************************** 

.................... /* usb_flush_in() 

.................... /* 

.................... /* Input: endpoint - which endpoint to mark for transfer 

.................... /*        len - length of data that is being tramsferred 

.................... /*        tgl - Data toggle synchronization for this packet 

.................... /* 

.................... /* Output: TRUE if success, FALSE if error (we don't control the endpoint) 

.................... /* 

.................... /* Summary: Marks the endpoint ready for transmission.  You must 

.................... /*          have already loaded the endpoint buffer with data. 

.................... /*          (IN is PIC -> PC). 

.................... /*          This routine is useful if you want to setup an endpoint by 

.................... /*          writing to the buffer directly. 

.................... /*          This routine is not necessary if you use usb_put_packet(). 

.................... /***************************************************************/ 

.................... int1 usb_flush_in(int8 endpoint, int16 len, USB_DTS_BIT tgl); 

....................  

.................... /************************************************************** 

.................... /* usb_flush_out() 

.................... /* 

.................... /* Input: endpoint - which endpoint to mark for release 

.................... /*        tgl - Data toggle synchronization to expect in the next packet 

.................... /* 

.................... /* Output: NONE 

.................... /* 

.................... /* Summary: Clears the previously received packet, and then marks this 

.................... /*          endpoint's receive buffer as ready for more data. 

.................... /*          (OUT is PC -> PIC).  This routine is useful if you do not 

.................... /*          want to use usb_get_packet(), instead you want to handle with 

.................... /*          the endpoint buffer directly.  Also see usb_rx_packet_size(). 

.................... /*          This routine is not necessary if you use usb_get_packet(). 

.................... /***************************************************************/ 

.................... void usb_flush_out(int8 endpoint, USB_DTS_BIT tgl); 

....................  

.................... /************************************************************** 

.................... /* usb_rx_packet_size() 

.................... /* 

.................... /* Input: endpoint - which endpoint to mark to check 

.................... /* 

.................... /* Output: Returns the number of bytes in the endpoint's receive buffer. 

.................... /* 

.................... /* Summary: Read the number of data stored in the receive buffer.  When you 

.................... /*    have handled the data, use usb_flush_out() to clear the buffer.  The 

.................... /*    result may be invalid if usb_kbhit() returns false for this endpoint. 

.................... /*    This routine is not necessary if you use usb_get_packet(). 

.................... /***************************************************************/ 

.................... int16 usb_rx_packet_size(int8 endpoint); 

....................  

.................... #ENDIF 

....................  

....................    #else 

....................     #include <pic24_usb.h>   //Microchip 18Fxx5x hardware layer for usb.c 

....................    #endif 

.................... #else 

....................    #include <usbn960x.h> 

.................... #endif 

.................... #include <usb_desc_cdc.h>   //USB Configuration and Device descriptors for this UBS device 

.................... /////////////////////////////////////////////////////////////////////////// 

.................... ////                         usb_desc_cdc.h                            //// 

.................... ////                                                                   //// 

.................... //// An example set of device / configuration descriptors for use with //// 

.................... //// CCS's CDC Virtual COM Port driver (see usb_cdc.h)                 //// 

.................... ////                                                                   //// 

.................... //// This file is part of CCS's PIC USB driver code.  See USB.H        //// 

.................... //// for more documentation and a list of examples.                    //// 

.................... ////                                                                   //// 

.................... /////////////////////////////////////////////////////////////////////////// 

.................... ////                                                                   //// 

.................... //// Version History:                                                  //// 

.................... ////                                                                   //// 

.................... //// March 5th, 2009:                                                  //// 

.................... ////   Cleanup for Wizard.                                             //// 

.................... ////   PIC24 Initial release.                                          //// 

.................... ////                                                                   //// 

.................... //// 10/28/05:                                                         //// 

.................... ////    Bulk endpoint sizes updated to allow more than 255 byte        //// 

.................... ////    packets.                                                       //// 

.................... ////    Changed device to USB 1.10                                     //// 

.................... ////                                                                   //// 

.................... /////////////////////////////////////////////////////////////////////////// 

.................... ////        (C) Copyright 1996,2005 Custom Computer Services           //// 

.................... //// This source code may only be used by licensed users of the CCS    //// 

.................... //// C compiler.  This source code may only be distributed to other    //// 

.................... //// licensed users of the CCS C compiler.  No other use,              //// 

.................... //// reproduction or distribution is permitted without written         //// 

.................... //// permission.  Derivative programs created using this software      //// 

.................... //// in object code form are not restricted in any way.                //// 

.................... /////////////////////////////////////////////////////////////////////////// 

....................  

.................... #IFNDEF __USB_DESCRIPTORS__ 

.................... #DEFINE __USB_DESCRIPTORS__ 

....................  

.................... ///////// config options, although it's best to leave alone for this demo ///// 

.................... #define  USB_CONFIG_PID       0x0033 

.................... #define  USB_CONFIG_VID       0x0461 

.................... #define  USB_CONFIG_BUS_POWER 100   //100mA  (range is 0..500) 

.................... #define  USB_CONFIG_VERSION   0x0100      //01.00  //range is 00.00 to 99.99 

.................... //////// end config /////////////////////////////////////////////////////////// 

....................  

.................... #DEFINE USB_HID_DEVICE  FALSE 

.................... #DEFINE USB_CDC_DEVICE  TRUE 

....................  

.................... #define USB_CDC_COMM_IN_ENDPOINT       1 

.................... #define USB_CDC_COMM_IN_SIZE           8 

.................... #define USB_EP1_TX_ENABLE  USB_ENABLE_INTERRUPT 

.................... #define USB_EP1_TX_SIZE  USB_CDC_COMM_IN_SIZE 

....................  

.................... //pic to pc endpoint config 

.................... #define USB_CDC_DATA_IN_ENDPOINT       2 

.................... #define USB_CDC_DATA_IN_SIZE           64 

.................... #define USB_EP2_TX_ENABLE  USB_ENABLE_BULK 

.................... #define USB_EP2_TX_SIZE  USB_CDC_DATA_IN_SIZE 

....................  

.................... //pc to pic endpoint config 

.................... #define USB_CDC_DATA_OUT_ENDPOINT       2 

.................... #define USB_CDC_DATA_OUT_SIZE           64 

.................... #define USB_EP2_RX_ENABLE  USB_ENABLE_BULK 

.................... #define USB_EP2_RX_SIZE  USB_CDC_DATA_OUT_SIZE 

....................  

.................... #include <usb.h> 

.................... /////////////////////////////////////////////////////////////////////////// 

.................... ////                              usb.h                                //// 

.................... ////                                                                   //// 

.................... //// Function protypes, defintions and globals used by CCS USB driver  //// 

.................... ////                                                                   //// 

.................... //// This file is part of CCS's USB driver code                        //// 

.................... ////                                                                   //// 

.................... //// The following USB examples are provided by CCS:                   //// 

.................... ////   ex_usb_mouse.c - A HID Mouse.                                   //// 

.................... ////   ex_usb_hid.c - A custom application using HID protocol.         //// 

.................... ////   ex_usb_kbmouse.c - A HID Mouse/Keyboard combo using multiple    //// 

.................... ////                      interfaces.                                  //// 

.................... ////   ex_usb_kbmouse2.c - A HID Mouse/Keyboard combo using multiple   //// 

.................... ////                      HID Reports.                                 //// 

.................... ////   ex_usb_scope.c - A digital oscilloscope using a custom          //// 

.................... ////                    protocol requiring custom Windows drivers.     //// 

.................... ////   ex_usb_serial.c -                                               //// 

.................... ////   ex_usb_serial2.c - Two examples of using the CDC driver for     //// 

.................... ////     a virtual COM port.                                           //// 

.................... ////   ex_usb_bootloader.c - CDC/Virtual COM port bootloader.          //// 

.................... ////   ex_usb_loadmouse.c - A conversion of ex_usb_mouse.c that is     //// 

.................... ////        compatible with ex_usb_mouse.c.                            //// 

.................... ////                                                                   //// 

.................... ////        ********************** API *********************           //// 

.................... ////                                                                   //// 

.................... //// These are the functions that are meant to be called by the user:  //// 

.................... ////                                                                   //// 

.................... //// usb_init() - Initializes the USB stack, the USB peripheral and    //// 

.................... ////              attaches the unit to the usb bus.  Enables           //// 

.................... ////              interrupts.  Will wait in an infinite loop until     //// 

.................... ////              the device enumerates - if you are using             //// 

.................... ////              connection sense or if the processor should run      //// 

.................... ////              even if it's not connected to USB then use           //// 

.................... ////              usb_init_cs() instead.                               //// 

.................... ////                                                                   //// 

.................... //// usb_init_cs() - A smaller usb_init(), does not attach unit        //// 

.................... ////              to usb bus or enable interrupts.  Since this does    //// 

.................... ////              not attach to the USB, you must periodically call    //// 

.................... ////              usb_task().  See usb_task() for more information.    //// 

.................... ////                                                                   //// 

.................... //// usb_task() - If usb_init_cs() was used to initiate the USB        //// 

.................... ////        peripheral, usb_task() should then be called periodically  //// 

.................... ////        to check the connection sense pin.  If the connection      //// 

.................... ////        sense pin denotes USB is connected and the USB peripheral  //// 

.................... ////        is not attached, this will attach the USB peripheral       //// 

.................... ////        so the PC can start the enumeration process (and it        //// 

.................... ////        will enable interrupts).  If the connection sense pin      //// 

.................... ////        denotes USB is not attached and the USB peripheral is      //// 

.................... ////        running, this will reset the USB peripheral and wait       //// 

.................... ////        for USB to reconnect (and usb_enumerated() will start      //// 

.................... ////        returning FALSE).  If connection sense (USB_CON_SENSE_PIN) //// 

.................... ////        is not defined the usb_task() assumes that USB is always   //// 

.................... ////        connected.                                                 //// 

.................... ////                                                                   //// 

.................... //// usb_attached() - Returns TRUE if the device is attached to a      //// 

.................... ////                  USB cable.  A macro that looks at the defined    //// 

.................... ////                  connection sense pin.  If this returns TRUE      //// 

.................... ////                  it does not mean the PC has connected to it,     //// 

.................... ////                  you need to use usb_enumerated() to check this.  //// 

.................... ////                                                                   //// 

.................... //// usb_enumerated() - Returns TRUE if device has been enumerated     //// 

.................... ////                    (configured) by host, FALSE if it has not.     //// 

.................... ////                    Do not try to use the USB peripheral for       //// 

.................... ////                    sending and receiving packets until you        //// 

.................... ////                    are enumerated.                                //// 

.................... ////                                                                   //// 

.................... //// usb_wait_for_enumeration() - Sits in an infinte loop until device //// 

.................... ////                              is enumerated.                       //// 

.................... ////                                                                   //// 

.................... //// usb_tbe(endpoint) - Returns TRUE if the endpoint transmit buffer  //// 

.................... ////     is free and ready to accept a new packet for transmission.    //// 

.................... ////                                                                   //// 

.................... //// usb_put_packet(endpoint, ptr, len, tgl) - Sends one packet to the //// 

.................... ////                    host.  If you need to send a message that      //// 

.................... ////                    spans more than one packet then use            //// 

.................... ////                    usb_puts().  Fore more detailed documentation  //// 

.................... ////                    see usb_hw_layer.h                             //// 

.................... ////                                                                   //// 

.................... //// usb_puts(endpoint, ptr, len, timeout) - Sends a multiple packet   //// 

.................... ////     message to the host.  If you only need to send one packet,    //// 

.................... ////     it is more effecient to use usb_put_packet().  This is        //// 

.................... ////     documented in more detail above the prototype in USB.H.       //// 

.................... ////                                                                   ////