noisymime
/
ArduinoCore-avr
mirror of https://github.com/noisymime/ArduinoCore-avr.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Adding LilyPad Arduino USB.

This commit is contained in:
David A. Mellis 2012-11-01 10:45:50 -04:00
parent 42ca56fb83
commit cfec7864e9
9 changed files with 2289 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
boards.txt
View File

@ -316,6 +316,27 @@ bt.build.variant=eightanaloginputs
##############################################################
LilyPadUSB.name=LilyPad Arduino USB
LilyPadUSB.upload.protocol=avr109
LilyPadUSB.upload.maximum_size=28672
LilyPadUSB.upload.speed=57600
LilyPadUSB.upload.disable_flushing=true
LilyPadUSB.bootloader.low_fuses=0xff
LilyPadUSB.bootloader.high_fuses=0xd8
LilyPadUSB.bootloader.extended_fuses=0xce
LilyPadUSB.bootloader.path=caterina-LilyPadUSB
LilyPadUSB.bootloader.file=Caterina-LilyPadUSB.hex
LilyPadUSB.bootloader.unlock_bits=0x3F
LilyPadUSB.bootloader.lock_bits=0x2F
LilyPadUSB.build.mcu=atmega32u4
LilyPadUSB.build.f_cpu=8000000L
LilyPadUSB.build.vid=0x1B4F
LilyPadUSB.build.pid=0x9208
LilyPadUSB.build.core=arduino
LilyPadUSB.build.variant=leonardo
##############################################################
lilypad328.name=LilyPad Arduino w/ ATmega328
lilypad328.upload.protocol=arduino

259
bootloaders/caterina-LilyPadUSB/Caterina-LilyPadUSB.hex Executable file
View File

@ -0,0 +1,259 @@
:1070000055C000006EC000006CC000006AC00000E7
:1070100068C0000066C0000064C0000062C00000DC
:1070200060C000005EC00000FCC400005AC0000048
:1070300058C0000056C0000054C0000052C00000FC
:1070400050C000005DC000004CC000004AC00000FD
:1070500048C0000046C0000044C0000042C000001C
:1070600040C000003EC000003CC000003AC000002C
:1070700038C0000036C0000034C0000032C000003C
:1070800030C000002EC000002CC000002AC000004C
:1070900028C0000026C0000024C0000022C000005C
:1070A00020C000001EC000001CC0000011241FBE34
:1070B000CFEFDAE0DEBFCDBF11E0A0E0B1E0E2E467
:1070C000FFE702C005900D92A83BB107D9F711E088
:1070D000A8EBB1E001C01D92A13DB107E1F74FD38C
:1070E0002EC78ECFF89410926F001092810081E02D
:1070F00085BF15BE47985D9A289A0C9400000895A4
:107100001F920F920FB60F9211242F938F939F937C
:10711000EF93FF9310928500109284008091B80144
:107120009091B901009741F001979093B901809334
:10713000B801892B09F45D9A8091BA019091BB0145
:10714000009741F001979093BB018093BA01892B7E
:1071500009F4289A8091BE019091BF010196909305
:10716000BF018093BE01E0E0F0E0859194918F5FD4
:107170009F4F49F08091BC019091BD010196909381
:10718000BD018093BC01FF91EF919F918F912F9151
:107190000F900FBE0F901F90189584E08093E90028
:1071A0000DC08091E8008B778093E80003C08EB318
:1071B000882351F08091E80082FFF9CF8091E800A8
:1071C00085FFEFCF8091F1000895982F83E08093A1
:1071D000E9008091E80085FD0DC08091E8008E7780
:1071E0008093E80003C08EB3882369F08091E800A3
:1071F00080FFF9CF9093F1005D9884E690E0909342
:10720000B9018093B80108954F925F926F927F9277
:107210008F929F92AF92BF92CF92DF92EF92FF92A6
:107220000F931F93CF93DF9384E08093E9008091C5
:10723000E80082FF57C2289884E690E09093BB0153
:107240008093BA01AADF182F853481F48CEA9DE07F
:107250009093BD018093BC0107B600FCFDCFF99966
:10726000FECF81E180935700E89503C0843519F47F
:1072700094DF8DE00DC28C34E1F38035D1F3843797
:1072800021F484E4A2DF80E003C2813611F489E5B1
:10729000FFC18134B1F481DF182F7FDF90E0880FC8
:1072A000991FAA2797FDA095BA2F312F330F20E001
:1072B000442737FD4095542F822B932BA42BB52BBD
:1072C000B8C1803711F483E5E3C1833549F4C0E0E8
:1072D000D1E089917ADF21E0C730D207D1F7D9C157
:1072E000863521F481E371DF80E3D2C1833731F445
:1072F00087E86BDF85E969DF8EE1CAC18536B9F4BD
:10730000E0E0F0E093E085E090935700E89507B661
:1073100000FCFDCF80935700E89507B600FCFDCF39
:10732000E058FF4FA0E7E030FA0771F7A2CF8237AD
:1073300039F4E1E0F0E089E0809357008491A8C13E
:10734000863439F4E0E0F0E089E0809357008491DE
:107350009FC18E3439F4E3E0F0E089E08093570078
:10736000849196C1813539F4E2E0F0E089E08093C0
:10737000570084918DC1823631F489E526DF80E0A3
:1073800024DF80E885C1823419F0873609F0E5C032
:107390001092BD011092BC0100DF082FFEDEF82E16
:1073A000FCDE682E8554823008F071C1902F80E099
:1073B000CF2DD0E0C82BD92B10926F00173609F0D3
:1073C0004BC081E180935700E895DD24CC24C39421
:1073D0003FC0E090C101F090C2010091C301109143
:1073E000C401B6E46B16D9F4ED2DF0E0EE29FF29C7
:1073F000E4918E2FEADEDD2081F082E090E0A0E0D3
:10740000B0E0E80EF91E0A1F1B1FE092C101F092C6
:10741000C2010093C3011093C401DC2418C0D80139
:10742000C701B695A7959795879573D5CEDE82E06F
:1074300090E0A0E0B0E0E80EF91E0A1F1B1FE092EA
:10744000C101F092C2010093C3011093C4012197BE
:10745000209709F0BECF7DC08090C1019090C201FD
:10746000A090C301B090C40196E4691609F05DC014
:1074700083E0F40180935700E89507B600FCFDCF48
:1074800054C0F6E46F1661F5772031F1E090C10148
:10749000F090C2010091C3011091C4017EDED82E8C
:1074A000CC24852D90E08C299D29F7010C01409278
:1074B0005700E895112482E090E0A0E0B0E0E80EEB
:1074C000F91E0A1F1B1FE092C101F092C201009336
:1074D000C3011093C40102C060DE582E742423C07F
:1074E000E090C101F090C2010091C3011091C4016C
:1074F00016950795F794E79450DE682FC70111D5CC
:107500008091C1019091C201A091C301B091C401C9
:107510000296A11DB11D8093C1019093C201A09359
:10752000C301B093C401219704C055247724442497
:107530004394209709F0A5CF96E4691641F485E0BD
:10754000F40180935700E89507B600FCFDCF8DE06D
:107550003CDE82E080936F009CC0833471F4009124
:10756000C1011091C20119DE90E021E0F8010C0187
:1075700020935700E89511247CCE833619F5E090CE
:10758000C101F090C2010091C3011091C40105DE58
:10759000F701E16090E021E00C0120935700E895AD
:1075A000112482E090E0A0E0B0E0E80EF91E0A1F8E
:1075B0001B1FE092C101F092C2010093C30110931E
:1075C000C40157CE8D3661F4E091C101F091C20142
:1075D00085E080935700E89507B600FCFDCF49CEC3
:1075E000823551F4E091C101F091C20105911491ED
:1075F000812FEBDD802F4CC0843421F5E090C10158
:10760000F090C2010091C3011091C4011695079535
:10761000F794E794C2DD682FC70183D48091C1013C
:107620009091C201A091C301B091C4010296A11D25
:10763000B11D8093C1019093C201A093C301B09387
:10764000C40117CE843609F5E090C101F090C20163
:107650000091C3011091C401D801C701B695A79547
:107660009795879556D4B1DD82E090E0A0E0B0E038
:10767000E80EF91E0A1F1B1FE092C101F092C20121
:107680000093C3011093C40104C08B3111F08FE348
:107690009CDD83E08093E9009091E8008091E80010
:1076A0008E778093E80095FF04C010C08EB38823C6
:1076B000C9F08091E80080FFF9CF8091E8008E77D3
:1076C0008093E80003C08EB3882361F08091E800C6
:1076D00080FFF9CF84E08093E9008091E8008B7708
:1076E0008093E800DF91CF911F910F91FF90EF9071
:1076F000DF90CF90BF90AF909F908F907F906F90D2
:107700005F904F9008959091C901892F8F778132B2
:1077100049F58091CA018032A1F0813219F5913A80
:1077200009F58091E800877F8093E8008CE091E084
:1077300067E070E025D28091E8008B778093E800C5
:107740000895913279F48091E800877F8093E80072
:107750008CE091E067E070E077D28091E8008E776E
:107760008093E800089582E061EC42E0D1D083E0AC
:1077700061E842E1CDD084E060E842E1C9C01F93F6
:10778000209100081092000844B714BE88E10FB69B
:10779000F89480936000109260000FBE80E8E0E0F3
:1077A000F0E00FB6F89480936100E09361000FBEA3
:1077B00031E035BF92E095BF3F9A209A559A809369
:1077C00061001092610047985D9A289A1092890092
:1077D0008AEF8093880090936F0083E0809381000C
:1077E000859194918F5F9F4F11F03093C001942F3A
:1077F00041FF19C0809109012817A9F08093000862
:10780000789480911301882339F08091BE01909182
:10781000BF0188579140C8F310920008F89481E0A6
:10782000809313010CC090FF04C08091C001882395
:1078300051F493FF09C080910901281729F0809124
:10784000C001882309F04EDCD4D078941092BD0199
:107850001092BC011EEF20C0D7DC49D38091BC013F
:107860009091BD01815A9F4010F0109213018091B8
:10787000C5019091C60101969093C6018093C50100
:10788000292F97FF03C0512F591B252F220F28178F
:1078900010F4479801C0479A809113018823E1F6BC
:1078A0008091E00081608093E0001CDC80E090E04B
:1078B0001F910895FA01923049F0933061F09130B0
:1078C000F9F484E191E022E130E01EC086E291E02B
:1078D0002EE330E019C0882329F484E691E024E007
:1078E00030E012C0813029F488E691E022E230E0F5
:1078F0000BC0823029F48CE891E02AE230E004C029
:1079000080E090E020E030E091838083C901089519
:107910008093E9008091EB0081608093EB001092EE
:10792000ED006093EC004093ED008091EE00881F25
:107930008827881F08958091C90188238CF403C08B
:107940008EB38823B1F08091E80082FFF9CF809157
:10795000E8008B778093E80008958EB3882349F080
:107960008091E80080FFF9CF8091E8008E778093C6
:10797000E8000895EF92FF920F931F9345D04CD0EB
:1079800008ED10E0F80180818F7780838081806826
:10799000808380818F7D808319BC1EBA1092C701BD
:1079A00080EEE82EF12CF70180818B7F8083F80137
:1079B00080818160808380E060E042E0A9DFE1EEC9
:1079C000F0E080818E7F8083E2EEF0E08081816054
:1079D0008083808188608083F70180818E7F8083AF
:1079E000F8018081806180831F910F91FF90EF905B
:1079F0000895E7EDF0E08081816080838AE482BFB2
:107A000081E08093C801B6CFE8EDF0E080818E7F01
:107A100080831092E20008951092DA001092E10043
:107A200008951F920F920FB60F9211242F933F9338
:107A30004F935F936F937F938F939F93AF93BF9376
:107A4000EF93FF938091DA0080FF1AC08091D800F5
:107A500080FF16C08091DA008E7F8093DA008091DB
:107A6000D90080FF0AC019BC82E089BD09B400FEBC
:107A7000FDCF81E08EBB3AD203C019BC1EBA36D20C
:107A80008091E10080FF17C08091E20080FF13C069
:107A90008091E2008E7F8093E2008091E20080611D
:107AA0008093E2008091D80080628093D80019BC56
:107AB00085E08EBB1BD28091E10084FF2BC08091BA
:107AC000E20084FF27C019BC82E089BD09B400FE32
:107AD000FDCF8091D8008F7D8093D8008091E10008
:107AE0008F7E8093E1008091E2008F7E8093E200A0
:107AF0008091E20081608093E2008091C701882339
:107B000031F48091E30087FD02C081E001C084E090
:107B10008EBBECD18091E10083FF21C08091E20017
:107B200083FF1DC08091E100877F8093E10082E0A8
:107B30008EBB1092C7018091E1008E7F8093E1009F
:107B40008091E2008E7F8093E2008091E20080616C
:107B50008093E20080E060E042E0DADEC7D1FF918E
:107B6000EF91BF91AF919F918F917F916F915F91B5
:107B70004F913F912F910F900FBE0F901F9018952E
:107B80009C014091CF015091D0014617570718F43E
:107B9000F90190E044C06115710511F0AB01F8CF17
:107BA0008091E8008E778093E80040E050E0F0CFCD
:107BB0008EB3882309F444C0853009F443C0809112
:107BC000E80083FF02C081E008958091E80082FD13
:107BD00031C08091E80080FF22C08091F300909135
:107BE000F200782F60E0292F30E0262B372B07C0DA
:107BF00081918093F100415050402F5F3F4F4115DC
:107C0000510519F02830310598F390E028303105FE
:107C100009F491E08091E8008E778093E8004115A7
:107C2000510531F6992321F605C08EB3882341F022
:107C3000853041F08091E80082FFF7CF80E0089521
:107C400082E0089583E008959C016115710529F48F
:107C50008091E8008B778093E800F90126C08EB30D
:107C6000882391F1853091F18091E80083FF02C073
:107C700081E008958091E80082FFF1CF06C08091F5
:107C8000F10081936150704059F02091F300809190
:107C9000F200322F20E090E0822B932B892B79F792
:107CA0008091E8008B778093E80061157105B9F643
:107CB00005C08EB3882341F0853041F08091E80003
:107CC00080FFF7CF80E0089582E0089583E0089573
:107CD0000F931F93DF93CF9300D0CDB7DEB7E9ECBE
:107CE000F1E08091F100819381E0E13DF807C9F76F
:107CF0000ADD8091E80083FFE4C08091C901909182
:107D0000CA01953009F46DC0963040F4913081F18C
:107D1000913070F0933009F0D4C02AC0983009F443
:107D2000A3C0993009F4B2C0963009F0CAC07CC033
:107D3000803809F4C6C0823809F0C3C08091CD01F3
:107D400087708093E9008091EB001092E900209108
:107D5000E800277F2093E80090E025E0969587953E
:107D60002A95E1F781708093F1001092F10087C0AD
:107D7000882319F0823009F0A4C08F71823009F095
:107D8000A0C08091CB01882331F52091CD012770CF
:107D900009F497C02093E9008091EB0080FF1BC09D
:107DA000933021F48091EB00806213C08091EB004E
:107DB00080618093EB0081E090E002C0880F991F02
:107DC0002A95E2F78093EA001092EA008091EB0096
:107DD00088608093EB001092E9008091E800877F33
:107DE00051C0882309F06DC01091CB011F770FB7E8
:107DF000F8948091E800877F8093E8009CDD809173
:107E0000E80080FFFCCF8091E3008078812B809395
:107E1000E30080688093E300112311F482E001C045
:107E200083E08EBB0FBF4DC08058823008F049C040
:107E30008091CB019091CC016091CD01AE014F5F5B
:107E40005F4F38DDBC01009709F43BC08091E8002A
:107E5000877F8093E80089819A8192DE8091E80093
:107E60008B778093E8002DC0803859F58091E80029
:107E7000877F8093E8008091C7018093F100809113
:107E8000E8008E778093E80056DD1BC08823C9F494
:107E90009091CB019230A8F48091E800877F809385
:107EA000E8009093C70147DD8091C701882331F432
:107EB0008091E30087FD02C081E001C084E08EBBB9
:107EC00052DC8091E80083FF0AC08091EB00806261
:107ED0008093EB008091E800877F8093E8000F900B
:107EE0000F90CF91DF911F910F91089508951F93E7
:107EF0008EB3882361F01091E9001092E90080911F
:107F0000E80083FF01C0E4DE17701093E9001F91C1
:107F10000895F999FECF92BD81BDF89A992780B551
:107F20000895262FF999FECF1FBA92BD81BD20BDBD
:107F30000FB6F894FA9AF99A0FBE01960895F8943C
:027F4000FFCF71
:107F42004341544552494E41007700080000000069
:107F52000000080112011001020000084F1B0792E5
:107F620001000201000109023E0002010080320903
:107F72000400000102020100052400100104240291
:107F8200040524060001070582030800FF09040115
:107F920000020A0000000705040210000107058321
:107FA200021000010403090422034C0069006C0062
:107FB2007900500061006400550053004200200027
:107FC2002000200020002000200000002A0353008F
:107FD2007000610072006B00460075006E002000A8
:107FE20045006C0065006300740072006F006E0053
:087FF200690063007300000048
:040000030000700089
:00000001FF

780
bootloaders/caterina-LilyPadUSB/Caterina.c Executable file
View File

@ -0,0 +1,780 @@
/*
LUFA Library
Copyright (C) Dean Camera, 2011.
dean [at] fourwalledcubicle [dot] com
www.lufa-lib.org
*/
/*
Copyright 2011 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Permission to use, copy, modify, distribute, and sell this
software and its documentation for any purpose is hereby granted
without fee, provided that the above copyright notice appear in
all copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
/** \file
*
* Main source file for the CDC class bootloader. This file contains the complete bootloader logic.
*/
#define INCLUDE_FROM_CATERINA_C
#include "Caterina.h"
/** Contains the current baud rate and other settings of the first virtual serial port. This must be retained as some
* operating systems will not open the port unless the settings can be set successfully.
*/
static CDC_LineEncoding_t LineEncoding = { .BaudRateBPS = 0,
.CharFormat = CDC_LINEENCODING_OneStopBit,
.ParityType = CDC_PARITY_None,
.DataBits = 8 };
/** Current address counter. This stores the current address of the FLASH or EEPROM as set by the host,
* and is used when reading or writing to the AVRs memory (either FLASH or EEPROM depending on the issued
* command.)
*/
static uint32_t CurrAddress;
/** Flag to indicate if the bootloader should be running, or should exit and allow the application code to run
* via a watchdog reset. When cleared the bootloader will exit, starting the watchdog and entering an infinite
* loop until the AVR restarts and the application runs.
*/
static bool RunBootloader = true;
/* Pulse generation counters to keep track of the time remaining for each pulse type */
#define TX_RX_LED_PULSE_PERIOD 100
uint16_t TxLEDPulse = 0; // time remaining for Tx LED pulse
uint16_t RxLEDPulse = 0; // time remaining for Rx LED pulse
/* Bootloader timeout timer */
// MAH 8/15/12- change so timeouts work properly when the chip is running at 8MHz instead of 16.
#define TIMEOUT_PERIOD 4000
#define EXT_RESET_TIMEOUT_PERIOD 375
/*********************************************************************************************************
LilyPadUSB bootloader code
The LilyPadUSB bootloader has been changed to remove the 8-second delay after external reset which is in
the Leonardo. To enter the bootloader, the user should execute TWO external resets within 750 ms; that is,
press the reset button twice, quickly.\
Some other changes were made to allow this code to compile tightly enough to fit in the alloted 4k of
bootloader space.
*/
// MAH 8/15/12- added this flag to replace the bulky program memory reads to check for the presence of a sketch
// at the top of the memory space.
static bool sketchPresent = false;
// MAH 8/15/12- make this volatile, since we modify it in one place and read it in another, we want to make
// sure we're always working on the copy in memory and not an erroneous value stored in a cache somewhere.
// This variable stores the length of time we've been in the bootloader when waiting for the 8 second delay.
volatile uint16_t Timeout = 0;
// MAH 8/15/12- added this for delay during startup. Did not use existing Timeout value b/c it only increments
// when there's a sketch at the top of the memory.
volatile uint16_t resetTimeout = 0;
// MAH 8/15/12- let's make this an 8-bit value instead of 16- that saves on memory because 16-bit addition and
// comparison compiles to bulkier code. Note that this does *not* require a change to the Arduino core- we're
// just sort of ignoring the extra byte that the Arduino core puts at the next location.
uint8_t bootKey = 0x77;
volatile uint8_t *const bootKeyPtr = (volatile uint8_t *)0x0800;
// StartSketch() is called to clean up our mess before passing execution to the sketch.
void StartSketch(void)
{
cli();
/* Undo TIMER1 setup and clear the count before running the sketch */
TIMSK1 = 0;
TCCR1B = 0;
/* Relocate the interrupt vector table to the application section */
MCUCR = (1 << IVCE);
MCUCR = 0;
L_LED_OFF();
TX_LED_OFF();
RX_LED_OFF();
/* jump to beginning of application space */
__asm__ volatile("jmp 0x0000");
}
uint16_t LLEDPulse;
/** Main program entry point. This routine configures the hardware required by the bootloader, then continuously
* runs the bootloader processing routine until it times out or is instructed to exit.
*/
int main(void)
{
/* Save the value of the boot key memory before it is overwritten */
uint8_t bootKeyPtrVal = *bootKeyPtr;
*bootKeyPtr = 0;
/* Check the reason for the reset so we can act accordingly */
uint8_t mcusr_state = MCUSR; // store the initial state of the Status register
MCUSR = 0; // clear all reset flags
/* Watchdog may be configured with a 15 ms period so must disable it before going any further */
// MAH 8/15/12- I removed this because wdt_disable() is the first thing SetupHardware() does- why
// do it twice right in a row?
//wdt_disable();
/* Setup hardware required for the bootloader */
// MAH 8/15/12- Moved this up to before the bootloader go/no-go decision tree so I could use the
// timer in that decision tree. Removed the USBInit() call from it; if I'm not going to stay in
// the bootloader, there's no point spending the time initializing the USB.
// SetupHardware();
wdt_disable();
// Disable clock division
clock_prescale_set(clock_div_1);
// Relocate the interrupt vector table to the bootloader section
MCUCR = (1 << IVCE);
MCUCR = (1 << IVSEL);
LED_SETUP();
CPU_PRESCALE(0);
L_LED_OFF();
TX_LED_OFF();
RX_LED_OFF();
// Initialize TIMER1 to handle bootloader timeout and LED tasks.
// With 16 MHz clock and 1/64 prescaler, timer 1 is clocked at 250 kHz
// Our chosen compare match generates an interrupt every 1 ms.
// This interrupt is disabled selectively when doing memory reading, erasing,
// or writing since SPM has tight timing requirements.
OCR1AH = 0;
OCR1AL = 250;
TIMSK1 = (1 << OCIE1A); // enable timer 1 output compare A match interrupt
TCCR1B = ((1 << CS11) | (1 << CS10)); // 1/64 prescaler on timer 1 input
// MAH 8/15/12- this replaces bulky pgm_read_word(0) calls later on, to save memory.
if (pgm_read_word(0) != 0xFFFF) sketchPresent = true;
// MAH 26 Oct 2012- The "bootload or not?" section has been modified since the code released
// with Arduino 1.0.1. The simplest modification is the replacement of equivalence checks on
// the reset bits with masked checks, so if more than one reset occurs before the register is
// checked, the check doesn't fail and fall through to the bootloader unnecessarily.
// The second, more in depth modification addresses behavior after an external reset (i.e.,
// user pushes the reset button). The Leonardo treats all external resets as requests to
// re-enter the bootloader and wait for code to be loaded. It remains in bootloader mode for
// 8 seconds before continuing on to the sketch (if one is present). By defining RESET_DELAY
// equal to 1, this behavior will persist.
// However, if RESET_DELAY is defined to 0, the reset timeout before loading the sketch drops
// to 750ms. If, during that 750ms, another external reset occurs, THEN an 8-second delay
// in the bootloader will occur.
// This is the "no-8-second-delay" code. If this is the first time through the loop, we
// don't expect to see the bootKey in memory.
if ( (mcusr_state & (1<<EXTRF)) && (bootKeyPtrVal != bootKey) ) {
*bootKeyPtr = bootKey; // Put the bootKey in memory so if we get back to this
// point again, we know to jump into the bootloader
sei(); // Enable interrupts, so we can use timer1 to track our time in the bootloader
while (RunBootloader)
{
if (resetTimeout > EXT_RESET_TIMEOUT_PERIOD) // resetTimeout is getting incremeted
RunBootloader = false; // in the timer1 ISR.
}
// If we make it past that while loop, it's sketch loading time!
*bootKeyPtr = 0; // clear out the bootKey; from now on, we want to treat a reset like
// a normal reset.
cli(); // Disable interrupts, in case no sketch is present.
RunBootloader = true; // We want to hang out in the bootloader if no sketch is present.
if (sketchPresent) StartSketch(); // If a sketch is present, go! Otherwise, wait around
// in the bootloader until one is uploaded.
}
// On a power-on reset, we ALWAYS want to go to the sketch. If there is one.
// This is a place where the old code had an equivalence and now there is a mask.
else if ( (mcusr_state & (1<<PORF)) && sketchPresent) {
StartSketch();
}
// On a watchdog reset, if the bootKey isn't set, and there's a sketch, we should just
// go straight to the sketch.
// This is a place where the old code had an equivalence and now there is a mask.
else if ( (mcusr_state & (1<<WDRF) ) && (bootKeyPtrVal != bootKey) && sketchPresent) {
// If it looks like an "accidental" watchdog reset then start the sketch.
StartSketch();
}
/* Initialize USB Subsystem */
USB_Init();
/* Enable global interrupts so that the USB stack can function */
sei();
Timeout = 0;
while (RunBootloader)
{
CDC_Task();
USB_USBTask();
/* Time out and start the sketch if one is present */
if (Timeout > TIMEOUT_PERIOD)
RunBootloader = false;
// MAH 8/15/12- This used to be a function call- inlining it saves a few bytes.
LLEDPulse++;
uint8_t p = LLEDPulse >> 8;
if (p > 127)
p = 254-p;
p += p;
if (((uint8_t)LLEDPulse) > p)
L_LED_OFF();
else
L_LED_ON();
}
/* Disconnect from the host - USB interface will be reset later along with the AVR */
USB_Detach();
/* Jump to beginning of application space to run the sketch - do not reset */
StartSketch();
}
// Timer1 is set up to provide periodic interrupts. This is used to flicker the LEDs during
// programming as well as to generate the clock counts which determine how long the board should
// remain in bootloading mode.
ISR(TIMER1_COMPA_vect, ISR_BLOCK)
{
/* Reset counter */
TCNT1H = 0;
TCNT1L = 0;
/* Check whether the TX or RX LED one-shot period has elapsed. if so, turn off the LED */
if (TxLEDPulse && !(--TxLEDPulse))
TX_LED_OFF();
if (RxLEDPulse && !(--RxLEDPulse))
RX_LED_OFF();
resetTimeout++; // Needed for the "short reset delay" mode- governs the time the board waits
// for a second reset before loading the sketch.
if (pgm_read_word(0) != 0xFFFF)
Timeout++;
}
// MAH 29 Oct 2012 Nothing below this point has to change for the LilyPadUSB support
/** Event handler for the USB_ConfigurationChanged event. This configures the device's endpoints ready
* to relay data to and from the attached USB host.
*/
void EVENT_USB_Device_ConfigurationChanged(void)
{
/* Setup CDC Notification, Rx and Tx Endpoints */
Endpoint_ConfigureEndpoint(CDC_NOTIFICATION_EPNUM, EP_TYPE_INTERRUPT,
ENDPOINT_DIR_IN, CDC_NOTIFICATION_EPSIZE,
ENDPOINT_BANK_SINGLE);
Endpoint_ConfigureEndpoint(CDC_TX_EPNUM, EP_TYPE_BULK,
ENDPOINT_DIR_IN, CDC_TXRX_EPSIZE,
ENDPOINT_BANK_SINGLE);
Endpoint_ConfigureEndpoint(CDC_RX_EPNUM, EP_TYPE_BULK,
ENDPOINT_DIR_OUT, CDC_TXRX_EPSIZE,
ENDPOINT_BANK_SINGLE);
}
/** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
* the device from the USB host before passing along unhandled control requests to the library for processing
* internally.
*/
void EVENT_USB_Device_ControlRequest(void)
{
/* Ignore any requests that aren't directed to the CDC interface */
if ((USB_ControlRequest.bmRequestType & (CONTROL_REQTYPE_TYPE | CONTROL_REQTYPE_RECIPIENT)) !=
(REQTYPE_CLASS | REQREC_INTERFACE))
{
return;
}
/* Process CDC specific control requests */
switch (USB_ControlRequest.bRequest)
{
case CDC_REQ_GetLineEncoding:
if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
{
Endpoint_ClearSETUP();
/* Write the line coding data to the control endpoint */
Endpoint_Write_Control_Stream_LE(&LineEncoding, sizeof(CDC_LineEncoding_t));
Endpoint_ClearOUT();
}
break;
case CDC_REQ_SetLineEncoding:
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
{
Endpoint_ClearSETUP();
/* Read the line coding data in from the host into the global struct */
Endpoint_Read_Control_Stream_LE(&LineEncoding, sizeof(CDC_LineEncoding_t));
Endpoint_ClearIN();
}
break;
}
}
#if !defined(NO_BLOCK_SUPPORT)
/** Reads or writes a block of EEPROM or FLASH memory to or from the appropriate CDC data endpoint, depending
* on the AVR910 protocol command issued.
*
* \param[in] Command Single character AVR910 protocol command indicating what memory operation to perform
*/
static void ReadWriteMemoryBlock(const uint8_t Command)
{
uint16_t BlockSize;
char MemoryType;
bool HighByte = false;
uint8_t LowByte = 0;
BlockSize = (FetchNextCommandByte() << 8);
BlockSize |= FetchNextCommandByte();
MemoryType = FetchNextCommandByte();
if ((MemoryType != 'E') && (MemoryType != 'F'))
{
/* Send error byte back to the host */
WriteNextResponseByte('?');
return;
}
/* Disable timer 1 interrupt - can't afford to process nonessential interrupts
* while doing SPM tasks */
TIMSK1 = 0;
/* Check if command is to read memory */
if (Command == 'g')
{
/* Re-enable RWW section */
boot_rww_enable();
while (BlockSize--)
{
if (MemoryType == 'F')
{
/* Read the next FLASH byte from the current FLASH page */
#if (FLASHEND > 0xFFFF)
WriteNextResponseByte(pgm_read_byte_far(CurrAddress | HighByte));
#else
WriteNextResponseByte(pgm_read_byte(CurrAddress | HighByte));
#endif
/* If both bytes in current word have been read, increment the address counter */
if (HighByte)
CurrAddress += 2;
HighByte = !HighByte;
}
else
{
/* Read the next EEPROM byte into the endpoint */
WriteNextResponseByte(eeprom_read_byte((uint8_t*)(intptr_t)(CurrAddress >> 1)));
/* Increment the address counter after use */
CurrAddress += 2;
}
}
}
else
{
uint32_t PageStartAddress = CurrAddress;
if (MemoryType == 'F')
{
boot_page_erase(PageStartAddress);
boot_spm_busy_wait();
}
while (BlockSize--)
{
if (MemoryType == 'F')
{
/* If both bytes in current word have been written, increment the address counter */
if (HighByte)
{
/* Write the next FLASH word to the current FLASH page */
boot_page_fill(CurrAddress, ((FetchNextCommandByte() << 8) | LowByte));
/* Increment the address counter after use */
CurrAddress += 2;
}
else
{
LowByte = FetchNextCommandByte();
}
HighByte = !HighByte;
}
else
{
/* Write the next EEPROM byte from the endpoint */
eeprom_write_byte((uint8_t*)((intptr_t)(CurrAddress >> 1)), FetchNextCommandByte());
/* Increment the address counter after use */
CurrAddress += 2;
}
}
/* If in FLASH programming mode, commit the page after writing */
if (MemoryType == 'F')
{
/* Commit the flash page to memory */
boot_page_write(PageStartAddress);
/* Wait until write operation has completed */
boot_spm_busy_wait();
}
/* Send response byte back to the host */
WriteNextResponseByte('\r');
}
/* Re-enable timer 1 interrupt disabled earlier in this routine */
TIMSK1 = (1 << OCIE1A);
}
#endif
/** Retrieves the next byte from the host in the CDC data OUT endpoint, and clears the endpoint bank if needed
* to allow reception of the next data packet from the host.
*
* \return Next received byte from the host in the CDC data OUT endpoint
*/
static uint8_t FetchNextCommandByte(void)
{
/* Select the OUT endpoint so that the next data byte can be read */
Endpoint_SelectEndpoint(CDC_RX_EPNUM);
/* If OUT endpoint empty, clear it and wait for the next packet from the host */
while (!(Endpoint_IsReadWriteAllowed()))
{
Endpoint_ClearOUT();
while (!(Endpoint_IsOUTReceived()))
{
if (USB_DeviceState == DEVICE_STATE_Unattached)
return 0;
}
}
/* Fetch the next byte from the OUT endpoint */
return Endpoint_Read_8();
}
/** Writes the next response byte to the CDC data IN endpoint, and sends the endpoint back if needed to free up the
* bank when full ready for the next byte in the packet to the host.
*
* \param[in] Response Next response byte to send to the host
*/
static void WriteNextResponseByte(const uint8_t Response)
{
/* Select the IN endpoint so that the next data byte can be written */
Endpoint_SelectEndpoint(CDC_TX_EPNUM);
/* If IN endpoint full, clear it and wait until ready for the next packet to the host */
if (!(Endpoint_IsReadWriteAllowed()))
{
Endpoint_ClearIN();
while (!(Endpoint_IsINReady()))
{
if (USB_DeviceState == DEVICE_STATE_Unattached)
return;
}
}
/* Write the next byte to the IN endpoint */
Endpoint_Write_8(Response);
TX_LED_ON();
TxLEDPulse = TX_RX_LED_PULSE_PERIOD;
}
#define STK_OK 0x10
#define STK_INSYNC 0x14 // ' '
#define CRC_EOP 0x20 // 'SPACE'
#define STK_GET_SYNC 0x30 // '0'
#define STK_GET_PARAMETER 0x41 // 'A'
#define STK_SET_DEVICE 0x42 // 'B'
#define STK_SET_DEVICE_EXT 0x45 // 'E'
#define STK_LOAD_ADDRESS 0x55 // 'U'
#define STK_UNIVERSAL 0x56 // 'V'
#define STK_PROG_PAGE 0x64 // 'd'
#define STK_READ_PAGE 0x74 // 't'
#define STK_READ_SIGN 0x75 // 'u'
/** Task to read in AVR910 commands from the CDC data OUT endpoint, process them, perform the required actions
* and send the appropriate response back to the host.
*/
void CDC_Task(void)
{
/* Select the OUT endpoint */
Endpoint_SelectEndpoint(CDC_RX_EPNUM);
/* Check if endpoint has a command in it sent from the host */
if (!(Endpoint_IsOUTReceived()))
return;
RX_LED_ON();
RxLEDPulse = TX_RX_LED_PULSE_PERIOD;
/* Read in the bootloader command (first byte sent from host) */
uint8_t Command = FetchNextCommandByte();
if (Command == 'E')
{
/* We nearly run out the bootloader timeout clock,
* leaving just a few hundred milliseconds so the
* bootloder has time to respond and service any
* subsequent requests */
Timeout = TIMEOUT_PERIOD - 500;
/* Re-enable RWW section - must be done here in case
* user has disabled verification on upload. */
boot_rww_enable_safe();
// Send confirmation byte back to the host
WriteNextResponseByte('\r');
}
else if (Command == 'T')
{
FetchNextCommandByte();
// Send confirmation byte back to the host
WriteNextResponseByte('\r');
}
else if ((Command == 'L') || (Command == 'P'))
{
// Send confirmation byte back to the host
WriteNextResponseByte('\r');
}
else if (Command == 't')
{
// Return ATMEGA128 part code - this is only to allow AVRProg to use the bootloader
WriteNextResponseByte(0x44);
WriteNextResponseByte(0x00);
}
else if (Command == 'a')
{
// Indicate auto-address increment is supported
WriteNextResponseByte('Y');
}
else if (Command == 'A')
{
// Set the current address to that given by the host
CurrAddress = (FetchNextCommandByte() << 9);
CurrAddress |= (FetchNextCommandByte() << 1);
// Send confirmation byte back to the host
WriteNextResponseByte('\r');
}
else if (Command == 'p')
{
// Indicate serial programmer back to the host
WriteNextResponseByte('S');
}
else if (Command == 'S')
{
// Write the 7-byte software identifier to the endpoint
for (uint8_t CurrByte = 0; CurrByte < 7; CurrByte++)
WriteNextResponseByte(SOFTWARE_IDENTIFIER[CurrByte]);
}
else if (Command == 'V')
{
WriteNextResponseByte('0' + BOOTLOADER_VERSION_MAJOR);
WriteNextResponseByte('0' + BOOTLOADER_VERSION_MINOR);
}
else if (Command == 's')
{
WriteNextResponseByte(AVR_SIGNATURE_3);
WriteNextResponseByte(AVR_SIGNATURE_2);
WriteNextResponseByte(AVR_SIGNATURE_1);
}
else if (Command == 'e')
{
// Clear the application section of flash
for (uint32_t CurrFlashAddress = 0; CurrFlashAddress < BOOT_START_ADDR; CurrFlashAddress += SPM_PAGESIZE)
{
boot_page_erase(CurrFlashAddress);
boot_spm_busy_wait();
boot_page_write(CurrFlashAddress);
boot_spm_busy_wait();
}
// Send confirmation byte back to the host
WriteNextResponseByte('\r');
}
#if !defined(NO_LOCK_BYTE_WRITE_SUPPORT)
else if (Command == 'l')
{
// Set the lock bits to those given by the host
boot_lock_bits_set(FetchNextCommandByte());
// Send confirmation byte back to the host
WriteNextResponseByte('\r');
}
#endif
else if (Command == 'r')
{
WriteNextResponseByte(boot_lock_fuse_bits_get(GET_LOCK_BITS));
}
else if (Command == 'F')
{
WriteNextResponseByte(boot_lock_fuse_bits_get(GET_LOW_FUSE_BITS));
}
else if (Command == 'N')
{
WriteNextResponseByte(boot_lock_fuse_bits_get(GET_HIGH_FUSE_BITS));
}
else if (Command == 'Q')
{
WriteNextResponseByte(boot_lock_fuse_bits_get(GET_EXTENDED_FUSE_BITS));
}
#if !defined(NO_BLOCK_SUPPORT)
else if (Command == 'b')
{
WriteNextResponseByte('Y');
// Send block size to the host
WriteNextResponseByte(SPM_PAGESIZE >> 8);
WriteNextResponseByte(SPM_PAGESIZE & 0xFF);
}
else if ((Command == 'B') || (Command == 'g'))
{
// Keep resetting the timeout counter if we're receiving self-programming instructions
Timeout = 0;
// Delegate the block write/read to a separate function for clarity
ReadWriteMemoryBlock(Command);
}
#endif
#if !defined(NO_FLASH_BYTE_SUPPORT)
else if (Command == 'C')
{
// Write the high byte to the current flash page
boot_page_fill(CurrAddress, FetchNextCommandByte());
// Send confirmation byte back to the host
WriteNextResponseByte('\r');
}
else if (Command == 'c')
{
// Write the low byte to the current flash page
boot_page_fill(CurrAddress | 0x01, FetchNextCommandByte());
// Increment the address
CurrAddress += 2;
// Send confirmation byte back to the host
WriteNextResponseByte('\r');
}
else if (Command == 'm')
{
// Commit the flash page to memory
boot_page_write(CurrAddress);
// Wait until write operation has completed
boot_spm_busy_wait();
// Send confirmation byte back to the host
WriteNextResponseByte('\r');
}
else if (Command == 'R')
{
#if (FLASHEND > 0xFFFF)
uint16_t ProgramWord = pgm_read_word_far(CurrAddress);
#else
uint16_t ProgramWord = pgm_read_word(CurrAddress);
#endif
WriteNextResponseByte(ProgramWord >> 8);
WriteNextResponseByte(ProgramWord & 0xFF);
}
#endif
#if !defined(NO_EEPROM_BYTE_SUPPORT)
else if (Command == 'D')
{
// Read the byte from the endpoint and write it to the EEPROM
eeprom_write_byte((uint8_t*)((intptr_t)(CurrAddress >> 1)), FetchNextCommandByte());
// Increment the address after use
CurrAddress += 2;
// Send confirmation byte back to the host
WriteNextResponseByte('\r');
}
else if (Command == 'd')
{
// Read the EEPROM byte and write it to the endpoint
WriteNextResponseByte(eeprom_read_byte((uint8_t*)((intptr_t)(CurrAddress >> 1))));
// Increment the address after use
CurrAddress += 2;
}
#endif
else if (Command != 27)
{
// Unknown (non-sync) command, return fail code
WriteNextResponseByte('?');
}
/* Select the IN endpoint */
Endpoint_SelectEndpoint(CDC_TX_EPNUM);
/* Remember if the endpoint is completely full before clearing it */
bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
/* Send the endpoint data to the host */
Endpoint_ClearIN();
/* If a full endpoint's worth of data was sent, we need to send an empty packet afterwards to signal end of transfer */
if (IsEndpointFull)
{
while (!(Endpoint_IsINReady()))
{
if (USB_DeviceState == DEVICE_STATE_Unattached)
return;
}
Endpoint_ClearIN();
}
/* Wait until the data has been sent to the host */
while (!(Endpoint_IsINReady()))
{
if (USB_DeviceState == DEVICE_STATE_Unattached)
return;
}
/* Select the OUT endpoint */
Endpoint_SelectEndpoint(CDC_RX_EPNUM);
/* Acknowledge the command from the host */
Endpoint_ClearOUT();
}

99
bootloaders/caterina-LilyPadUSB/Caterina.h Executable file
View File

@ -0,0 +1,99 @@
/*
LUFA Library
Copyright (C) Dean Camera, 2011.
dean [at] fourwalledcubicle [dot] com
www.lufa-lib.org
*/
/*
Copyright 2011 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Permission to use, copy, modify, distribute, and sell this
software and its documentation for any purpose is hereby granted
without fee, provided that the above copyright notice appear in
all copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
/** \file
*
* Header file for BootloaderCDC.c.
*/
#ifndef _CDC_H_
#define _CDC_H_
/* Includes: */
#include <avr/io.h>
#include <avr/wdt.h>
#include <avr/boot.h>
#include <avr/eeprom.h>
#include <avr/power.h>
#include <avr/interrupt.h>
#include <stdbool.h>
#include "Descriptors.h"
#include <LUFA/Drivers/USB/USB.h>
/* Macros: */
/** Version major of the CDC bootloader. */
#define BOOTLOADER_VERSION_MAJOR 0x01
/** Version minor of the CDC bootloader. */
#define BOOTLOADER_VERSION_MINOR 0x00
/** Hardware version major of the CDC bootloader. */
#define BOOTLOADER_HWVERSION_MAJOR 0x01
/** Hardware version minor of the CDC bootloader. */
#define BOOTLOADER_HWVERSION_MINOR 0x00
/** Eight character bootloader firmware identifier reported to the host when requested */
#define SOFTWARE_IDENTIFIER "CATERINA"
#define CPU_PRESCALE(n) (CLKPR = 0x80, CLKPR = (n))
#define LED_SETUP() DDRC |= (1<<7); DDRB |= (1<<0); DDRD |= (1<<5);
#define L_LED_OFF() PORTC &= ~(1<<7)
#define L_LED_ON() PORTC |= (1<<7)
#define L_LED_TOGGLE() PORTC ^= (1<<7)
#define TX_LED_OFF() PORTD |= (1<<5)
#define TX_LED_ON() PORTD &= ~(1<<5)
#define RX_LED_OFF() PORTB |= (1<<0)
#define RX_LED_ON() PORTB &= ~(1<<0)
/* Type Defines: */
/** Type define for a non-returning pointer to the start of the loaded application in flash memory. */
typedef void (*AppPtr_t)(void) ATTR_NO_RETURN;
/* Function Prototypes: */
void StartSketch(void);
void LEDPulse(void);
void CDC_Task(void);
void SetupHardware(void);
void EVENT_USB_Device_ConfigurationChanged(void);
#if defined(INCLUDE_FROM_CATERINA_C) || defined(__DOXYGEN__)
#if !defined(NO_BLOCK_SUPPORT)
static void ReadWriteMemoryBlock(const uint8_t Command);
#endif
static uint8_t FetchNextCommandByte(void);
static void WriteNextResponseByte(const uint8_t Response);
#endif
#endif

260
bootloaders/caterina-LilyPadUSB/Descriptors.c Executable file
View File

@ -0,0 +1,260 @@
/*
LUFA Library
Copyright (C) Dean Camera, 2011.
dean [at] fourwalledcubicle [dot] com
www.lufa-lib.org
*/
/*
Copyright 2011 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Permission to use, copy, modify, distribute, and sell this
software and its documentation for any purpose is hereby granted
without fee, provided that the above copyright notice appear in
all copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
/** \file
*
* USB Device Descriptors, for library use when in USB device mode. Descriptors are special
* computer-readable structures which the host requests upon device enumeration, to determine
* the device's capabilities and functions.
*/
#include "Descriptors.h"
/** Device descriptor structure. This descriptor, located in SRAM memory, describes the overall
* device characteristics, including the supported USB version, control endpoint size and the
* number of device configurations. The descriptor is read out by the USB host when the enumeration
* process begins.
*/
const USB_Descriptor_Device_t DeviceDescriptor =
{
.Header = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},
.USBSpecification = VERSION_BCD(01.10),
.Class = CDC_CSCP_CDCClass,
.SubClass = CDC_CSCP_NoSpecificSubclass,
.Protocol = CDC_CSCP_NoSpecificProtocol,
.Endpoint0Size = FIXED_CONTROL_ENDPOINT_SIZE,
.VendorID = DEVICE_VID,
.ProductID = DEVICE_PID,
.ReleaseNumber = VERSION_BCD(00.01),
.ManufacturerStrIndex = 0x02,
.ProductStrIndex = 0x01,
.SerialNumStrIndex = NO_DESCRIPTOR,
.NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS
};
/** Configuration descriptor structure. This descriptor, located in SRAM memory, describes the usage
* of the device in one of its supported configurations, including information about any device interfaces
* and endpoints. The descriptor is read out by the USB host during the enumeration process when selecting
* a configuration so that the host may correctly communicate with the USB device.
*/
const USB_Descriptor_Configuration_t ConfigurationDescriptor =
{
.Config =
{
.Header = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},
.TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
.TotalInterfaces = 2,
.ConfigurationNumber = 1,
.ConfigurationStrIndex = NO_DESCRIPTOR,
.ConfigAttributes = USB_CONFIG_ATTR_BUSPOWERED,
.MaxPowerConsumption = USB_CONFIG_POWER_MA(100)
},
.CDC_CCI_Interface =
{
.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
.InterfaceNumber = 0,
.AlternateSetting = 0,
.TotalEndpoints = 1,
.Class = CDC_CSCP_CDCClass,
.SubClass = CDC_CSCP_ACMSubclass,
.Protocol = CDC_CSCP_ATCommandProtocol,
.InterfaceStrIndex = NO_DESCRIPTOR
},
.CDC_Functional_Header =
{
.Header = {.Size = sizeof(USB_CDC_Descriptor_FunctionalHeader_t), .Type = DTYPE_CSInterface},
.Subtype = 0x00,
.CDCSpecification = VERSION_BCD(01.10),
},
.CDC_Functional_ACM =
{
.Header = {.Size = sizeof(USB_CDC_Descriptor_FunctionalACM_t), .Type = DTYPE_CSInterface},
.Subtype = 0x02,
.Capabilities = 0x04,
},
.CDC_Functional_Union =
{
.Header = {.Size = sizeof(USB_CDC_Descriptor_FunctionalUnion_t), .Type = DTYPE_CSInterface},
.Subtype = 0x06,
.MasterInterfaceNumber = 0,
.SlaveInterfaceNumber = 1,
},
.CDC_NotificationEndpoint =
{
.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
.EndpointAddress = (ENDPOINT_DIR_IN | CDC_NOTIFICATION_EPNUM),
.Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
.EndpointSize = CDC_NOTIFICATION_EPSIZE,
.PollingIntervalMS = 0xFF
},
.CDC_DCI_Interface =
{
.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
.InterfaceNumber = 1,
.AlternateSetting = 0,
.TotalEndpoints = 2,
.Class = CDC_CSCP_CDCDataClass,
.SubClass = CDC_CSCP_NoDataSubclass,
.Protocol = CDC_CSCP_NoDataProtocol,
.InterfaceStrIndex = NO_DESCRIPTOR
},
.CDC_DataOutEndpoint =
{
.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
.EndpointAddress = (ENDPOINT_DIR_OUT | CDC_RX_EPNUM),
.Attributes = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
.EndpointSize = CDC_TXRX_EPSIZE,
.PollingIntervalMS = 0x01
},
.CDC_DataInEndpoint =
{
.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
.EndpointAddress = (ENDPOINT_DIR_IN | CDC_TX_EPNUM),
.Attributes = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
.EndpointSize = CDC_TXRX_EPSIZE,
.PollingIntervalMS = 0x01
}
};
/** Language descriptor structure. This descriptor, located in SRAM memory, is returned when the host requests
* the string descriptor with index 0 (the first index). It is actually an array of 16-bit integers, which indicate
* via the language ID table available at USB.org what languages the device supports for its string descriptors.
*/
const USB_Descriptor_String_t LanguageString =
{
.Header = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},
.UnicodeString = {LANGUAGE_ID_ENG}
};
/** Product descriptor string. This is a Unicode string containing the product's details in human readable form,
* and is read out upon request by the host when the appropriate string ID is requested, listed in the Device
* Descriptor.
*/
const USB_Descriptor_String_t ProductString =
{
.Header = {.Size = USB_STRING_LEN(16), .Type = DTYPE_String},
#if DEVICE_PID == 0x9207
.UnicodeString = L"LilyPadUSB "
#else
.UnicodeString = L"USB IO board "
#endif
};
const USB_Descriptor_String_t ManufNameString =
{
.Header = {.Size = USB_STRING_LEN(20), .Type = DTYPE_String},
#if DEVICE_VID == 0x1B4F
.UnicodeString = L"SparkFun Electronics"
#else
.UnicodeString = L"Unknown "
#endif
};
/** This function is called by the library when in device mode, and must be overridden (see LUFA library "USB Descriptors"
* documentation) by the application code so that the address and size of a requested descriptor can be given
* to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function
* is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the
* USB host.
*/
uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
const uint8_t wIndex,
const void** const DescriptorAddress)
{
const uint8_t DescriptorType = (wValue >> 8);
const uint8_t DescriptorNumber = (wValue & 0xFF);
const void* Address = NULL;
uint16_t Size = NO_DESCRIPTOR;
switch (DescriptorType)
{
case DTYPE_Device:
Address = &DeviceDescriptor;
Size = sizeof(USB_Descriptor_Device_t);
break;
case DTYPE_Configuration:
Address = &ConfigurationDescriptor;
Size = sizeof(USB_Descriptor_Configuration_t);
break;
case DTYPE_String:
if (!(DescriptorNumber))
{
Address = &LanguageString;
Size = LanguageString.Header.Size;
}
else if (DescriptorNumber == DeviceDescriptor.ProductStrIndex)
{
Address = &ProductString;
Size = ProductString.Header.Size;
} else if (DescriptorNumber == DeviceDescriptor.ManufacturerStrIndex)
{
Address = &ManufNameString;
Size = ManufNameString.Header.Size;
}
break;
}
*DescriptorAddress = Address;
return Size;
}

139
bootloaders/caterina-LilyPadUSB/Descriptors.h Executable file
View File

@ -0,0 +1,139 @@
/*
LUFA Library
Copyright (C) Dean Camera, 2011.
dean [at] fourwalledcubicle [dot] com
www.lufa-lib.org
*/
/*
Copyright 2011 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Permission to use, copy, modify, distribute, and sell this
software and its documentation for any purpose is hereby granted
without fee, provided that the above copyright notice appear in
all copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
/** \file
*
* Header file for Descriptors.c.
*/
#ifndef _DESCRIPTORS_H_
#define _DESCRIPTORS_H_
/* Includes: */
#include <LUFA/Drivers/USB/USB.h>
/* Macros: */
#if defined(__AVR_AT90USB1287__)
#define AVR_SIGNATURE_1 0x1E
#define AVR_SIGNATURE_2 0x97
#define AVR_SIGNATURE_3 0x82
#elif defined(__AVR_AT90USB647__)
#define AVR_SIGNATURE_1 0x1E
#define AVR_SIGNATURE_2 0x96
#define AVR_SIGNATURE_3 0x82
#elif defined(__AVR_AT90USB1286__)
#define AVR_SIGNATURE_1 0x1E
#define AVR_SIGNATURE_2 0x97
#define AVR_SIGNATURE_3 0x82
#elif defined(__AVR_AT90USB646__)
#define AVR_SIGNATURE_1 0x1E
#define AVR_SIGNATURE_2 0x96
#define AVR_SIGNATURE_3 0x82
#elif defined(__AVR_ATmega32U6__)
#define AVR_SIGNATURE_1 0x1E
#define AVR_SIGNATURE_2 0x95
#define AVR_SIGNATURE_3 0x88
#elif defined(__AVR_ATmega32U4__)
#define AVR_SIGNATURE_1 0x1E
#define AVR_SIGNATURE_2 0x95
#define AVR_SIGNATURE_3 0x87
#elif defined(__AVR_ATmega16U4__)
#define AVR_SIGNATURE_1 0x1E
#define AVR_SIGNATURE_2 0x94
#define AVR_SIGNATURE_3 0x88
#elif defined(__AVR_ATmega32U2__)
#define AVR_SIGNATURE_1 0x1E
#define AVR_SIGNATURE_2 0x95
#define AVR_SIGNATURE_3 0x8A
#elif defined(__AVR_ATmega16U2__)
#define AVR_SIGNATURE_1 0x1E
#define AVR_SIGNATURE_2 0x94
#define AVR_SIGNATURE_3 0x89
#elif defined(__AVR_AT90USB162__)
#define AVR_SIGNATURE_1 0x1E
#define AVR_SIGNATURE_2 0x94
#define AVR_SIGNATURE_3 0x82
#elif defined(__AVR_ATmega8U2__)
#define AVR_SIGNATURE_1 0x1E
#define AVR_SIGNATURE_2 0x93
#define AVR_SIGNATURE_3 0x89
#elif defined(__AVR_AT90USB82__)
#define AVR_SIGNATURE_1 0x1E
#define AVR_SIGNATURE_2 0x94
#define AVR_SIGNATURE_3 0x82
#else
#error The selected AVR part is not currently supported by this bootloader.
#endif
/** Endpoint number for the CDC control interface event notification endpoint. */
#define CDC_NOTIFICATION_EPNUM 2
/** Endpoint number for the CDC data interface TX (data IN) endpoint. */
#define CDC_TX_EPNUM 3
/** Endpoint number for the CDC data interface RX (data OUT) endpoint. */
#define CDC_RX_EPNUM 4
/** Size of the CDC data interface TX and RX data endpoint banks, in bytes. */
#define CDC_TXRX_EPSIZE 16
/** Size of the CDC control interface notification endpoint bank, in bytes. */
#define CDC_NOTIFICATION_EPSIZE 8
/* Type Defines: */
/** Type define for the device configuration descriptor structure. This must be defined in the
* application code, as the configuration descriptor contains several sub-descriptors which
* vary between devices, and which describe the device's usage to the host.
*/
typedef struct
{
USB_Descriptor_Configuration_Header_t Config;
// CDC Control Interface
USB_Descriptor_Interface_t CDC_CCI_Interface;
USB_CDC_Descriptor_FunctionalHeader_t CDC_Functional_Header;
USB_CDC_Descriptor_FunctionalACM_t CDC_Functional_ACM;
USB_CDC_Descriptor_FunctionalUnion_t CDC_Functional_Union;
USB_Descriptor_Endpoint_t CDC_NotificationEndpoint;
// CDC Data Interface
USB_Descriptor_Interface_t CDC_DCI_Interface;
USB_Descriptor_Endpoint_t CDC_DataOutEndpoint;
USB_Descriptor_Endpoint_t CDC_DataInEndpoint;
} USB_Descriptor_Configuration_t;
/* Function Prototypes: */
uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
const uint8_t wIndex,
const void** const DescriptorAddress)
ATTR_WARN_UNUSED_RESULT ATTR_NON_NULL_PTR_ARG(3);
#endif

716
bootloaders/caterina-LilyPadUSB/Makefile Executable file
View File

@ -0,0 +1,716 @@
# Hey Emacs, this is a -*- makefile -*-
#----------------------------------------------------------------------------
# WinAVR Makefile Template written by Eric B. Weddington, Jörg Wunsch, et al.
# >> Modified for use with the LUFA project. <<
#
# Released to the Public Domain
#
# Additional material for this makefile was written by:
# Peter Fleury
# Tim Henigan
# Colin O'Flynn
# Reiner Patommel
# Markus Pfaff
# Sander Pool
# Frederik Rouleau
# Carlos Lamas
# Dean Camera
# Opendous Inc.
# Denver Gingerich
#
#----------------------------------------------------------------------------
# On command line:
#
# make all = Make software.
#
# make clean = Clean out built project files.
#
# make coff = Convert ELF to AVR COFF.
#
# make extcoff = Convert ELF to AVR Extended COFF.
#
# make program = Download the hex file to the device, using avrdude.
# Please customize the avrdude settings below first!
#
# make doxygen = Generate DoxyGen documentation for the project (must have
# DoxyGen installed)
#
# make debug = Start either simulavr or avarice as specified for debugging,
# with avr-gdb or avr-insight as the front end for debugging.
#
# make filename.s = Just compile filename.c into the assembler code only.
#
# make filename.i = Create a preprocessed source file for use in submitting
# bug reports to the GCC project.
#
# To rebuild project do "make clean" then "make all".
#----------------------------------------------------------------------------
# USB vendor ID (VID)
# official Arduino LLC VID = 0x2341
# SparkFun VID = 0x1B4F
VID = 0x1B4F
# USB product ID (PID)
# official Leonardo PID = 0x0036
# SparkFun LilyPadUSB PID = 0x9207
PID = 0x9207
# MCU name
MCU = atmega32u4
# Target architecture (see library "Board Types" documentation).
ARCH = AVR8
# Target board (see library "Board Types" documentation, NONE for projects not requiring
# LUFA board drivers). If USER is selected, put custom board drivers in a directory called
# "Board" inside the application directory.
BOARD = USER
# Processor frequency.
# This will define a symbol, F_CPU, in all source code files equal to the
# processor frequency in Hz. You can then use this symbol in your source code to
# calculate timings. Do NOT tack on a 'UL' at the end, this will be done
# automatically to create a 32-bit value in your source code.
#
# This will be an integer division of F_USB below, as it is sourced by
# F_USB after it has run through any CPU prescalers. Note that this value
# does not *change* the processor frequency - it should merely be updated to
# reflect the processor speed set externally so that the code can use accurate
# software delays.
F_CPU = 8000000
# Input clock frequency.
# This will define a symbol, F_USB, in all source code files equal to the
# input clock frequency (before any prescaling is performed) in Hz. This value may
# differ from F_CPU if prescaling is used on the latter, and is required as the
# raw input clock is fed directly to the PLL sections of the AVR for high speed
# clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
# at the end, this will be done automatically to create a 32-bit value in your
# source code.
#
# If no clock division is performed on the input clock inside the AVR (via the
# CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
F_USB = $(F_CPU)
# Starting byte address of the bootloader, as a byte address - computed via the formula
# BOOT_START = ((FLASH_SIZE_KB - BOOT_SECTION_SIZE_KB) * 1024)
#
# Note that the bootloader size and start address given in AVRStudio is in words and not
# bytes, and so will need to be doubled to obtain the byte address needed by AVR-GCC.
FLASH_SIZE_KB = 32
BOOT_SECTION_SIZE_KB = 4
BOOT_START = 0x$(shell echo "obase=16; ($(FLASH_SIZE_KB) - $(BOOT_SECTION_SIZE_KB)) * 1024" | bc)
# Output format. (can be srec, ihex, binary)
FORMAT = ihex
# Target file name (without extension).
TARGET = Caterina
# Object files directory
# To put object files in current directory, use a dot (.), do NOT make
# this an empty or blank macro!
OBJDIR = .
# Path to the LUFA library
LUFA_PATH = LUFA-111009
# LUFA library compile-time options and predefined tokens
LUFA_OPTS = -D USB_DEVICE_ONLY
LUFA_OPTS += -D DEVICE_STATE_AS_GPIOR=0
LUFA_OPTS += -D ORDERED_EP_CONFIG
LUFA_OPTS += -D FIXED_CONTROL_ENDPOINT_SIZE=8
LUFA_OPTS += -D FIXED_NUM_CONFIGURATIONS=1
LUFA_OPTS += -D USE_RAM_DESCRIPTORS
LUFA_OPTS += -D USE_STATIC_OPTIONS="(USB_DEVICE_OPT_FULLSPEED | USB_OPT_REG_ENABLED | USB_OPT_AUTO_PLL)"
LUFA_OPTS += -D NO_INTERNAL_SERIAL
LUFA_OPTS += -D NO_DEVICE_SELF_POWER
LUFA_OPTS += -D NO_DEVICE_REMOTE_WAKEUP
LUFA_OPTS += -D NO_SOF_EVENTS
#LUFA_OPTS += -D NO_BLOCK_SUPPORT
#LUFA_OPTS += -D NO_EEPROM_BYTE_SUPPORT
#LUFA_OPTS += -D NO_FLASH_BYTE_SUPPORT
LUFA_OPTS += -D NO_LOCK_BYTE_WRITE_SUPPORT
# Create the LUFA source path variables by including the LUFA root makefile
include $(LUFA_PATH)/LUFA/makefile
# List C source files here. (C dependencies are automatically generated.)
SRC = $(TARGET).c \
Descriptors.c \
$(LUFA_SRC_USB) \
# List C++ source files here. (C dependencies are automatically generated.)
CPPSRC =
# List Assembler source files here.
# Make them always end in a capital .S. Files ending in a lowercase .s
# will not be considered source files but generated files (assembler
# output from the compiler), and will be deleted upon "make clean"!
# Even though the DOS/Win* filesystem matches both .s and .S the same,
# it will preserve the spelling of the filenames, and gcc itself does
# care about how the name is spelled on its command-line.
ASRC =
# Optimization level, can be [0, 1, 2, 3, s].
# 0 = turn off optimization. s = optimize for size.
# (Note: 3 is not always the best optimization level. See avr-libc FAQ.)
OPT = s
# Debugging format.
# Native formats for AVR-GCC's -g are dwarf-2 [default] or stabs.
# AVR Studio 4.10 requires dwarf-2.
# AVR [Extended] COFF format requires stabs, plus an avr-objcopy run.
DEBUG = dwarf-2
# List any extra directories to look for include files here.
# Each directory must be seperated by a space.
# Use forward slashes for directory separators.
# For a directory that has spaces, enclose it in quotes.
EXTRAINCDIRS = $(LUFA_PATH)/
# Compiler flag to set the C Standard level.
# c89 = "ANSI" C
# gnu89 = c89 plus GCC extensions
# c99 = ISO C99 standard (not yet fully implemented)
# gnu99 = c99 plus GCC extensions
CSTANDARD = -std=c99
# Place -D or -U options here for C sources
CDEFS = -DF_CPU=$(F_CPU)UL
CDEFS += -DF_USB=$(F_USB)UL
CDEFS += -DBOARD=BOARD_$(BOARD) -DARCH=ARCH_$(ARCH)
CDEFS += -DBOOT_START_ADDR=$(BOOT_START)UL
CDEFS += -DDEVICE_VID=$(VID)UL
CDEFS += -DDEVICE_PID=$(PID)UL
CDEFS += $(LUFA_OPTS)
# Place -D or -U options here for ASM sources
ADEFS = -DF_CPU=$(F_CPU)
ADEFS += -DF_USB=$(F_USB)UL
ADEFS += -DBOARD=BOARD_$(BOARD)
ADEFS += -DBOOT_START_ADDR=$(BOOT_START)UL
ADEFS += $(LUFA_OPTS)
# Place -D or -U options here for C++ sources
CPPDEFS = -DF_CPU=$(F_CPU)UL
CPPDEFS += -DF_USB=$(F_USB)UL
CPPDEFS += -DBOARD=BOARD_$(BOARD)
CPPDEFS += -DBOOT_START_ADDR=$(BOOT_START)UL
CPPDEFS += $(LUFA_OPTS)
#CPPDEFS += -D__STDC_LIMIT_MACROS
#CPPDEFS += -D__STDC_CONSTANT_MACROS
#---------------- Compiler Options C ----------------
# -g*: generate debugging information
# -O*: optimization level
# -f...: tuning, see GCC manual and avr-libc documentation
# -Wall...: warning level
# -Wa,...: tell GCC to pass this to the assembler.
# -adhlns...: create assembler listing
CFLAGS = -g$(DEBUG)
CFLAGS += $(CDEFS)
CFLAGS += -O$(OPT)
CFLAGS += -funsigned-char
CFLAGS += -funsigned-bitfields
CFLAGS += -ffunction-sections
CFLAGS += -fno-inline-small-functions
CFLAGS += -fpack-struct
CFLAGS += -fshort-enums
CFLAGS += -fno-strict-aliasing
CFLAGS += -Wall
CFLAGS += -Wstrict-prototypes
#CFLAGS += -mshort-calls
#CFLAGS += -fno-unit-at-a-time
#CFLAGS += -Wundef
#CFLAGS += -Wunreachable-code
#CFLAGS += -Wsign-compare
CFLAGS += -Wa,-adhlns=$(<:%.c=$(OBJDIR)/%.lst)
CFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
CFLAGS += $(CSTANDARD)
#---------------- Compiler Options C++ ----------------
# -g*: generate debugging information
# -O*: optimization level
# -f...: tuning, see GCC manual and avr-libc documentation
# -Wall...: warning level
# -Wa,...: tell GCC to pass this to the assembler.
# -adhlns...: create assembler listing
CPPFLAGS = -g$(DEBUG)
CPPFLAGS += $(CPPDEFS)
CPPFLAGS += -O$(OPT)
CPPFLAGS += -funsigned-char
CPPFLAGS += -funsigned-bitfields
CPPFLAGS += -fpack-struct
CPPFLAGS += -fshort-enums
CPPFLAGS += -fno-exceptions
CPPFLAGS += -Wall
CPPFLAGS += -Wundef
#CPPFLAGS += -mshort-calls
#CPPFLAGS += -fno-unit-at-a-time
#CPPFLAGS += -Wstrict-prototypes
#CPPFLAGS += -Wunreachable-code
#CPPFLAGS += -Wsign-compare
CPPFLAGS += -Wa,-adhlns=$(<:%.cpp=$(OBJDIR)/%.lst)
CPPFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
#CPPFLAGS += $(CSTANDARD)
#---------------- Assembler Options ----------------
# -Wa,...: tell GCC to pass this to the assembler.
# -adhlns: create listing
# -gstabs: have the assembler create line number information; note that
# for use in COFF files, additional information about filenames
# and function names needs to be present in the assembler source
# files -- see avr-libc docs [FIXME: not yet described there]
# -listing-cont-lines: Sets the maximum number of continuation lines of hex
# dump that will be displayed for a given single line of source input.
ASFLAGS = $(ADEFS) -Wa,-adhlns=$(<:%.S=$(OBJDIR)/%.lst),-gstabs,--listing-cont-lines=100
#---------------- Library Options ----------------
# Minimalistic printf version
PRINTF_LIB_MIN = -Wl,-u,vfprintf -lprintf_min
# Floating point printf version (requires MATH_LIB = -lm below)
PRINTF_LIB_FLOAT = -Wl,-u,vfprintf -lprintf_flt
# If this is left blank, then it will use the Standard printf version.
PRINTF_LIB =
#PRINTF_LIB = $(PRINTF_LIB_MIN)
#PRINTF_LIB = $(PRINTF_LIB_FLOAT)
# Minimalistic scanf version
SCANF_LIB_MIN = -Wl,-u,vfscanf -lscanf_min
# Floating point + %[ scanf version (requires MATH_LIB = -lm below)
SCANF_LIB_FLOAT = -Wl,-u,vfscanf -lscanf_flt
# If this is left blank, then it will use the Standard scanf version.
SCANF_LIB =
#SCANF_LIB = $(SCANF_LIB_MIN)
#SCANF_LIB = $(SCANF_LIB_FLOAT)
MATH_LIB = -lm
# List any extra directories to look for libraries here.
# Each directory must be seperated by a space.
# Use forward slashes for directory separators.
# For a directory that has spaces, enclose it in quotes.
EXTRALIBDIRS =
#---------------- External Memory Options ----------------
# 64 KB of external RAM, starting after internal RAM (ATmega128!),
# used for variables (.data/.bss) and heap (malloc()).
#EXTMEMOPTS = -Wl,-Tdata=0x801100,--defsym=__heap_end=0x80ffff
# 64 KB of external RAM, starting after internal RAM (ATmega128!),
# only used for heap (malloc()).
#EXTMEMOPTS = -Wl,--section-start,.data=0x801100,--defsym=__heap_end=0x80ffff
EXTMEMOPTS =
#---------------- Linker Options ----------------
# -Wl,...: tell GCC to pass this to linker.
# -Map: create map file
# --cref: add cross reference to map file
LDFLAGS = -Wl,-Map=$(TARGET).map,--cref
LDFLAGS += -Wl,--section-start=.text=$(BOOT_START)
LDFLAGS += -Wl,--relax
LDFLAGS += -Wl,--gc-sections
LDFLAGS += $(EXTMEMOPTS)
LDFLAGS += $(patsubst %,-L%,$(EXTRALIBDIRS))
LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)
#LDFLAGS += -T linker_script.x
#---------------- Programming Options (avrdude) ----------------
# Programming hardware
# Type: avrdude -c ?
# to get a full listing.
#
AVRDUDE_PROGRAMMER = avrispmkII
# com1 = serial port. Use lpt1 to connect to parallel port.
AVRDUDE_PORT = usb
AVRDUDE_WRITE_FLASH = -U flash:w:$(TARGET).hex
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
AVRDUDE_WRITE_FUSES = -U efuse:w:0xce:m
AVRDUDE_WRITE_FUSES += -U hfuse:w:0xd8:m
AVRDUDE_WRITE_FUSES += -U lfuse:w:0xff:m
# Uncomment the following if you want avrdude's erase cycle counter.
# Note that this counter needs to be initialized first using -Yn,
# see avrdude manual.
#AVRDUDE_ERASE_COUNTER = -y
# Uncomment the following if you do /not/ wish a verification to be
# performed after programming the device.
#AVRDUDE_NO_VERIFY = -V
# Increase verbosity level. Please use this when submitting bug
# reports about avrdude. See <http://savannah.nongnu.org/projects/avrdude>
# to submit bug reports.
#AVRDUDE_VERBOSE = -v -v
AVRDUDE_FLAGS = -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER)
AVRDUDE_FLAGS += $(AVRDUDE_NO_VERIFY)
AVRDUDE_FLAGS += $(AVRDUDE_VERBOSE)
AVRDUDE_FLAGS += $(AVRDUDE_ERASE_COUNTER)
#---------------- Debugging Options ----------------
# For simulavr only - target MCU frequency.
DEBUG_MFREQ = $(F_CPU)
# Set the DEBUG_UI to either gdb or insight.
# DEBUG_UI = gdb
DEBUG_UI = insight
# Set the debugging back-end to either avarice, simulavr.
DEBUG_BACKEND = avarice
#DEBUG_BACKEND = simulavr
# GDB Init Filename.
GDBINIT_FILE = __avr_gdbinit
# When using avarice settings for the JTAG
JTAG_DEV = /dev/com1
# Debugging port used to communicate between GDB / avarice / simulavr.
DEBUG_PORT = 4242
# Debugging host used to communicate between GDB / avarice / simulavr, normally
# just set to localhost unless doing some sort of crazy debugging when
# avarice is running on a different computer.
DEBUG_HOST = localhost
#============================================================================
# Define programs and commands.
SHELL = sh
CC = avr-gcc
OBJCOPY = avr-objcopy
OBJDUMP = avr-objdump
SIZE = avr-size
AR = avr-ar rcs
NM = avr-nm
AVRDUDE = avrdude -B 1
REMOVE = rm -f
REMOVEDIR = rm -rf
COPY = cp
WINSHELL = cmd
# Define Messages
# English
MSG_ERRORS_NONE = Errors: none
MSG_BEGIN = -------- begin --------
MSG_END = -------- end --------
MSG_SIZE_BEFORE = Size before:
MSG_SIZE_AFTER = Size after:
MSG_COFF = Converting to AVR COFF:
MSG_EXTENDED_COFF = Converting to AVR Extended COFF:
MSG_FLASH = Creating load file for Flash:
MSG_EEPROM = Creating load file for EEPROM:
MSG_EXTENDED_LISTING = Creating Extended Listing:
MSG_SYMBOL_TABLE = Creating Symbol Table:
MSG_LINKING = Linking:
MSG_COMPILING = Compiling C:
MSG_COMPILING_CPP = Compiling C++:
MSG_ASSEMBLING = Assembling:
MSG_CLEANING = Cleaning project:
MSG_CREATING_LIBRARY = Creating library:
# Define all object files.
OBJ = $(SRC:%.c=$(OBJDIR)/%.o) $(CPPSRC:%.cpp=$(OBJDIR)/%.o) $(ASRC:%.S=$(OBJDIR)/%.o)
# Define all listing files.
LST = $(SRC:%.c=$(OBJDIR)/%.lst) $(CPPSRC:%.cpp=$(OBJDIR)/%.lst) $(ASRC:%.S=$(OBJDIR)/%.lst)
# Compiler flags to generate dependency files.
GENDEPFLAGS = -MMD -MP -MF .dep/$(@F).d
# Combine all necessary flags and optional flags.
# Add target processor to flags.
ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)
ALL_CPPFLAGS = -mmcu=$(MCU) -I. -x c++ $(CPPFLAGS) $(GENDEPFLAGS)
ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)
# Default target.
all: begin gccversion sizebefore build sizeafter end
# Change the build target to build a HEX file or a library.
build: elf hex eep lss sym
#build: lib
elf: $(TARGET).elf
hex: $(TARGET).hex
eep: $(TARGET).eep
lss: $(TARGET).lss
sym: $(TARGET).sym
LIBNAME=lib$(TARGET).a
lib: $(LIBNAME)
# Eye candy.
# AVR Studio 3.x does not check make's exit code but relies on
# the following magic strings to be generated by the compile job.
begin:
@echo
@echo $(MSG_BEGIN)
end:
@echo $(MSG_END)
@echo
# Display size of file.
HEXSIZE = $(SIZE) --target=$(FORMAT) $(TARGET).hex
ELFSIZE = $(SIZE) $(MCU_FLAG) $(FORMAT_FLAG) $(TARGET).elf
MCU_FLAG = $(shell $(SIZE) --help | grep -- --mcu > /dev/null && echo --mcu=$(MCU) )
FORMAT_FLAG = $(shell $(SIZE) --help | grep -- --format=.*avr > /dev/null && echo --format=avr )
sizebefore:
@if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_BEFORE); $(ELFSIZE); \
2>/dev/null; echo; fi
sizeafter:
@if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_AFTER); $(ELFSIZE); \
2>/dev/null; echo; fi
# Display compiler version information.
gccversion :
@$(CC) --version
# Program the device.
program: $(TARGET).hex $(TARGET).eep
$(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE_EEPROM) $(AVRDUDE_WRITE_FUSES)
# Generate avr-gdb config/init file which does the following:
# define the reset signal, load the target file, connect to target, and set
# a breakpoint at main().
gdb-config:
@$(REMOVE) $(GDBINIT_FILE)
@echo define reset >> $(GDBINIT_FILE)
@echo SIGNAL SIGHUP >> $(GDBINIT_FILE)
@echo end >> $(GDBINIT_FILE)
@echo file $(TARGET).elf >> $(GDBINIT_FILE)
@echo target remote $(DEBUG_HOST):$(DEBUG_PORT) >> $(GDBINIT_FILE)
ifeq ($(DEBUG_BACKEND),simulavr)
@echo load >> $(GDBINIT_FILE)
endif
@echo break main >> $(GDBINIT_FILE)
debug: gdb-config $(TARGET).elf
ifeq ($(DEBUG_BACKEND), avarice)
@echo Starting AVaRICE - Press enter when "waiting to connect" message displays.
@$(WINSHELL) /c start avarice --jtag $(JTAG_DEV) --erase --program --file \
$(TARGET).elf $(DEBUG_HOST):$(DEBUG_PORT)
@$(WINSHELL) /c pause
else
@$(WINSHELL) /c start simulavr --gdbserver --device $(MCU) --clock-freq \
$(DEBUG_MFREQ) --port $(DEBUG_PORT)
endif
@$(WINSHELL) /c start avr-$(DEBUG_UI) --command=$(GDBINIT_FILE)
# Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.
COFFCONVERT = $(OBJCOPY) --debugging
COFFCONVERT += --change-section-address .data-0x800000
COFFCONVERT += --change-section-address .bss-0x800000
COFFCONVERT += --change-section-address .noinit-0x800000
COFFCONVERT += --change-section-address .eeprom-0x810000
coff: $(TARGET).elf
@echo
@echo $(MSG_COFF) $(TARGET).cof
$(COFFCONVERT) -O coff-avr $< $(TARGET).cof
extcoff: $(TARGET).elf
@echo
@echo $(MSG_EXTENDED_COFF) $(TARGET).cof
$(COFFCONVERT) -O coff-ext-avr $< $(TARGET).cof
# Create final output files (.hex, .eep) from ELF output file.
%.hex: %.elf
@echo
@echo $(MSG_FLASH) $@
$(OBJCOPY) -O $(FORMAT) -R .eeprom -R .fuse -R .lock $< $@
%.eep: %.elf
@echo
@echo $(MSG_EEPROM) $@
-$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \
--change-section-lma .eeprom=0 --no-change-warnings -O $(FORMAT) $< $@ || exit 0
# Create extended listing file from ELF output file.
%.lss: %.elf
@echo
@echo $(MSG_EXTENDED_LISTING) $@
$(OBJDUMP) -h -S -z $< > $@
# Create a symbol table from ELF output file.
%.sym: %.elf
@echo
@echo $(MSG_SYMBOL_TABLE) $@
$(NM) -n $< > $@
# Create library from object files.
.SECONDARY : $(TARGET).a
.PRECIOUS : $(OBJ)
%.a: $(OBJ)
@echo
@echo $(MSG_CREATING_LIBRARY) $@
$(AR) $@ $(OBJ)
# Link: create ELF output file from object files.
.SECONDARY : $(TARGET).elf
.PRECIOUS : $(OBJ)
%.elf: $(OBJ)
@echo
@echo $(MSG_LINKING) $@
$(CC) $(ALL_CFLAGS) $^ --output $@ $(LDFLAGS)
# Compile: create object files from C source files.
$(OBJDIR)/%.o : %.c
@echo
@echo $(MSG_COMPILING) $<
$(CC) -c $(ALL_CFLAGS) $< -o $@
# Compile: create object files from C++ source files.
$(OBJDIR)/%.o : %.cpp
@echo
@echo $(MSG_COMPILING_CPP) $<
$(CC) -c $(ALL_CPPFLAGS) $< -o $@
# Compile: create assembler files from C source files.
%.s : %.c
$(CC) -S $(ALL_CFLAGS) $< -o $@
# Compile: create assembler files from C++ source files.
%.s : %.cpp
$(CC) -S $(ALL_CPPFLAGS) $< -o $@
# Assemble: create object files from assembler source files.
$(OBJDIR)/%.o : %.S
@echo
@echo $(MSG_ASSEMBLING) $<
$(CC) -c $(ALL_ASFLAGS) $< -o $@
# Create preprocessed source for use in sending a bug report.
%.i : %.c
$(CC) -E -mmcu=$(MCU) -I. $(CFLAGS) $< -o $@
# Target: clean project.
clean: begin clean_list end
clean_list :
@echo
@echo $(MSG_CLEANING)
$(REMOVE) $(TARGET).hex
$(REMOVE) $(TARGET).eep
$(REMOVE) $(TARGET).cof
$(REMOVE) $(TARGET).elf
$(REMOVE) $(TARGET).map
$(REMOVE) $(TARGET).sym
$(REMOVE) $(TARGET).lss
$(REMOVE) $(SRC:%.c=$(OBJDIR)/%.o) $(CPPSRC:%.cpp=$(OBJDIR)/%.o) $(ASRC:%.S=$(OBJDIR)/%.o)
$(REMOVE) $(SRC:%.c=$(OBJDIR)/%.lst) $(CPPSRC:%.cpp=$(OBJDIR)/%.lst) $(ASRC:%.S=$(OBJDIR)/%.lst)
$(REMOVE) $(SRC:.c=.s)
$(REMOVE) $(SRC:.c=.d)
$(REMOVE) $(SRC:.c=.i)
$(REMOVEDIR) .dep
doxygen:
@echo Generating Project Documentation \($(TARGET)\)...
@doxygen Doxygen.conf
@echo Documentation Generation Complete.
clean_doxygen:
rm -rf Documentation
checksource:
@for f in $(SRC) $(CPPSRC) $(ASRC); do \
if [ -f $$f ]; then \
echo "Found Source File: $$f" ; \
else \
echo "Source File Not Found: $$f" ; \
fi; done
# Create object files directory
$(shell mkdir $(OBJDIR) 2>/dev/null)
# Include the dependency files.
-include $(shell mkdir .dep 2>/dev/null) $(wildcard .dep/*)
# Listing of phony targets.
.PHONY : all begin finish end sizebefore sizeafter gccversion \
build elf hex eep lss sym coff extcoff doxygen clean \
clean_list clean_doxygen program debug gdb-config checksource

11
bootloaders/caterina-LilyPadUSB/Readme.txt Executable file
View File

@ -0,0 +1,11 @@
Building the bootloader for the LilyPadUSB
1. Download the LUFA-111009 file (http://fourwalledcubicle.com/blog/2011/10/lufa-111009-released/).
2. Extract that file directly to the Caterina-LilyPadUSB bootloader directory.
3. Open a command prompt in the Caterina-LilyPadUSB bootloader directory.
4. Type 'make'.
5. Enjoy!
Programming the bootloader for the LilyPadUSB
1. Open a command prompt in the Caterina-LilyPadUSB folder.
2. Connect your programmer- use a 2x3 .1" header, pressed against the programming vias.
3. Type 'make program' into the command prompt.

4
cores/arduino/USBCore.cpp
View File

@ -55,6 +55,8 @@ const u16 STRING_IPRODUCT[17] = {
'A','r','d','u','i','n','o',' ','L','e','o','n','a','r','d','o'
#elif USB_PID == 0x8037
'A','r','d','u','i','n','o',' ','M','i','c','r','o',' ',' ',' '
#elif USB_PID == 0x9208
'L','i','l','y','P','a','d','U','S','B',' ',' ',' ',' ',' ',' '
#else
'U','S','B',' ','I','O',' ','B','o','a','r','d',' ',' ',' ',' '
#endif
@ -64,6 +66,8 @@ const u16 STRING_IMANUFACTURER[12] = {
(3<<8) | (2+2*11),
#if USB_VID == 0x2341
'A','r','d','u','i','n','o',' ','L','L','C'
#elif USB_VID == 0x1b4f
'S','p','a','r','k','F','u','n',' ',' ',' '
#else
'U','n','k','n','o','w','n',' ',' ',' ',' '
#endif