There are various sample programs that demonstrate the capabilties of the Jallib USB library. Sample files are available to show the following features:

• Using the PIC as a serial (COM) port
• Using the PIC as a keyboard
• Using the PIC as a mouse
• Using the PIC as a Human Interface Device (HID)

include 16f1455             -- Target processor.

pragma target clock         48_000_000

-- Settings for internal clock and system clock 48 MHz.
pragma target OSC           INTOSC_NOCLKOUT -- Internal clock
pragma target CLKOUTEN      DISABLED -- CLKOUT function is disabled. 
pragma target PLLMULT       N3X      -- PLL Multipler Selection Bit, 3x

-- Other fuses.
pragma target CPUDIV        P1       -- NO CPU system divide
pragma target USBLSCLK      F48MHZ   -- System clock expects 48 MHz
pragma target PLLEN         ENABLED  -- 3x or 4x PLL Enabled
pragma target FCMEN         DISABLED -- Fail-Safe Clock Monitor is disabled
pragma target WRT           DISABLED -- Write protection off
pragma target STVR          ENABLED  -- Stack Overflow or Underflow will cause a Reset
pragma target LPBOR         DISABLED -- Low-Power BOR is disabled
pragma target IESO          DISABLED -- Internal/External Switchover Mode is disabled
pragma target PWRTE         DISABLED -- power up timer
pragma target BROWNOUT      DISABLED -- no brownout detection
pragma target WDT           DISABLED -- Watchdog disabled
pragma target MCLR          EXTERNAL -- External reset
pragma target LVP           ENABLED  -- allow low-voltage programming
pragma target VOLTAGE       MAXIMUM  -- brown out voltage
pragma target CP            DISABLED -- Program memory code protection is disabled

OSCCON        = 0b1111_1100          -- Select PLL,3x, 16MHz internal oscillator

When a PIC is reset, all pins are set to input and are floating. A good practice is to use the weak pull-up feature of the PIC to pull the inputs high. When making a pin output the weak pull-up for that pin is disabled. For this PIC only port A has the weak pull-up feature and because of that we make port C output so that the pins are not floating.

-- Enable weak pull-up for port a and and set port c to output just to
-- have no floating input pins.
OPTION_REG_WPUEN = FALSE             -- Enable weak pull-up for port a.
WPUA          = 0b0011_1111          -- Weak-pull up for all inputs.
TRISC         = 0b0000_0000          -- Port c output.

Now include the Jallib USB library. Since we will send information back to the computer we want to format it nicely so we also include the Jallib print library. We will also define the pins including some aliases to make the program more readable.

-- Include serial library and print library for formatting print output.
include usb_serial
include print

-- Aliases for LEDs, active HIGH.
alias led_amber is pin_A5            -- On when connected.  
pin_A5_direction = output            -- Pin 2 of 14 pin DIP.
alias led_red is pin_C2                 
pin_C2_direction = output            -- Pin 8 of 14 pin DIP.
alias led_green is pin_C1
pin_C1_direction = output            -- Pin 9 of 14 pin DIP.

This program uses a few variables, one for the character that is received from the computer and two bit variable to hold the status of the Red and Green LED.

-- Variables.
var byte character
var bit red_value, green_value

Last but not least is the main part of the program which does the following:

• Initialize the usb library
• Initialize (clear) all LEDs
• Report if the PIC USB device is configured
• Keep the USB going by frequently calling the function usb_serial_flush()
  Note: The USB driver can also be used on an interrupt basis as described in the USB library and the USB sample programs. In that case the usb_serial_flush() is not required
• Handle the commands sent by the computer and control the LEDs accordingly. A single character command will toggle the status of the LED from on to off or the other way around
• Return the status of the controlled LED to the computer after a command was received
• Return an error message if an incorrect command was received

The main program then becomes as follows.

-- ------------- The main program starts here  ------------------------

-- Setup the USB serial library.
usb_serial_init()

-- LEDs off.
led_yellow = FALSE
red_value = FALSE
green_value = FALSE

forever loop
  
   -- Update Red and Green LEDs.
   led_red = red_value
   led_green = green_value
   
   -- Poll the usb ISR function  on a regular base, in order to serve 
   -- the USB requests
   usb_serial_flush()
   
   -- Check if USB device has been configured by the host.
   if ( usb_cdc_line_status() !=  0x00 )  then
      led_yellow = TRUE   
   else
      led_yellow = FALSE  
   end if
   
   -- Check for input character. If OK, toggle led value.
   if usb_serial_read(character) then
      if (character == "R") | (character == "r") then
         red_value = !red_value
         if red_value then 
           print_string(usb_serial_data, "Red LED is on.")
         else
           print_string(usb_serial_data, "Red LED is off.")
         end if
      elsif (character == "G") | (character == "g") then  
         green_value = !green_value
         if green_value then 
           print_string(usb_serial_data, "Green LED is on.")
         else
           print_string(usb_serial_data, "Green LED is off.")
         end if
      else
         print_string(usb_serial_data, "Unsupported command.")
      end if
      print_crlf(usb_serial_data)
   end if

end loop

In this video you can see the program in action. Commands are entered in the terminal emulation program, LEDs are switched on and off and the response of the PIC is returned to the computer. Some additional info that is worth mentioning:

• In order to initialize the PIC as USB device you have to enable RTS/CTS
• The USB serial baudrate and number of bits is not relevant
• Since we are using single character commands make sure to disable sending carriage return and/or linefeed after the character was entered, otherwise the PIC will return that as an unsupported command.