From dcfe43860be2daf118e81a59029a34f018926ae5 Mon Sep 17 00:00:00 2001 From: James McKenzie Date: Mon, 15 Dec 2014 12:10:09 +0000 Subject: fish --- .gitignore | 5 + Makefile | 41 +++ clock.c | 182 ++++++++++++ lib_ws2812.c | 168 +++++++++++ lib_ws2812.h | 64 ++++ project.h | 47 +++ prototypes.h | 30 ++ stdio.c | 23 ++ usb_serial.c | 940 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ usb_serial.h | 124 ++++++++ util.c | 13 + 11 files changed, 1637 insertions(+) create mode 100644 .gitignore create mode 100644 Makefile create mode 100644 clock.c create mode 100644 lib_ws2812.c create mode 100644 lib_ws2812.h create mode 100644 project.h create mode 100644 prototypes.h create mode 100644 stdio.c create mode 100644 usb_serial.c create mode 100644 usb_serial.h create mode 100644 util.c diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d762bcb --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +*.d +*~ +*.o +clock +clock.hex diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..db58fbf --- /dev/null +++ b/Makefile @@ -0,0 +1,41 @@ +CSRCS= lib_ws2812.c clock.c util.c stdio.c usb_serial.c +SSRCS= +CC=avr-gcc -mmcu=atmega32u4 +PROJECT=clock +HEX=${PROJECT}.hex + +AVRDUDE=avrdude + +CPPFLAGS= +CPP=${CC} -E + +CFLAGS=-O2 -MP -MD -Wall -Werror -Wno-unused + +OBJS=${CSRCS:%.c=%.o} ${SSRCS:%.S=%.o} + +default: ${HEX} + +clean: + +${PROJECT}:${OBJS} + ${CC} -o $@ ${OBJS} + +${HEX}: ${PROJECT} + avr-objcopy -O ihex -R .eeprom $< $@ + +program: ${HEX} + ${AVRDUDE} -F -V -c usbasp -p ATMEGA32U4 -P usb -U flash:w:$< + #${AVRDUDE} -F -V -c avrispmkII -p ATMEGA32U4 -P usb -U flash:w:$< + + +protos: + echo -n > prototypes.h + cproto -E "${CPP}" ${CPPFLAGS} -DPROTOTYPING ${CSRCS} > prototypes.h.tmp + mv prototypes.h.tmp prototypes.h + +clean: + /bin/rm -f ${PROJECT} ${HEX} ${OBJS} *~ *.d + + +-include ${CSRCS:%.c=%.d} + diff --git a/clock.c b/clock.c new file mode 100644 index 0000000..66b278b --- /dev/null +++ b/clock.c @@ -0,0 +1,182 @@ +/* +* Light_WS2812 library example - RGB_blinky +* +* cycles one LED through red, green, blue +* +* This example is configured for a ATtiny85 with PLL clock fuse set and +* the WS2812 string connected to PB4. +*/ + +#include "project.h" + + +#define N_COLORS (288*2) +#define N_LEDS 24 + + +struct RGB led[N_LEDS]; + + + +static uint32_t ticks; /* 4 ticks per second */ + + +static void +do_hand (int w, uint8_t r, uint8_t g, uint8_t b) +{ + int i, j; + + for (i = 0; w >= 50; ++i, w -= 50); + + i %= N_LEDS; + j = i + 1; + j %= N_LEDS; + + led[i].r += (r * (49 - w)) / 49; + led[i].g += (g * (49 - w)) / 49; + led[i].b += (b * (49 - w)) / 49; + + led[j].r += (r * w) / 49; + led[j].g += (g * w) / 49; + led[j].b += (b * w) / 49; + +} + + +static void +tick (void) +{ + uint32_t r; + ticks++; + + + + if ((ticks%20)<10) { + PORTD&=~(1<<5); + } else { + PORTD|=1<<5; + } + + + memset (led, 0, sizeof (led)); + + r = ticks % 1200; + + do_hand (r, 255, 0, 0); + + r = (ticks / 60) % 1200; + + do_hand (r, 0, 255, 0); + + r = (ticks / 720) % 1200; + + + + do_hand (r, 0, 0, 255); + + ws2812_setleds (led, N_LEDS); + +} + +static void off(void) +{ + memset (led, 0, sizeof (led)); + ws2812_setleds (led, N_LEDS); +} + +int get_int(char *buf) +{ +int r; + +r=buf[0]-'0'; +r*=10; +r+=buf[1]-'0'; + +return r; +} + + +static void command_dispatch(char *buf) +{ +uint32_t r=ticks/20; +int h,m,s; + +if ((buf[2]==':') && (buf[5]==':')) { + h=get_int(buf); + m=get_int(buf+3); + s=get_int(buf+6); + + r=h; + r*=60; + r+=m; + r*=60; + r+=s; + ticks=r*20; +} + + +h=r/3600; +r -= h*3600; +m=r/60; +r -= m*60; +s=r; +printf("%02d.%02d.%02d\n",h,m,s); +} + + + +static void serial_dispatch(void) +{ +static char buf[64]; +static int bptr=0; + +int r=usb_serial_getchar(); +if (r==-1) return; + + +if (r==10) { + buf[bptr]=0; + command_dispatch(buf); + bptr=0; + return; +} + +buf[bptr++]=r; + +if (bptr==(sizeof(buf) -1 )) { + bptr=0; + return; +} +} + + + +int +main (void) +{ + int i, j, k; + + setup_clocks (); + off(); + stdio_init (); + + + DDRD|=1<<5; + + ticks=0; + ticks*=60; + ticks+=30; + ticks*=60; + ticks+=15; + ticks*=20; + + + + + while (1) + { + tick (); + serial_dispatch(); + _delay_ms (50); // wait for 500ms. + } +} diff --git a/lib_ws2812.c b/lib_ws2812.c new file mode 100644 index 0000000..7f29425 --- /dev/null +++ b/lib_ws2812.c @@ -0,0 +1,168 @@ +/* +* light weight WS2812 lib V2.0b +* +* Controls WS2811/WS2812/WS2812B RGB-LEDs +* Author: Tim (cpldcpu@gmail.com) +* +* Jan 18th, 2014 v2.0b Initial Version +* +* License: GNU GPL v2 (see License.txt) +*/ + +#include "project.h" + +void inline +ws2812_setleds (struct RGB *ledarray, uint16_t leds) +{ + ws2812_setleds_pin (ledarray, leds, _BV (WS2812_PIN)); +} + +void inline +ws2812_setleds_pin (struct RGB *ledarray, uint16_t leds, uint8_t pinmask) +{ + WS2812_DDRREG |= pinmask; // Enable DDR + ws2812_sendarray_mask ((uint8_t *) ledarray, leds + leds + leds, pinmask); + _delay_us (50); +} + +void +ws2812_sendarray (uint8_t * data, uint16_t datlen) +{ + ws2812_sendarray_mask (data, datlen, _BV (WS2812_PIN)); +} + +/* + This routine writes an array of bytes with RGB values to the Dataout pin + using the fast 800kHz clockless WS2811/2812 protocol. +*/ + +// Timing in ns +#define w_zeropulse 350 +#define w_onepulse 900 +#define w_totalperiod 1250 + +// Fixed cycles used by the inner loop +#define w_fixedlow 2 +#define w_fixedhigh 4 +#define w_fixedtotal 8 + +// Insert NOPs to match the timing, if possible +#define w_zerocycles (((F_CPU/1000)*w_zeropulse )/1000000) +#define w_onecycles (((F_CPU/1000)*w_onepulse +500000)/1000000) +#define w_totalcycles (((F_CPU/1000)*w_totalperiod +500000)/1000000) + +// w1 - nops between rising edge and falling edge - low +#define w1 (w_zerocycles-w_fixedlow) +// w2 nops between fe low and fe high +#define w2 (w_onecycles-w_fixedhigh-w1) +// w3 nops to complete loop +#define w3 (w_totalcycles-w_fixedtotal-w1-w2) + +#if w1>0 +#define w1_nops w1 +#else +#define w1_nops 0 +#endif + +// The only critical timing parameter is the minimum pulse length of the "0" +// Warn or throw error if this timing can not be met with current F_CPU settings. +#define w_lowtime ((w1_nops+w_fixedlow)*1000000)/(F_CPU/1000) +#if w_lowtime>550 +#error "Light_ws2812: Sorry, the clock speed is too low. Did you set F_CPU correctly?" +#elif w_lowtime>450 +#warning "Light_ws2812: The timing is critical and may only work on WS2812B, not on WS2812(S)." +#warning "Please consider a higher clockspeed, if possible" +#endif + +#if w2>0 +#define w2_nops w2 +#else +#define w2_nops 0 +#endif + +#if w3>0 +#define w3_nops w3 +#else +#define w3_nops 0 +#endif + +#define w_nop1 "nop \n\t" +#define w_nop2 "rjmp .+0 \n\t" +#define w_nop4 w_nop2 w_nop2 +#define w_nop8 w_nop4 w_nop4 +#define w_nop16 w_nop8 w_nop8 + +void inline +ws2812_sendarray_mask (uint8_t * data, uint16_t datlen, uint8_t maskhi) +{ + uint8_t curbyte, ctr, masklo; + uint8_t sreg_prev; + + masklo = ~maskhi & WS2812_PORTREG; + maskhi |= WS2812_PORTREG; + sreg_prev = SREG; + cli (); + + while (datlen--) + { + curbyte = *data++; + + asm volatile (" ldi %0,8 \n\t" "loop%=: \n\t" " out %2,%3 \n\t" // '1' [01] '0' [01] - re +#if (w1_nops&1) + w_nop1 +#endif +#if (w1_nops&2) + w_nop2 +#endif +#if (w1_nops&4) + w_nop4 +#endif +#if (w1_nops&8) + w_nop8 +#endif +#if (w1_nops&16) + w_nop16 +#endif + " sbrs %1,7 \n\t" // '1' [03] '0' [02] + " out %2,%4 \n\t" // '1' [--] '0' [03] - fe-low + " lsl %1 \n\t" // '1' [04] '0' [04] +#if (w2_nops&1) + w_nop1 +#endif +#if (w2_nops&2) + w_nop2 +#endif +#if (w2_nops&4) + w_nop4 +#endif +#if (w2_nops&8) + w_nop8 +#endif +#if (w2_nops&16) + w_nop16 +#endif + " out %2,%4 \n\t" // '1' [+1] '0' [+1] - fe-high +#if (w3_nops&1) + w_nop1 +#endif +#if (w3_nops&2) + w_nop2 +#endif +#if (w3_nops&4) + w_nop4 +#endif +#if (w3_nops&8) + w_nop8 +#endif +#if (w3_nops&16) + w_nop16 +#endif + " dec %0 \n\t" // '1' [+2] '0' [+2] + " brne loop%=\n\t" // '1' [+3] '0' [+4] + :"=&d" (ctr):"r" (curbyte), + "I" (_SFR_IO_ADDR (WS2812_PORTREG)), "r" (maskhi), + "r" (masklo)); + } + + SREG = sreg_prev; +} diff --git a/lib_ws2812.h b/lib_ws2812.h new file mode 100644 index 0000000..2142fa1 --- /dev/null +++ b/lib_ws2812.h @@ -0,0 +1,64 @@ +/* + * light weight WS2812 lib include + * + * Version 2.0a3 - Jan 18th 2014 + * Author: Tim (cpldcpu@gmail.com) + * + * Please do not change this file! All configuration is handled in "ws2812_config.h" + * + * License: GNU GPL v2 (see License.txt) + + + */ + +#ifndef LIGHT_WS2812_H_ +#define LIGHT_WS2812_H_ + +/* + * Structure of the LED array + */ + +struct RGB +{ + uint8_t g; + uint8_t r; + uint8_t b; +}; + +/* User Interface + * + * Input: + * ledarray: An array of GRB data describing the LED colors + * number_of_leds: The number of LEDs to write + * pinmask (optional): Bitmask describing the output bin. e.g. _BV(PB0) + * + * The functions will perform the following actions: + * - Set the data-out pin as output + * - Send out the LED data + * - Wait 50µs to reset the LEDs + */ + +void ws2812_setleds (struct RGB *ledarray, uint16_t number_of_leds); +void ws2812_setleds_pin (struct RGB *ledarray, uint16_t number_of_leds, + uint8_t pinmask); + +/* + * Old interface / Internal functions + * + * The functions take a byte-array and send to the data output as WS2812 bitstream. + * The length is the number of bytes to send - three per LED. + */ + +void ws2812_sendarray (uint8_t * array, uint16_t length); +void ws2812_sendarray_mask (uint8_t * array, uint16_t length, + uint8_t pinmask); + + +/* + * Internal defines + */ + +#define CONCAT(a, b) a ## b +#define CONCAT_EXP(a, b) CONCAT(a, b) + + +#endif /* LIGHT_WS2812_H_ */ diff --git a/project.h b/project.h new file mode 100644 index 0000000..779b00c --- /dev/null +++ b/project.h @@ -0,0 +1,47 @@ +#define F_CPU 8000000 + + +#ifdef PROTOTYPING +#define NOPROTO static +#define inline +//delay.h is broken we need to look after it +#define __OPTIMIZE__ +#else +#define NOPROTO +#endif + + +#include +#include +#include +#include +#include +#include + +#ifdef PROTOTYPING +#define _delay_ms static _delay_ms +#define _delay_us static _delay_us +#define _delay_loop_1 static _delay_loop_1 +#define _delay_loop_2 static _delay_loop_2 +#endif + +#define __DELAY_BACKWARD_COMPATIBLE__ + +#include + +#ifdef PROTOTYPING +#undef _delay_loop_2 +#undef _delay_loop_1 +#undef _delay_us +#undef _delay_ms +#endif + + +#define WS2812_PORTREG PORTC +#define WS2812_DDRREG DDRC +#define WS2812_PIN 6 + +#include "lib_ws2812.h" +#define NOUNUSED __attribute__((unused)) + +#include "prototypes.h" diff --git a/prototypes.h b/prototypes.h new file mode 100644 index 0000000..eeaeb5c --- /dev/null +++ b/prototypes.h @@ -0,0 +1,30 @@ +/* lib_ws2812.c */ +void ws2812_setleds(struct RGB *ledarray, uint16_t leds); +void ws2812_setleds_pin(struct RGB *ledarray, uint16_t leds, uint8_t pinmask); +void ws2812_sendarray(uint8_t *data, uint16_t datlen); +void ws2812_sendarray_mask(uint8_t *data, uint16_t datlen, uint8_t maskhi); +/* clock.c */ +int get_int(char *buf); +int main(void); +/* util.c */ +void setup_clocks(void); +/* stdio.c */ +void stdio_init(void); +/* usb_serial.c */ +void usb_init(void); +uint8_t usb_configured(void); +int16_t usb_serial_getchar(void); +uint8_t usb_serial_available(void); +void usb_serial_flush_input(void); +int8_t usb_serial_putchar(uint8_t c); +int8_t usb_serial_putchar_nowait(uint8_t c); +int8_t usb_serial_write(const uint8_t *buffer, uint16_t size); +void usb_serial_flush_output(void); +uint32_t usb_serial_get_baud(void); +uint8_t usb_serial_get_stopbits(void); +uint8_t usb_serial_get_paritytype(void); +uint8_t usb_serial_get_numbits(void); +uint8_t usb_serial_get_control(void); +int8_t usb_serial_set_control(uint8_t signals); +void __vector_10(void); +void __vector_11(void); diff --git a/stdio.c b/stdio.c new file mode 100644 index 0000000..db54136 --- /dev/null +++ b/stdio.c @@ -0,0 +1,23 @@ +#include "project.h" + +static int +stdio_uart_putchar (char var, FILE * stream) +{ + if (var == '\n') + usb_serial_putchar_nowait ('\r'); + usb_serial_putchar_nowait (var); + return 0; +} + + +static FILE stdio_uart_stdout = +FDEV_SETUP_STREAM (stdio_uart_putchar, NULL, _FDEV_SETUP_WRITE); + +void +stdio_init (void) +{ + stdout = &stdio_uart_stdout; + usb_init(); +// while (!usb_configured()) /* wait */ ; + usb_serial_flush_input(); +} diff --git a/usb_serial.c b/usb_serial.c new file mode 100644 index 0000000..7d83076 --- /dev/null +++ b/usb_serial.c @@ -0,0 +1,940 @@ +/* USB Serial Example for Teensy USB Development Board + * http://www.pjrc.com/teensy/usb_serial.html + * Copyright (c) 2008,2010,2011 PJRC.COM, LLC + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +// Version 1.0: Initial Release +// Version 1.1: support Teensy++ +// Version 1.2: fixed usb_serial_available +// Version 1.3: added transmit bandwidth test +// Version 1.4: added usb_serial_write +// Version 1.5: add support for Teensy 2.0 +// Version 1.6: fix zero length packet bug +// Version 1.7: fix usb_serial_set_control + +#include "project.h" + +#define USB_SERIAL_PRIVATE_INCLUDE +#include "usb_serial.h" + + +/************************************************************************** + * + * Configurable Options + * + **************************************************************************/ + +// You can change these to give your code its own name. On Windows, +// these are only used before an INF file (driver install) is loaded. +#define STR_MANUFACTURER L"Me" +#define STR_PRODUCT L"Clock" + +// All USB serial devices are supposed to have a serial number +// (according to Microsoft). On windows, a new COM port is created +// for every unique serial/vendor/product number combination. If +// you program 2 identical boards with 2 different serial numbers +// and they are assigned COM7 and COM8, each will always get the +// same COM port number because Windows remembers serial numbers. +// +// On Mac OS-X, a device file is created automatically which +// incorperates the serial number, eg, /dev/cu-usbmodem12341 +// +// Linux by default ignores the serial number, and creates device +// files named /dev/ttyACM0, /dev/ttyACM1... in the order connected. +// Udev rules (in /etc/udev/rules.d) can define persistent device +// names linked to this serial number, as well as permissions, owner +// and group settings. +#define STR_SERIAL_NUMBER L"12345" + +// Mac OS-X and Linux automatically load the correct drivers. On +// Windows, even though the driver is supplied by Microsoft, an +// INF file is needed to load the driver. These numbers need to +// match the INF file. +#define VENDOR_ID 0x16C0 +#define PRODUCT_ID 0x047A + +// When you write data, it goes into a USB endpoint buffer, which +// is transmitted to the PC when it becomes full, or after a timeout +// with no more writes. Even if you write in exactly packet-size +// increments, this timeout is used to send a "zero length packet" +// that tells the PC no more data is expected and it should pass +// any buffered data to the application that may be waiting. If +// you want data sent immediately, call usb_serial_flush_output(). +#define TRANSMIT_FLUSH_TIMEOUT 5 /* in milliseconds */ + +// If the PC is connected but not "listening", this is the length +// of time before usb_serial_getchar() returns with an error. This +// is roughly equivilant to a real UART simply transmitting the +// bits on a wire where nobody is listening, except you get an error +// code which you can ignore for serial-like discard of data, or +// use to know your data wasn't sent. +#define TRANSMIT_TIMEOUT 25 /* in milliseconds */ + +// USB devices are supposed to implment a halt feature, which is +// rarely (if ever) used. If you comment this line out, the halt +// code will be removed, saving 116 bytes of space (gcc 4.3.0). +// This is not strictly USB compliant, but works with all major +// operating systems. +#define SUPPORT_ENDPOINT_HALT + + + +/************************************************************************** + * + * Endpoint Buffer Configuration + * + **************************************************************************/ + +// These buffer sizes are best for most applications, but perhaps if you +// want more buffering on some endpoint at the expense of others, this +// is where you can make such changes. The AT90USB162 has only 176 bytes +// of DPRAM (USB buffers) and only endpoints 3 & 4 can double buffer. + +#define ENDPOINT0_SIZE 16 +#define CDC_ACM_ENDPOINT 2 +#define CDC_RX_ENDPOINT 3 +#define CDC_TX_ENDPOINT 4 +#if defined(__AVR_AT90USB162__) +#define CDC_ACM_SIZE 16 +#define CDC_ACM_BUFFER EP_SINGLE_BUFFER +#define CDC_RX_SIZE 32 +#define CDC_RX_BUFFER EP_DOUBLE_BUFFER +#define CDC_TX_SIZE 32 +#define CDC_TX_BUFFER EP_DOUBLE_BUFFER +#else +#define CDC_ACM_SIZE 16 +#define CDC_ACM_BUFFER EP_SINGLE_BUFFER +#define CDC_RX_SIZE 64 +#define CDC_RX_BUFFER EP_DOUBLE_BUFFER +#define CDC_TX_SIZE 64 +#define CDC_TX_BUFFER EP_DOUBLE_BUFFER +#endif + +static const uint8_t PROGMEM endpoint_config_table[] = { + 0, + 1, EP_TYPE_INTERRUPT_IN, EP_SIZE(CDC_ACM_SIZE) | CDC_ACM_BUFFER, + 1, EP_TYPE_BULK_OUT, EP_SIZE(CDC_RX_SIZE) | CDC_RX_BUFFER, + 1, EP_TYPE_BULK_IN, EP_SIZE(CDC_TX_SIZE) | CDC_TX_BUFFER +}; + + +/************************************************************************** + * + * Descriptor Data + * + **************************************************************************/ + +// Descriptors are the data that your computer reads when it auto-detects +// this USB device (called "enumeration" in USB lingo). The most commonly +// changed items are editable at the top of this file. Changing things +// in here should only be done by those who've read chapter 9 of the USB +// spec and relevant portions of any USB class specifications! + +const static uint8_t PROGMEM device_descriptor[] = { + 18, // bLength + 1, // bDescriptorType + 0x00, 0x02, // bcdUSB + 2, // bDeviceClass + 0, // bDeviceSubClass + 0, // bDeviceProtocol + ENDPOINT0_SIZE, // bMaxPacketSize0 + LSB(VENDOR_ID), MSB(VENDOR_ID), // idVendor + LSB(PRODUCT_ID), MSB(PRODUCT_ID), // idProduct + 0x00, 0x01, // bcdDevice + 1, // iManufacturer + 2, // iProduct + 3, // iSerialNumber + 1 // bNumConfigurations +}; + +#define CONFIG1_DESC_SIZE (9+9+5+5+4+5+7+9+7+7) +const static uint8_t PROGMEM config1_descriptor[CONFIG1_DESC_SIZE] = { + // configuration descriptor, USB spec 9.6.3, page 264-266, Table 9-10 + 9, // bLength; + 2, // bDescriptorType; + LSB(CONFIG1_DESC_SIZE), // wTotalLength + MSB(CONFIG1_DESC_SIZE), + 2, // bNumInterfaces + 1, // bConfigurationValue + 0, // iConfiguration + 0xC0, // bmAttributes + 50, // bMaxPower + // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12 + 9, // bLength + 4, // bDescriptorType + 0, // bInterfaceNumber + 0, // bAlternateSetting + 1, // bNumEndpoints + 0x02, // bInterfaceClass + 0x02, // bInterfaceSubClass + 0x01, // bInterfaceProtocol + 0, // iInterface + // CDC Header Functional Descriptor, CDC Spec 5.2.3.1, Table 26 + 5, // bFunctionLength + 0x24, // bDescriptorType + 0x00, // bDescriptorSubtype + 0x10, 0x01, // bcdCDC + // Call Management Functional Descriptor, CDC Spec 5.2.3.2, Table 27 + 5, // bFunctionLength + 0x24, // bDescriptorType + 0x01, // bDescriptorSubtype + 0x01, // bmCapabilities + 1, // bDataInterface + // Abstract Control Management Functional Descriptor, CDC Spec 5.2.3.3, Table 28 + 4, // bFunctionLength + 0x24, // bDescriptorType + 0x02, // bDescriptorSubtype + 0x06, // bmCapabilities + // Union Functional Descriptor, CDC Spec 5.2.3.8, Table 33 + 5, // bFunctionLength + 0x24, // bDescriptorType + 0x06, // bDescriptorSubtype + 0, // bMasterInterface + 1, // bSlaveInterface0 + // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13 + 7, // bLength + 5, // bDescriptorType + CDC_ACM_ENDPOINT | 0x80, // bEndpointAddress + 0x03, // bmAttributes (0x03=intr) + CDC_ACM_SIZE, 0, // wMaxPacketSize + 64, // bInterval + // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12 + 9, // bLength + 4, // bDescriptorType + 1, // bInterfaceNumber + 0, // bAlternateSetting + 2, // bNumEndpoints + 0x0A, // bInterfaceClass + 0x00, // bInterfaceSubClass + 0x00, // bInterfaceProtocol + 0, // iInterface + // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13 + 7, // bLength + 5, // bDescriptorType + CDC_RX_ENDPOINT, // bEndpointAddress + 0x02, // bmAttributes (0x02=bulk) + CDC_RX_SIZE, 0, // wMaxPacketSize + 0, // bInterval + // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13 + 7, // bLength + 5, // bDescriptorType + CDC_TX_ENDPOINT | 0x80, // bEndpointAddress + 0x02, // bmAttributes (0x02=bulk) + CDC_TX_SIZE, 0, // wMaxPacketSize + 0 // bInterval +}; + +// If you're desperate for a little extra code memory, these strings +// can be completely removed if iManufacturer, iProduct, iSerialNumber +// in the device desciptor are changed to zeros. +struct usb_string_descriptor_struct { + uint8_t bLength; + uint8_t bDescriptorType; + int16_t wString[]; +}; +const static struct usb_string_descriptor_struct PROGMEM string0 = { + 4, + 3, + {0x0409} +}; +const static struct usb_string_descriptor_struct PROGMEM string1 = { + sizeof(STR_MANUFACTURER), + 3, + STR_MANUFACTURER +}; +const static struct usb_string_descriptor_struct PROGMEM string2 = { + sizeof(STR_PRODUCT), + 3, + STR_PRODUCT +}; +const static struct usb_string_descriptor_struct PROGMEM string3 = { + sizeof(STR_SERIAL_NUMBER), + 3, + STR_SERIAL_NUMBER +}; + +// This table defines which descriptor data is sent for each specific +// request from the host (in wValue and wIndex). +const static struct descriptor_list_struct { + uint16_t wValue; + uint16_t wIndex; + const uint8_t *addr; + uint8_t length; +} PROGMEM descriptor_list[] = { + {0x0100, 0x0000, device_descriptor, sizeof(device_descriptor)}, + {0x0200, 0x0000, config1_descriptor, sizeof(config1_descriptor)}, + {0x0300, 0x0000, (const uint8_t *)&string0, 4}, + {0x0301, 0x0409, (const uint8_t *)&string1, sizeof(STR_MANUFACTURER)}, + {0x0302, 0x0409, (const uint8_t *)&string2, sizeof(STR_PRODUCT)}, + {0x0303, 0x0409, (const uint8_t *)&string3, sizeof(STR_SERIAL_NUMBER)} +}; +#define NUM_DESC_LIST (sizeof(descriptor_list)/sizeof(struct descriptor_list_struct)) + + +/************************************************************************** + * + * Variables - these are the only non-stack RAM usage + * + **************************************************************************/ + +// zero when we are not configured, non-zero when enumerated +static volatile uint8_t usb_configuration=0; + +// the time remaining before we transmit any partially full +// packet, or send a zero length packet. +static volatile uint8_t transmit_flush_timer=0; +static uint8_t transmit_previous_timeout=0; + +// serial port settings (baud rate, control signals, etc) set +// by the PC. These are ignored, but kept in RAM. +static uint8_t cdc_line_coding[7]={0x00, 0xE1, 0x00, 0x00, 0x00, 0x00, 0x08}; +static uint8_t cdc_line_rtsdtr=0; + + +/************************************************************************** + * + * Public Functions - these are the API intended for the user + * + **************************************************************************/ + +// initialize USB serial +void usb_init(void) +{ + HW_CONFIG(); + USB_FREEZE(); // enable USB + PLL_CONFIG(); // config PLL, 16 MHz xtal + while (!(PLLCSR & (1< size) write_size = size; + size -= write_size; + + // write the packet + switch (write_size) { + #if (CDC_TX_SIZE == 64) + case 64: UEDATX = *buffer++; + case 63: UEDATX = *buffer++; + case 62: UEDATX = *buffer++; + case 61: UEDATX = *buffer++; + case 60: UEDATX = *buffer++; + case 59: UEDATX = *buffer++; + case 58: UEDATX = *buffer++; + case 57: UEDATX = *buffer++; + case 56: UEDATX = *buffer++; + case 55: UEDATX = *buffer++; + case 54: UEDATX = *buffer++; + case 53: UEDATX = *buffer++; + case 52: UEDATX = *buffer++; + case 51: UEDATX = *buffer++; + case 50: UEDATX = *buffer++; + case 49: UEDATX = *buffer++; + case 48: UEDATX = *buffer++; + case 47: UEDATX = *buffer++; + case 46: UEDATX = *buffer++; + case 45: UEDATX = *buffer++; + case 44: UEDATX = *buffer++; + case 43: UEDATX = *buffer++; + case 42: UEDATX = *buffer++; + case 41: UEDATX = *buffer++; + case 40: UEDATX = *buffer++; + case 39: UEDATX = *buffer++; + case 38: UEDATX = *buffer++; + case 37: UEDATX = *buffer++; + case 36: UEDATX = *buffer++; + case 35: UEDATX = *buffer++; + case 34: UEDATX = *buffer++; + case 33: UEDATX = *buffer++; + #endif + #if (CDC_TX_SIZE >= 32) + case 32: UEDATX = *buffer++; + case 31: UEDATX = *buffer++; + case 30: UEDATX = *buffer++; + case 29: UEDATX = *buffer++; + case 28: UEDATX = *buffer++; + case 27: UEDATX = *buffer++; + case 26: UEDATX = *buffer++; + case 25: UEDATX = *buffer++; + case 24: UEDATX = *buffer++; + case 23: UEDATX = *buffer++; + case 22: UEDATX = *buffer++; + case 21: UEDATX = *buffer++; + case 20: UEDATX = *buffer++; + case 19: UEDATX = *buffer++; + case 18: UEDATX = *buffer++; + case 17: UEDATX = *buffer++; + #endif + #if (CDC_TX_SIZE >= 16) + case 16: UEDATX = *buffer++; + case 15: UEDATX = *buffer++; + case 14: UEDATX = *buffer++; + case 13: UEDATX = *buffer++; + case 12: UEDATX = *buffer++; + case 11: UEDATX = *buffer++; + case 10: UEDATX = *buffer++; + case 9: UEDATX = *buffer++; + #endif + case 8: UEDATX = *buffer++; + case 7: UEDATX = *buffer++; + case 6: UEDATX = *buffer++; + case 5: UEDATX = *buffer++; + case 4: UEDATX = *buffer++; + case 3: UEDATX = *buffer++; + case 2: UEDATX = *buffer++; + default: + case 1: UEDATX = *buffer++; + case 0: break; + } + // if this completed a packet, transmit it now! + if (!(UEINTX & (1<= NUM_DESC_LIST) { + UECONX = (1< desc_length) len = desc_length; + do { + // wait for host ready for IN packet + do { + i = UEINTX; + } while (!(i & ((1<= 1 && i <= MAX_ENDPOINT) { + usb_send_in(); + UENUM = i; + if (bRequest == SET_FEATURE) { + UECONX = (1< + +// setup +void usb_init(void); // initialize everything +uint8_t usb_configured(void); // is the USB port configured + +// receiving data +int16_t usb_serial_getchar(void); // receive a character (-1 if timeout/error) +uint8_t usb_serial_available(void); // number of bytes in receive buffer +void usb_serial_flush_input(void); // discard any buffered input + +// transmitting data +int8_t usb_serial_putchar(uint8_t c); // transmit a character +int8_t usb_serial_putchar_nowait(uint8_t c); // transmit a character, do not wait +int8_t usb_serial_write(const uint8_t *buffer, uint16_t size); // transmit a buffer +void usb_serial_flush_output(void); // immediately transmit any buffered output + +// serial parameters +uint32_t usb_serial_get_baud(void); // get the baud rate +uint8_t usb_serial_get_stopbits(void); // get the number of stop bits +uint8_t usb_serial_get_paritytype(void);// get the parity type +uint8_t usb_serial_get_numbits(void); // get the number of data bits +uint8_t usb_serial_get_control(void); // get the RTS and DTR signal state +int8_t usb_serial_set_control(uint8_t signals); // set DSR, DCD, RI, etc + +// constants corresponding to the various serial parameters +#define USB_SERIAL_DTR 0x01 +#define USB_SERIAL_RTS 0x02 +#define USB_SERIAL_1_STOP 0 +#define USB_SERIAL_1_5_STOP 1 +#define USB_SERIAL_2_STOP 2 +#define USB_SERIAL_PARITY_NONE 0 +#define USB_SERIAL_PARITY_ODD 1 +#define USB_SERIAL_PARITY_EVEN 2 +#define USB_SERIAL_PARITY_MARK 3 +#define USB_SERIAL_PARITY_SPACE 4 +#define USB_SERIAL_DCD 0x01 +#define USB_SERIAL_DSR 0x02 +#define USB_SERIAL_BREAK 0x04 +#define USB_SERIAL_RI 0x08 +#define USB_SERIAL_FRAME_ERR 0x10 +#define USB_SERIAL_PARITY_ERR 0x20 +#define USB_SERIAL_OVERRUN_ERR 0x40 + +// This file does not include the HID debug functions, so these empty +// macros replace them with nothing, so users can compile code that +// has calls to these functions. +#define usb_debug_putchar(c) +#define usb_debug_flush_output() + + + +// Everything below this point is only intended for usb_serial.c +#ifdef USB_SERIAL_PRIVATE_INCLUDE +#include +#include +#include + +#define EP_TYPE_CONTROL 0x00 +#define EP_TYPE_BULK_IN 0x81 +#define EP_TYPE_BULK_OUT 0x80 +#define EP_TYPE_INTERRUPT_IN 0xC1 +#define EP_TYPE_INTERRUPT_OUT 0xC0 +#define EP_TYPE_ISOCHRONOUS_IN 0x41 +#define EP_TYPE_ISOCHRONOUS_OUT 0x40 +#define EP_SINGLE_BUFFER 0x02 +#define EP_DOUBLE_BUFFER 0x06 +#define EP_SIZE(s) ((s) == 64 ? 0x30 : \ + ((s) == 32 ? 0x20 : \ + ((s) == 16 ? 0x10 : \ + 0x00))) + +#define MAX_ENDPOINT 4 + +#define LSB(n) (n & 255) +#define MSB(n) ((n >> 8) & 255) + +#if defined(__AVR_AT90USB162__) +#define HW_CONFIG() +#define PLL_CONFIG() (PLLCSR = ((1<