8F328U 作基礎的 AVR 燒寫器

eddiewwm

用 8F328U 小紅板 按外國大神的指導，完成了以下的 AVR ATmega328P 燒寫器。


參考視頻：
https://www.youtube.com/watch?v=7H8aQ1mWUy4

AVRprogrammer_9_24_18.ino

1. #include "data.h"
   
2. void setup ()
   
3. {
   
4.   Serial.begin(115200);
   
5.   Serial.println("AVR Programmer Ready...");
   
6.   pinMode (startSwitch, INPUT);
   
7.   digitalWrite (startSwitch, HIGH);
   
8.   pinMode (errorLED, OUTPUT);
   
9.   pinMode (readyLED, OUTPUT);
   
10.   pinMode (workingLED, OUTPUT);
    
11.   pinMode (buzzerPin, OUTPUT);
    
12.   digitalWrite(buzzerPin, HIGH);
    
13.   delay(20);
    
14.   digitalWrite(buzzerPin, LOW);
    
15.   // initialize the SD card at SPI_HALF_SPEED to avoid bus errors with
    
16.   // breadboards.  use SPI_FULL_SPEED for better performance.
    
17.   while (!sd.begin (chipSelect, SPI_HALF_SPEED))
    
18.   {
    
19.     ShowMessage (MSG_NO_SD_CARD);
    
20.     delay (1000);
    
21.   }
    
22. 
    
23. }  // end of setup
    
24. 
    
25. 
    
26. 
    
27. //------------------------------------------------------------------------------
    
28. //      LOOP
    
29. //------------------------------------------------------------------------------
    
30. void loop ()
    
31. {
    
32. 
    
33.   digitalWrite (readyLED, HIGH);
    
34. 
    
35.   // wait till they press the start switch
    
36.   while (!getUserSerial()) {}
    
37. //  Serial.println("Press Button to Start!!");
    
38. //  while (digitalRead (startSwitch) == HIGH)
    
39. //  {
    
40. //    //just loop in here till start button is pressed
    
41. //
    
42. //  }  // end of waiting for switch press
    
43. 
    
44. }  // end of loop

复制代码

data.h

1. //includes
   
2. #include <SdFat.h>// for SDFat library see: https://github.com/greiman/SdFat
   
3. 
   
4. 
   
5. //functions
   
6. boolean getUserSerial();
   
7. boolean getDate();
   
8. boolean getIntro();
   
9. 
   
10. void burnEEPROM(byte EEPROMdata);
    
11. void getString();
    
12. void readALlFromChip();
    
13. void showHex (const byte b, const boolean newline = false, const boolean show0x = true);
    
14. void blink (const int whichLED1,
    
15.             const int whichLED2,
    
16.             const byte times = 1,
    
17.             const unsigned long repeat = 1,
    
18.             const unsigned long interval = 200);
    
19. void ShowMessage (const byte which);
    
20. byte BB_SPITransfer (byte c);
    
21. byte program (const byte b1, const byte b2 = 0, const byte b3 = 0, const byte b4 = 0);
    
22. byte readFlash (unsigned long addr);
    
23. void writeFlash (unsigned long addr, const byte data);
    
24. bool hexConv (const char * (& pStr), byte & b);
    
25. void pollUntilReady ();
    
26. void showProgress ();
    
27. void clearPage ();
    
28. void commitPage (unsigned long addr);
    
29. void writeData (const unsigned long addr, const byte * pData, const int length);
    
30. void verifyData (const unsigned long addr, const byte * pData, const int length);
    
31. bool processLine (const char * pLine, const byte action);
    
32. bool readHexFile (const char * fName, const byte action);
    
33. bool startProgramming ();
    
34. void stopProgramming ();
    
35. void getSignature ();
    
36. void getFuseBytes ();
    
37. void writeFuse (const byte newValue, const byte instruction);
    
38. bool updateFuses (const bool writeIt);
    
39. bool chooseInputFile ();
    
40. bool writeFlashContents ();
    
41. 
    
42. 
    
43. 
    
44. //variables and constants
    
45. const unsigned int ENTER_PROGRAMMING_ATTEMPTS = 2;
    
46. String inputstring = "";
    
47. boolean input_string_complete = false;
    
48. byte EEPROMindex = 0;
    
49. const bool allowTargetToRun = true;  // if true, programming lines are freed when not programming
    
50. const char dateMessage[] PROGMEM  = {"Please Enter Date like this: MM/DD/YY \n Example for July 4th, 2018, would be 07/04/18\n"};
    
51. const char introMessage[]  PROGMEM  = {"What do you want to do?\n  R = Read Board Information\n  W = Write parameters\n  N = Brand New Board Programming\n"};
    
52. const char fuseBurn[]  PROGMEM  = {"Burning Fuse Config:  Should be LFuse=0xFF, HFuse=0xDF, EFuse=0xFD\n"};
    
53. const char wrongLength[]  PROGMEM  = {"Sorry wrong length\n"};
    
54. // fixed file name to read from SD card (root directory)
    
55. const char wantedFile [] = "firmware.hex";
    
56. 
    
57. // which switch to close to start programming the target chip
    
58. const byte startSwitch = 2;
    
59. 
    
60. // the three "status" LEDs
    
61. const int errorLED = A0;
    
62. const int readyLED = A1;
    
63. const int workingLED = A4;
    
64. const int buzzerPin = 3;
    
65. 
    
66. const int noLED = -1;  // must be int! - can be negative
    
67. 
    
68. // status "messages"
    
69. typedef enum {
    
70.   MSG_NO_SD_CARD,          // cannot open SD card
    
71.   MSG_CANNOT_OPEN_FILE,    // canoot open file 'wantedFile' (above)
    
72.   MSG_LINE_TOO_LONG,       // line on disk too long to read
    
73.   MSG_LINE_TOO_SHORT,      // line too short to be valid
    
74.   MSG_LINE_DOES_NOT_START_WITH_COLON,  // line does not start with a colon
    
75.   MSG_INVALID_HEX_DIGITS,  // invalid hex where there should be hex
    
76.   MSG_BAD_SUMCHECK,        // line fails sumcheck
    
77.   MSG_LINE_NOT_EXPECTED_LENGTH,  // record not length expected
    
78.   MSG_UNKNOWN_RECORD_TYPE,  // record type not known
    
79.   MSG_NO_END_OF_FILE_RECORD,  // no 'end of file' at end of file
    
80.   MSG_FILE_TOO_LARGE_FOR_FLASH,  // file will not fit into flash
    
81. 
    
82.   MSG_CANNOT_ENTER_PROGRAMMING_MODE,  // cannot program target chip
    
83.   MSG_NO_BOOTLOADER_FUSE,             // chip does not have bootloader
    
84.   MSG_CANNOT_FIND_SIGNATURE,      // cannot find chip signature
    
85.   MSG_UNRECOGNIZED_SIGNATURE,     // signature not known
    
86.   MSG_BAD_START_ADDRESS,          // file start address invalid
    
87.   MSG_VERIFICATION_ERROR,         // verification error after programming
    
88.   MSG_FLASHED_OK,                 // flashed OK
    
89. } msgType;
    
90. 
    
91. //SPI to target pins
    
92. const byte MSPIM_SCK = 4;  // port D bit 4
    
93. const byte MSPIM_SS  = 5;  // port D bit 5
    
94. const byte BB_MISO   = 6;  // port D bit 6
    
95. const byte BB_MOSI   = 7;  // port D bit 7
    
96. // 8 MHz clock on this pin
    
97. const byte CLOCKOUT = 9;
    
98. 
    
99. #define BB_MISO_PORT PIND
    
100. #define BB_MOSI_PORT PORTD
     
101. #define BB_SCK_PORT PORTD
     
102. const byte BB_SCK_BIT = 4;
     
103. const byte BB_MISO_BIT = 6;
     
104. const byte BB_MOSI_BIT = 7;
     
105. 
     
106. // control speed of programming
     
107. const byte BB_DELAY_MICROSECONDS = 6;
     
108. // target board reset goes to here
     
109. const byte RESET = MSPIM_SS;
     
110. // SD chip select pin
     
111. const uint8_t chipSelect = SS;
     
112. const unsigned long NO_PAGE = 0xFFFFFFFF;
     
113. const int MAX_FILENAME = 13;
     
114. 
     
115. // actions to take
     
116. enum {
     
117.   checkFile,
     
118.   verifyFlash,
     
119.   writeToFlash,
     
120. };
     
121. 
     
122. // file system object
     
123. SdFat sd;
     
124. 
     
125. // copy of fuses/lock bytes found for this processor
     
126. byte fuses [5];
     
127. 
     
128. // meaning of bytes in above array
     
129. enum {
     
130.   lowFuse,
     
131.   highFuse,
     
132.   extFuse,
     
133.   lockByte,
     
134.   calibrationByte
     
135. };
     
136. 
     
137. // structure to hold signature and other relevant data about each chip
     
138. typedef struct {
     
139.   byte sig [3];
     
140.   const char * desc;
     
141.   unsigned long flashSize;
     
142.   unsigned int baseBootSize;
     
143.   unsigned long pageSize;     // bytes
     
144.   byte fuseWithBootloaderSize;  // ie. one of: lowFuse, highFuse, extFuse
     
145.   byte timedWrites;    // if pollUntilReady won't work by polling the chip
     
146. } signatureType;
     
147. 
     
148. const unsigned long kb = 1024;
     
149. const byte NO_FUSE = 0xFF;
     
150. 
     
151. // see Atmega datasheets
     
152. const signatureType signatures [] PROGMEM =
     
153. {
     
154.   //     signature        description   flash size   bootloader  flash  fuse
     
155.   //                                                     size    page    to
     
156.   //                                                             size   change
     
157. 
     
158.   // Attiny84 family
     
159.   { { 0x1E, 0x91, 0x0B }, "ATtiny24",   2 * kb,           0,   32,   NO_FUSE },
     
160.   { { 0x1E, 0x92, 0x07 }, "ATtiny44",   4 * kb,           0,   64,   NO_FUSE },
     
161.   { { 0x1E, 0x93, 0x0C }, "ATtiny84",   8 * kb,           0,   64,   NO_FUSE },
     
162. 
     
163.   // Attiny85 family
     
164.   { { 0x1E, 0x91, 0x08 }, "ATtiny25",   2 * kb,           0,   32,   NO_FUSE },
     
165.   { { 0x1E, 0x92, 0x06 }, "ATtiny45",   4 * kb,           0,   64,   NO_FUSE },
     
166.   { { 0x1E, 0x93, 0x0B }, "ATtiny85",   8 * kb,           0,   64,   NO_FUSE },
     
167. 
     
168.   // Atmega328 family
     
169.   { { 0x1E, 0x92, 0x0A }, "ATmega48PA",   4 * kb,         0,    64,  NO_FUSE },
     
170.   { { 0x1E, 0x93, 0x0F }, "ATmega88PA",   8 * kb,       256,   128,  extFuse },
     
171.   { { 0x1E, 0x94, 0x0B }, "ATmega168PA", 16 * kb,       256,   128,  extFuse },
     
172.   { { 0x1E, 0x95, 0x0F }, "ATmega328P",  32 * kb,       512,   128,  highFuse },
     
173. 
     
174.   // Atmega644 family
     
175.   { { 0x1E, 0x94, 0x0A }, "ATmega164P",   16 * kb,      256,   128,  highFuse },
     
176.   { { 0x1E, 0x95, 0x08 }, "ATmega324P",   32 * kb,      512,   128,  highFuse },
     
177.   { { 0x1E, 0x96, 0x0A }, "ATmega644P",   64 * kb,   1 * kb,   256,  highFuse },
     
178. 
     
179.   // Atmega2560 family
     
180.   { { 0x1E, 0x96, 0x08 }, "ATmega640",    64 * kb,   1 * kb,   256,  highFuse },
     
181.   { { 0x1E, 0x97, 0x03 }, "ATmega1280",  128 * kb,   1 * kb,   256,  highFuse },
     
182.   { { 0x1E, 0x97, 0x04 }, "ATmega1281",  128 * kb,   1 * kb,   256,  highFuse },
     
183.   { { 0x1E, 0x98, 0x01 }, "ATmega2560",  256 * kb,   1 * kb,   256,  highFuse },
     
184. 
     
185.   { { 0x1E, 0x98, 0x02 }, "ATmega2561",  256 * kb,   1 * kb,   256,  highFuse },
     
186. 
     
187.   // AT90USB family
     
188.   { { 0x1E, 0x93, 0x82 }, "At90USB82",    8 * kb,       512,   128,  highFuse },
     
189.   { { 0x1E, 0x94, 0x82 }, "At90USB162",  16 * kb,       512,   128,  highFuse },
     
190. 
     
191.   // Atmega32U2 family
     
192.   { { 0x1E, 0x93, 0x89 }, "ATmega8U2",    8 * kb,       512,   128,  highFuse  },
     
193.   { { 0x1E, 0x94, 0x89 }, "ATmega16U2",  16 * kb,       512,   128,  highFuse  },
     
194.   { { 0x1E, 0x95, 0x8A }, "ATmega32U2",  32 * kb,       512,   128,  highFuse  },
     
195. 
     
196.   // Atmega32U4 family -  (datasheet is wrong about flash page size being 128 words)
     
197.   { { 0x1E, 0x94, 0x88 }, "ATmega16U4",  16 * kb,       512,   128,  highFuse },
     
198.   { { 0x1E, 0x95, 0x87 }, "ATmega32U4",  32 * kb,       512,   128,  highFuse },
     
199. 
     
200.   // ATmega1284P family
     
201.   { { 0x1E, 0x97, 0x05 }, "ATmega1284P", 128 * kb,   1 * kb,   256,  highFuse  },
     
202. 
     
203.   // ATtiny4313 family
     
204.   { { 0x1E, 0x91, 0x0A }, "ATtiny2313A",   2 * kb,        0,    32,  NO_FUSE  },
     
205.   { { 0x1E, 0x92, 0x0D }, "ATtiny4313",    4 * kb,        0,    64,  NO_FUSE  },
     
206. 
     
207.   // ATtiny13 family
     
208.   { { 0x1E, 0x90, 0x07 }, "ATtiny13A",     1 * kb,        0,    32,  NO_FUSE },
     
209. 
     
210.   // Atmega8A family
     
211.   { { 0x1E, 0x93, 0x07 }, "ATmega8A",      8 * kb,      256,    64,  highFuse, true },
     
212. 
     
213.   // ATmega64rfr2 family
     
214.   { { 0x1E, 0xA6, 0x02 }, "ATmega64rfr2",  256 * kb, 1 * kb,   256, highFuse },
     
215.   { { 0x1E, 0xA7, 0x02 }, "ATmega128rfr2", 256 * kb, 1 * kb,   256, highFuse },
     
216.   { { 0x1E, 0xA8, 0x02 }, "ATmega256rfr2", 256 * kb, 1 * kb,   256, highFuse },
     
217. 
     
218. };  // end of signatures
     
219. 
     
220. char name[MAX_FILENAME] = { 0 };  // current file name
     
221. 
     
222. // number of items in an array
     
223. #define NUMITEMS(arg) ((unsigned int) (sizeof (arg) / sizeof (arg [0])))
     
224. 
     
225. // programming commands to send via SPI to the chip
     
226. enum {
     
227.   progamEnable = 0xAC,
     
228. 
     
229.   // writes are preceded by progamEnable
     
230.   chipErase = 0x80,
     
231.   writeLockByte = 0xE0,
     
232.   writeLowFuseByte = 0xA0,
     
233.   writeHighFuseByte = 0xA8,
     
234.   writeExtendedFuseByte = 0xA4,
     
235. 
     
236.   pollReady = 0xF0,
     
237. 
     
238.   programAcknowledge = 0x53,
     
239. 
     
240.   readSignatureByte = 0x30,
     
241.   readCalibrationByte = 0x38,
     
242. 
     
243.   readLowFuseByte = 0x50,       readLowFuseByteArg2 = 0x00,
     
244.   readExtendedFuseByte = 0x50,  readExtendedFuseByteArg2 = 0x08,
     
245.   readHighFuseByte = 0x58,      readHighFuseByteArg2 = 0x08,
     
246.   readLockByte = 0x58,          readLockByteArg2 = 0x00,
     
247. 
     
248.   readProgramMemory = 0x20,
     
249.   writeProgramMemory = 0x4C,
     
250.   loadExtendedAddressByte = 0x4D,
     
251.   loadProgramMemory = 0x40,
     
252.   readEEPROMbyte = 0xA0,
     
253.   writeEEPROMbyte = 0xC0
     
254. 
     
255.                     /*
     
256.                        0xC0 WRITE BYTE TO EEPROM
     
257.                       0xA0 READ BYTE FROM EEPROM
     
258. 
     
259.                     */
     
260. 
     
261. };  // end of enum
     
262. 
     
263. // which program instruction writes which fuse
     
264. const byte fuseCommands [4] = { writeLowFuseByte, writeHighFuseByte, writeExtendedFuseByte, writeLockByte };
     
265. 
     
266. // types of record in .hex file
     
267. enum {
     
268.   hexDataRecord,  // 00
     
269.   hexEndOfFile,   // 01
     
270.   hexExtendedSegmentAddressRecord, // 02
     
271.   hexStartSegmentAddressRecord,  // 03
     
272.   hexExtendedLinearAddressRecord, // 04
     
273.   hexStartLinearAddressRecord // 05
     
274. };
     
275. // if signature found in above table, this is its index
     
276. int foundSig = -1;
     
277. byte lastAddressMSB = 0;
     
278. // copy of current signature entry for matching processor
     
279. signatureType currentSignature;
     
280. 
     
281. unsigned long pagesize;
     
282. unsigned long pagemask;
     
283. unsigned long oldPage;
     
284. unsigned int progressBarCount;
     
285. // count errors
     
286. unsigned int errors;
     
287. bool gotEndOfFile;
     
288. unsigned long extendedAddress;
     
289. 
     
290. unsigned long lowestAddress;
     
291. unsigned long highestAddress;
     
292. unsigned long bytesWritten;
     
293. unsigned int lineCount;
     
294. 
     
295. 
     
296. /*
     
297.   LED codes (flash counts) - each sequence repeats 5 times
     
298. 
     
299.   If you are using the Crossroads programming board, the statuses are also shown
     
300.   as a 2-digit code in the 7-segment display. If you have the board with only one
     
301.   7-segment display you will see the first letter only.
     
302. 
     
303.   Problems with SD card or programming target chip
     
304.   ------------------------------------------------
     
305. 
     
306.   Red x 1 = Cannot open SD card (Sd)
     
307.   Red x 2 = Cannot read file 'firmware.hex' (FL)
     
308.   Red x 3 = Cannot enter programming mode in target chip (Ch)
     
309.   Red x 4 = This chip does not have a bootloader fuse (Fu)
     
310.   Red x 5 = Cannot read chip signature (Sg)
     
311.   Red x 6 = Unrecognized signature (Un)
     
312.   Red x 7 = Bad start address in hex file for code (Ad)
     
313.   Red x 8 = Verification error (bd)
     
314. 
     
315.   Problems with firmware.hex file
     
316.   -------------------------------
     
317. 
     
318.   Red + yellow x 1 = Line in file is too long (E1)
     
319.   Red + yellow x 2 = Line in file is too short (E2)
     
320.   Red + yellow x 3 = Line does not start with a colon (:) (E3)
     
321.   Red + yellow x 4 = Invalid hex digits (should be 0-9, A-F) (E4)
     
322.   Red + yellow x 5 = Bad sumcheck at end of line (E5)
     
323.   Red + yellow x 6 = Line not expected length (E6)
     
324.   Red + yellow x 7 = Unknown record type (E7)
     
325.   Red + yellow x 8 = No 'end of file' record in file (E8)
     
326.   Red + yellow x 9 = File will not fit into flash of target (LG)
     
327. 
     
328.   Worked OK
     
329.   ---------
     
330. 
     
331.   Green x 3 = Flashed and verified OK - sequence repeats 10 times (AA)
     
332. 
     
333.   Other statuses
     
334.   --------------
     
335. 
     
336.   Green (steady) = Ready to program (close switch to commence)
     
337.   Yellow (flashing) = Programming (Pr)
     
338.   Green (steady) + yellow (flashing) = verifying (uF)
     
339.   No LEDs on = No power?
     
340. 
     
341. */
     

复制代码

getUserInput.ino

1. 
   
2. boolean getUserSerial() {
   
3.   EEPROMindex = 0;
   
4.   inputstring.reserve(15);
   
5.   digitalWrite (readyLED, HIGH);
   
6.   if (!getIntro())
   
7.     return 0;
   
8.   digitalWrite(buzzerPin, HIGH);
   
9.   delay(20);
   
10.   digitalWrite(buzzerPin, LOW);
    
11.   if (inputstring == "R") {
    
12. 
    
13.     readALlFromChip();
    
14. 
    
15.     return 0;
    
16.   }
    
17.   if (inputstring == "N") {
    
18.     strcpy (name, wantedFile);
    
19.     Serial.println("Programming Started");
    
20. 
    
21.     digitalWrite (readyLED, LOW);
    
22.     if (!startProgramming ())
    
23.     {
    
24.       ShowMessage (MSG_CANNOT_ENTER_PROGRAMMING_MODE);
    
25.       return;
    
26.     }  // end of could not enter programming mode
    
27. 
    
28.     //FUSES ARE BURNED HERE!!!
    
29.     // WOULD BE NICE IF WE COULD DETERMINE FUSE SETTINGS BASED ON SIGNATURE
    
30.     writeFuse (0xFF, writeLowFuseByte);
    
31.     stopProgramming();
    
32.     startProgramming ();
    
33.     //writeFuse (0xD6, writeHighFuseByte);//retains EEPROM
    
34.     writeFuse (0xDE, writeHighFuseByte);
    
35.     stopProgramming();
    
36.     startProgramming ();
    
37.     writeFuse (0x05, writeExtendedFuseByte);//BO at 2.7V
    
38.     stopProgramming();
    
39.     startProgramming ();
    
40.     getSignature ();
    
41.     for (int k = 0; k < strlen_P(fuseBurn); k++)
    
42.     {
    
43.       char myChar =  pgm_read_byte_near(fuseBurn + k);
    
44.       Serial.print(myChar);
    
45.     }
    
46.     getFuseBytes ();
    
47.     // don't have signature? don't proceed
    
48.     if (foundSig == -1)
    
49.     {
    
50.       ShowMessage (MSG_CANNOT_FIND_SIGNATURE);
    
51.       return;
    
52.     }  // end of no signature
    
53. 
    
54.     digitalWrite (workingLED, HIGH);
    
55.     bool ok = writeFlashContents ();
    
56.     digitalWrite (workingLED, LOW);
    
57.     digitalWrite (readyLED, LOW);
    
58.     stopProgramming ();
    
59.     //delay (500);
    
60.     if (ok) {
    
61.       //ShowMessage (MSG_FLASHED_OK);
    
62.       for (int i = 0; i < 10; i++) {
    
63.         digitalWrite(buzzerPin, HIGH);
    
64.         delay(50);
    
65.         digitalWrite(buzzerPin, LOW);
    
66.         delay(50);
    
67.       }
    
68.     }
    
69.     Serial.println("Programming Complete!");
    
70. 
    
71.   }
    
72. 
    
73.   digitalWrite (readyLED, HIGH);
    
74.   digitalWrite(buzzerPin, HIGH);
    
75.   delay(20);
    
76.   digitalWrite(buzzerPin, LOW);
    
77. 
    
78.   if (!getDate())
    
79.     return 0;
    
80.   digitalWrite(buzzerPin, HIGH);
    
81.   delay(20);
    
82.   digitalWrite(buzzerPin, LOW);
    
83. 
    
84.   for (int i = 0; i < 10; i++) {
    
85.     digitalWrite(buzzerPin, HIGH);
    
86.     delay(20);
    
87.     digitalWrite(buzzerPin, LOW);
    
88.     delay(20);
    
89.   }
    
90.   Serial.println("DONE!\n\n");
    
91.   readALlFromChip();
    
92.   return 0;
    
93. 
    
94. }
    
95. 
    
96. 
    
97. 
    
98. 
    
99. void burnEEPROM(byte EEPROMdata) {
    
100.   startProgramming();
     
101.   digitalWrite(workingLED, HIGH);
     
102.   program (writeEEPROMbyte, 0, EEPROMindex, EEPROMdata);
     
103.   delay(100);
     
104.   digitalWrite(workingLED, LOW);
     
105.   stopProgramming();
     
106. }
     
107. 
     
108. 
     
109. boolean getDate() {
     
110.   inputstring = "";
     
111.   //Serial.println("Please Enter Date like this: MM/DD/YY");
     
112.   for (int k = 0; k < strlen_P(dateMessage); k++)
     
113.   {
     
114.     char myChar =  pgm_read_byte_near(dateMessage + k);
     
115.     Serial.print(myChar);
     
116.   }
     
117.   getString();
     
118.   if (inputstring.length() > 8 || inputstring.length() < 8) {
     
119.     for (int k = 0; k < strlen_P(wrongLength); k++)
     
120.     {
     
121.       char myChar =  pgm_read_byte_near(wrongLength + k);
     
122.       Serial.print(myChar);
     
123.     }
     
124.     // Serial.println("Sorry wrong length");
     
125.     return 0;
     
126.   }
     
127.   Serial.print("Thanks, will use ");
     
128.   Serial.println(inputstring);
     
129.   for (int i = 0; i < 8; i++) {
     
130.     burnEEPROM(inputstring[i]);
     
131.     EEPROMindex++;
     
132.   }
     
133.   return 1;
     
134. }
     
135. 
     
136. 
     
137. boolean getIntro() {
     
138.   inputstring = "";
     
139.   for (int k = 0; k < strlen_P(introMessage); k++)
     
140.   {
     
141.     char myChar =  pgm_read_byte_near(introMessage + k);
     
142.     Serial.print(myChar);
     
143.   }
     
144. 
     
145.   getString();
     
146.   if (inputstring.length() > 1 || inputstring.length() < 1) {
     
147.     for (int k = 0; k < strlen_P(wrongLength); k++)
     
148.     {
     
149.       char myChar =  pgm_read_byte_near(wrongLength + k);
     
150.       Serial.print(myChar);
     
151.     }
     
152.     return 0;
     
153.   }
     
154. 
     
155.   return 1;
     
156. }
     
157. 
     
158. void getString() {
     
159.   inputstring = "";
     
160.   //digitalWrite (readyLED, LOW);
     
161.   unsigned long blinkerStart = millis();
     
162.   while (1) {
     
163.     if (millis() - blinkerStart > 50) {
     
164.       digitalWrite(readyLED, !digitalRead(readyLED));
     
165.       blinkerStart = millis();
     
166.     }
     
167. 
     
168.     if (digitalRead (startSwitch) == LOW) {
     
169.       inputstring = "N";
     
170.       break;
     
171.     }
     
172. 
     
173.     if (Serial.available() > 0) {
     
174.       delay(10);
     
175.       inputstring = Serial.readStringUntil(13);           //read the string until we see a <CR>
     
176.       //Serial.println(inputstring);
     
177.       digitalWrite (readyLED, HIGH);
     
178.       //digitalWrite(workingLED, LOW);
     
179.       break;
     
180.     }
     
181.   }
     
182. }
     
183. 
     
184. void readALlFromChip() {
     
185. 
     
186.   if (!startProgramming ()) {
     
187.     Serial.println("NO BOARD DETECTED!!");
     
188.     return;
     
189.   }
     
190.   Serial.println("***** Reading From Board *****");
     
191.   Serial.println("Config Fuses Set:");
     
192.   getFuseBytes ();
     
193.   //startProgramming();
     
194.   Serial.println("");
     
195.   //    Serial.println("Reading Board Data...");
     
196.   Serial.print("Date Prog = ");
     
197.   byte indexTracker = 0;
     
198.   for (byte i = 0; i < 8; i++) {
     
199.     Serial.print(char(program (readEEPROMbyte, 0, i)));
     
200.     indexTracker++;
     
201.   }
     
202.   Serial.println("");
     
203. 
     
204.   Serial.print("Firmware Date Code = ");
     
205.   for (byte i = indexTracker; i < indexTracker + 8; i++) {
     
206.     Serial.print(char(program (readEEPROMbyte, 0, i)));
     
207.   }
     
208. 
     
209.   stopProgramming();
     
210.   Serial.println("");
     
211.   Serial.println("*********************");
     
212.   Serial.println("\n");
     
213. }

复制代码

programmingFunctions.ino

1. /// changed this line: lowestAddress = 0x7E00;//I HAD TO FORCE THIS FOR THE ATMEGA328P
   
2. 
   
3. void showHex (const byte b, const boolean newline, const boolean show0x)
   
4. {
   
5.   if (show0x)
   
6.     Serial.print (F("0x"));
   
7.   // try to avoid using sprintf
   
8.   char buf [4];
   
9.   buf [0] = ((b >> 4) & 0x0F) | '0';
   
10.   buf [1] = (b & 0x0F) | '0';
    
11.   buf [2] = ' ';
    
12.   buf [3] = 0;
    
13.   if (buf [0] > '9')
    
14.     buf [0] += 7;
    
15.   if (buf [1] > '9')
    
16.     buf [1] += 7;
    
17.   Serial.print (buf);
    
18.   if (newline)
    
19.     Serial.println ();
    
20. }  // end of showHex
    
21. // blink one or two LEDs for "times" times, with a delay of "interval". Wait a second and do it again "repeat" times.
    
22. void blink (const int whichLED1,
    
23.             const int whichLED2,
    
24.             const byte times = 1,
    
25.             const unsigned long repeat = 1,
    
26.             const unsigned long interval = 200)
    
27. {
    
28.   for (unsigned long i = 0; i < repeat; i++)
    
29.   {
    
30.     for (byte j = 0; j < times; j++)
    
31.     {
    
32.       digitalWrite (whichLED1, HIGH);
    
33.       if (whichLED2 != noLED)
    
34.         digitalWrite (whichLED2, HIGH);
    
35.       delay (interval);
    
36.       digitalWrite (whichLED1, LOW);
    
37.       if (whichLED2 != noLED)
    
38.         digitalWrite (whichLED2, LOW);
    
39.       delay (interval);
    
40.     }  // end of for loop
    
41.     if (i < (repeat - 1))
    
42.       delay (1000);
    
43.   }  // end of repeating the sequence
    
44. }  // end of blink
    
45. 
    
46. void ShowMessage (const byte which)
    
47. {
    
48.   // first turn off all LEDs
    
49.   digitalWrite (errorLED, LOW);
    
50.   digitalWrite (workingLED, LOW);
    
51.   digitalWrite (readyLED, LOW);
    
52.   Serial.println("SOMETHING IS NOT RIGHT!! Press RED Button to try again...");
    
53.   while (1) {
    
54.     // now flash an appropriate sequence
    
55.     switch (which)
    
56.     {
    
57.       // problems with SD card or finding the file
    
58.       case MSG_NO_SD_CARD:                      blink (errorLED, noLED, 1, 5); break;
    
59.       case MSG_CANNOT_OPEN_FILE:                blink (errorLED, noLED, 2, 5); break;
    
60. 
    
61.       // problems reading the .hex file
    
62.       case MSG_LINE_TOO_LONG:                   blink (errorLED, workingLED, 1, 5); break;
    
63.       case MSG_LINE_TOO_SHORT:                  blink (errorLED, workingLED, 2, 5); break;
    
64.       case MSG_LINE_DOES_NOT_START_WITH_COLON:  blink (errorLED, workingLED, 3, 5); break;
    
65.       case MSG_INVALID_HEX_DIGITS:              blink (errorLED, workingLED, 4, 5); break;
    
66.       case MSG_BAD_SUMCHECK:                    blink (errorLED, workingLED, 5, 5); break;
    
67.       case MSG_LINE_NOT_EXPECTED_LENGTH:        blink (errorLED, workingLED, 6, 5); break;
    
68.       case MSG_UNKNOWN_RECORD_TYPE:             blink (errorLED, workingLED, 7, 5); break;
    
69.       case MSG_NO_END_OF_FILE_RECORD:           blink (errorLED, workingLED, 8, 5); break;
    
70. 
    
71.       // problems with the file contents
    
72.       case MSG_FILE_TOO_LARGE_FOR_FLASH:        blink (errorLED, workingLED, 9, 5); break;
    
73. 
    
74.       // problems programming the chip
    
75.       case MSG_CANNOT_ENTER_PROGRAMMING_MODE:  blink (errorLED, noLED, 3, 5); break;
    
76.       case MSG_NO_BOOTLOADER_FUSE:             blink (errorLED, noLED, 4, 5); break;
    
77.       case MSG_CANNOT_FIND_SIGNATURE:          blink (errorLED, noLED, 5, 5); break;
    
78.       case MSG_UNRECOGNIZED_SIGNATURE:         blink (errorLED, noLED, 6, 5); break;
    
79.       case MSG_BAD_START_ADDRESS:              blink (errorLED, noLED, 7, 5); break;
    
80.       case MSG_VERIFICATION_ERROR:             blink (errorLED, noLED, 8, 5); break;
    
81.       case MSG_FLASHED_OK:                     blink (readyLED, noLED, 3, 2); break;
    
82. 
    
83.       default:                                  blink (errorLED, 10, 10);  break;   // unknown error
    
84.     }  // end of switch on which message
    
85.   }
    
86. }  // end of ShowMessage
    
87. 
    
88. // Bit Banged SPI transfer
    
89. byte BB_SPITransfer (byte c)
    
90. {
    
91.   byte bit;
    
92. 
    
93.   for (bit = 0; bit < 8; bit++)
    
94.   {
    
95.     // write MOSI on falling edge of previous clock
    
96.     if (c & 0x80)
    
97.       BB_MOSI_PORT |= bit (BB_MOSI_BIT);
    
98.     else
    
99.       BB_MOSI_PORT &= ~bit (BB_MOSI_BIT);
    
100.     c <<= 1;
     
101. 
     
102.     // read MISO
     
103.     c |= (BB_MISO_PORT & bit (BB_MISO_BIT)) != 0;
     
104. 
     
105.     // clock high
     
106.     BB_SCK_PORT |= bit (BB_SCK_BIT);
     
107. 
     
108.     // delay between rise and fall of clock
     
109.     delayMicroseconds (BB_DELAY_MICROSECONDS);
     
110. 
     
111.     // clock low
     
112.     BB_SCK_PORT &= ~bit (BB_SCK_BIT);
     
113. 
     
114.     // delay between rise and fall of clock
     
115.     delayMicroseconds (BB_DELAY_MICROSECONDS);
     
116.   }
     
117. 
     
118.   return c;
     
119. }  // end of BB_SPITransfer
     
120. 
     
121. // execute one programming instruction ... b1 is command, b2, b3, b4 are arguments
     
122. //  processor may return a result on the 4th transfer, this is returned.
     
123. byte program (const byte b1, const byte b2 = 0, const byte b3 = 0, const byte b4 = 0)
     
124. {
     
125.   noInterrupts ();
     
126.   BB_SPITransfer (b1);
     
127.   BB_SPITransfer (b2);
     
128.   BB_SPITransfer (b3);
     
129.   byte b = BB_SPITransfer (b4);
     
130.   interrupts ();
     
131.   return b;
     
132. } // end of program
     
133. 
     
134. // read a byte from flash memory
     
135. byte readFlash (unsigned long addr)
     
136. {
     
137.   byte high = (addr & 1) ? 0x08 : 0;  // set if high byte wanted
     
138.   addr >>= 1;  // turn into word address
     
139. 
     
140.   // set the extended (most significant) address byte if necessary
     
141.   byte MSB = (addr >> 16) & 0xFF;
     
142.   if (MSB != lastAddressMSB)
     
143.   {
     
144.     program (loadExtendedAddressByte, 0, MSB);
     
145.     lastAddressMSB = MSB;
     
146.   }  // end if different MSB
     
147. 
     
148.   return program (readProgramMemory | high, highByte (addr), lowByte (addr));
     
149. } // end of readFlash
     
150. // write a byte to the flash memory buffer (ready for committing)
     
151. 
     
152. void writeFlash (unsigned long addr, const byte data)
     
153. {
     
154.   byte high = (addr & 1) ? 0x08 : 0;  // set if high byte wanted
     
155.   addr >>= 1;  // turn into word address
     
156.   program (loadProgramMemory | high, 0, lowByte (addr), data);
     
157. } // end of writeFlash
     
158. 
     
159. // convert two hex characters into a byte
     
160. //    returns true if error, false if OK
     
161. bool hexConv (const char * (& pStr), byte & b)
     
162. {
     
163. 
     
164.   if (!isxdigit (pStr [0]) || !isxdigit (pStr [1]))
     
165.   {
     
166.     ShowMessage (MSG_INVALID_HEX_DIGITS);
     
167.     return true;
     
168.   } // end not hex
     
169. 
     
170.   b = *pStr++ - '0';
     
171.   if (b > 9)
     
172.     b -= 7;
     
173. 
     
174.   // high-order nybble
     
175.   b <<= 4;
     
176. 
     
177.   byte b1 = *pStr++ - '0';
     
178.   if (b1 > 9)
     
179.     b1 -= 7;
     
180. 
     
181.   b |= b1;
     
182. 
     
183.   return false;  // OK
     
184. }  // end of hexConv
     
185. // poll the target device until it is ready to be programmed
     
186. void pollUntilReady ()
     
187. {
     
188.   if (currentSignature.timedWrites)
     
189.     delay (10);  // at least 2 x WD_FLASH which is 4.5 mS
     
190.   else
     
191.   {
     
192.     while ((program (pollReady) & 1) == 1)
     
193.     {}  // wait till ready
     
194.   }  // end of if
     
195. }  // end of pollUntilReady
     
196. 
     
197. // shows progress, toggles working LED
     
198. void showProgress ()
     
199. {
     
200.   digitalWrite (workingLED, ! digitalRead (workingLED));
     
201. }  // end of showProgress
     
202. // clear entire temporary page to 0xFF in case we don't write to all of it
     
203. void clearPage ()
     
204. {
     
205.   unsigned int len = currentSignature.pageSize;
     
206.   for (unsigned int i = 0; i < len; i++)
     
207.     writeFlash (i, 0xFF);
     
208. }  // end of clearPage
     
209. // commit page to flash memory
     
210. void commitPage (unsigned long addr)
     
211. {
     
212.   addr >>= 1;  // turn into word address
     
213. 
     
214.   // set the extended (most significant) address byte if necessary
     
215.   byte MSB = (addr >> 16) & 0xFF;
     
216.   if (MSB != lastAddressMSB)
     
217.   {
     
218.     program (loadExtendedAddressByte, 0, MSB);
     
219.     lastAddressMSB = MSB;
     
220.   }  // end if different MSB
     
221. 
     
222.   showProgress ();
     
223. 
     
224.   program (writeProgramMemory, highByte (addr), lowByte (addr));
     
225.   pollUntilReady ();
     
226. 
     
227.   clearPage();  // clear ready for next page full
     
228. }  // end of commitPage
     
229. // write data to temporary buffer, ready for committing
     
230. void writeData (const unsigned long addr, const byte * pData, const int length)
     
231. {
     
232.   // write each byte
     
233.   for (int i = 0; i < length; i++)
     
234.   {
     
235.     unsigned long thisPage = (addr + i) & pagemask;
     
236.     // page changed? commit old one
     
237.     if (thisPage != oldPage && oldPage != NO_PAGE)
     
238.       commitPage (oldPage);
     
239.     // now this is the current page
     
240.     oldPage = thisPage;
     
241.     // put byte into work buffer
     
242.     writeFlash (addr + i, pData [i]);
     
243.   }  // end of for
     
244. 
     
245. }  // end of writeData
     
246. void verifyData (const unsigned long addr, const byte * pData, const int length)
     
247. {
     
248.   // check each byte
     
249.   for (int i = 0; i < length; i++)
     
250.   {
     
251.     unsigned long thisPage = (addr + i) & pagemask;
     
252.     // page changed? show progress
     
253.     if (thisPage != oldPage && oldPage != NO_PAGE)
     
254.       showProgress ();
     
255.     // now this is the current page
     
256.     oldPage = thisPage;
     
257. 
     
258.     byte found = readFlash (addr + i);
     
259.     byte expected = pData [i];
     
260.     if (found != expected)
     
261.       errors++;
     
262.   }  // end of for
     
263. 
     
264. }  // end of verifyData
     
265. 
     
266. /*
     
267.   Line format:
     
268. 
     
269.   :nnaaaatt(data)ss
     
270. 
     
271.   Where:
     
272.   :      = a colon
     
273. 
     
274.   (All of below in hex format)
     
275. 
     
276.   nn     = length of data part
     
277.   aaaa   = address (eg. where to write data)
     
278.   tt     = transaction type
     
279.            00 = data
     
280.            01 = end of file
     
281.            02 = extended segment address (changes high-order byte of the address)
     
282.            03 = start segment address *
     
283.            04 = linear address *
     
284.            05 = start linear address *
     
285.   (data) = variable length data
     
286.   ss     = sumcheck
     
287. 
     
288.               We don't use these
     
289. 
     
290. */
     
291. 
     
292. // returns true if error, false if OK
     
293. bool processLine (const char * pLine, const byte action)
     
294. {
     
295.   if (*pLine++ != ':')
     
296.   {
     
297.     ShowMessage (MSG_LINE_DOES_NOT_START_WITH_COLON);
     
298.     return true;  // error
     
299.   }
     
300. 
     
301.   const int maxHexData = 40;
     
302.   byte hexBuffer [maxHexData];
     
303.   int bytesInLine = 0;
     
304. 
     
305.   if (action == checkFile)
     
306.     if (lineCount++ % 40 == 0)
     
307.       showProgress ();
     
308. 
     
309.   // convert entire line from ASCII into binary
     
310.   while (isxdigit (*pLine))
     
311.   {
     
312.     // can't fit?
     
313.     if (bytesInLine >= maxHexData)
     
314.     {
     
315.       ShowMessage (MSG_LINE_TOO_LONG);
     
316.       return true;
     
317.     } // end if too long
     
318. 
     
319.     if (hexConv (pLine, hexBuffer [bytesInLine++]))
     
320.       return true;
     
321.   }  // end of while
     
322. 
     
323.   if (bytesInLine < 5)
     
324.   {
     
325.     ShowMessage (MSG_LINE_TOO_SHORT);
     
326.     return true;
     
327.   }
     
328. 
     
329.   // sumcheck it
     
330. 
     
331.   byte sumCheck = 0;
     
332.   for (int i = 0; i < (bytesInLine - 1); i++)
     
333.     sumCheck += hexBuffer [i];
     
334. 
     
335.   // 2's complement
     
336.   sumCheck = ~sumCheck + 1;
     
337. 
     
338.   // check sumcheck
     
339.   if (sumCheck != hexBuffer [bytesInLine - 1])
     
340.   {
     
341.     ShowMessage (MSG_BAD_SUMCHECK);
     
342.     return true;
     
343.   }
     
344. 
     
345.   // length of data (eg. how much to write to memory)
     
346.   byte len = hexBuffer [0];
     
347. 
     
348.   // the data length should be the number of bytes, less
     
349.   //   length / address (2) / transaction type / sumcheck
     
350.   if (len != (bytesInLine - 5))
     
351.   {
     
352.     ShowMessage (MSG_LINE_NOT_EXPECTED_LENGTH);
     
353.     return true;
     
354.   }
     
355. 
     
356.   // two bytes of address
     
357.   unsigned long addrH = hexBuffer [1];
     
358.   unsigned long addrL = hexBuffer [2];
     
359. 
     
360.   unsigned long addr = addrL | (addrH << 8);
     
361. 
     
362.   byte recType = hexBuffer [3];
     
363. 
     
364.   switch (recType)
     
365.   {
     
366.     // stuff to be written to memory
     
367.     case hexDataRecord:
     
368.       //lowestAddress  = min (lowestAddress, addr + extendedAddress);
     
369.       lowestAddress = 0x7E00;//I HAD TO FORCE THIS FOR THE ATMEGA328P
     
370.       highestAddress = max (lowestAddress, addr + extendedAddress + len - 1);
     
371.       bytesWritten += len;
     
372. 
     
373.       switch (action)
     
374.       {
     
375.         case checkFile:  // nothing much to do, we do the checks anyway
     
376.           break;
     
377. 
     
378.         case verifyFlash:
     
379.           verifyData (addr + extendedAddress, &hexBuffer [4], len);
     
380.           break;
     
381. 
     
382.         case writeToFlash:
     
383.           writeData (addr + extendedAddress, &hexBuffer [4], len);
     
384.           break;
     
385.       } // end of switch on action
     
386.       break;
     
387. 
     
388.     // end of data
     
389.     case hexEndOfFile:
     
390.       gotEndOfFile = true;
     
391.       break;
     
392. 
     
393.     // we are setting the high-order byte of the address
     
394.     case hexExtendedSegmentAddressRecord:
     
395.       extendedAddress = ((unsigned long) hexBuffer [4]) << 12;
     
396.       break;
     
397. 
     
398.     // ignore these, who cares?
     
399.     case hexStartSegmentAddressRecord:
     
400.     case hexExtendedLinearAddressRecord:
     
401.     case hexStartLinearAddressRecord:
     
402.       break;
     
403. 
     
404.     default:
     
405.       ShowMessage (MSG_UNKNOWN_RECORD_TYPE);
     
406.       return true;
     
407.   }  // end of switch on recType
     
408. 
     
409.   return false;
     
410. } // end of processLine
     
411. 
     
412. //------------------------------------------------------------------------------
     
413. // returns true if error, false if OK
     
414. bool readHexFile (const char * fName, const byte action)
     
415. {
     
416.   const int maxLine = 80;
     
417.   char buffer[maxLine];
     
418.   ifstream sdin (fName);
     
419.   int lineNumber = 0;
     
420.   gotEndOfFile = false;
     
421.   extendedAddress = 0;
     
422.   errors = 0;
     
423.   lowestAddress = 0xFFFFFFFF;
     
424.   //lowestAddress
     
425.   highestAddress = 0;
     
426.   bytesWritten = 0;
     
427.   progressBarCount = 0;
     
428. 
     
429.   pagesize = currentSignature.pageSize;
     
430.   pagemask = ~(pagesize - 1);
     
431.   oldPage = NO_PAGE;
     
432. 
     
433.   // check for open error
     
434.   if (!sdin.is_open())
     
435.   {
     
436.     ShowMessage (MSG_CANNOT_OPEN_FILE);
     
437.     return true;
     
438.   }
     
439. 
     
440.   switch (action)
     
441.   {
     
442.     case checkFile:
     
443.       break;
     
444. 
     
445.     case verifyFlash:
     
446.       break;
     
447. 
     
448.     case writeToFlash:
     
449.       program (progamEnable, chipErase);   // erase it
     
450.       delay (20);  // for Atmega8
     
451.       pollUntilReady ();
     
452.       clearPage();  // clear temporary page
     
453.       break;
     
454.   } // end of switch
     
455. 
     
456.   while (sdin.getline (buffer, maxLine))
     
457.   {
     
458.     lineNumber++;
     
459.     int count = sdin.gcount();
     
460.     if (sdin.fail())
     
461.     {
     
462.       ShowMessage (MSG_LINE_TOO_LONG);
     
463.       return true;
     
464.     }  // end of fail (line too long?)
     
465. 
     
466.     // ignore empty lines
     
467.     if (count > 1)
     
468.     {
     
469.       if (processLine (buffer, action))
     
470.       {
     
471.         return true;  // error
     
472.       }
     
473.     }
     
474.   }    // end of while each line
     
475. 
     
476.   if (!gotEndOfFile)
     
477.   {
     
478.     ShowMessage (MSG_NO_END_OF_FILE_RECORD);
     
479.     return true;
     
480.   }
     
481. 
     
482.   switch (action)
     
483.   {
     
484.     case writeToFlash:
     
485.       // commit final page
     
486.       if (oldPage != NO_PAGE)
     
487.         commitPage (oldPage);
     
488.       break;
     
489. 
     
490.     case verifyFlash:
     
491.       if (errors > 0)
     
492.       {
     
493.         ShowMessage (MSG_VERIFICATION_ERROR);
     
494.         return true;
     
495.       }  // end if
     
496.       break;
     
497. 
     
498.     case checkFile:
     
499.       break;
     
500.   }  // end of switch
     
501. 
     
502.   return false;
     
503. }  // end of readHexFile
     
504. 
     
505. // returns true if managed to enter programming mode
     
506. bool startProgramming ()
     
507. {
     
508. 
     
509.   byte confirm;
     
510.   pinMode (RESET, OUTPUT);
     
511.   digitalWrite (MSPIM_SCK, LOW);
     
512.   pinMode (MSPIM_SCK, OUTPUT);
     
513.   pinMode (BB_MOSI, OUTPUT);
     
514.   //pinMode (BB_MISO, INPUT);
     
515.   unsigned int timeout = 0;
     
516. 
     
517.   // we are in sync if we get back programAcknowledge on the third byte
     
518.   do
     
519.   {
     
520.     // regrouping pause
     
521.     delay (100);
     
522. 
     
523.     // ensure SCK low
     
524.     noInterrupts ();
     
525.     digitalWrite (MSPIM_SCK, LOW);
     
526.     // then pulse reset, see page 309 of datasheet
     
527.     digitalWrite (RESET, HIGH);
     
528.     delayMicroseconds (10);  // pulse for at least 2 clock cycles
     
529.     digitalWrite (RESET, LOW);
     
530.     interrupts ();
     
531. 
     
532.     delay (25);  // wait at least 20 mS
     
533.     //delay (25);
     
534.     noInterrupts ();
     
535.     BB_SPITransfer (progamEnable);
     
536.     BB_SPITransfer (programAcknowledge);
     
537.     confirm = BB_SPITransfer (0);
     
538.     BB_SPITransfer (0);
     
539.     interrupts ();
     
540. 
     
541.     if (confirm != programAcknowledge)
     
542.     {
     
543.       if (timeout++ >= ENTER_PROGRAMMING_ATTEMPTS)
     
544.         return false;
     
545.     }  // end of not entered programming mode
     
546. 
     
547.   } while (confirm != programAcknowledge);
     
548.   return true;  // entered programming mode OK
     
549. }  // end of startProgramming
     
550. 
     
551. void stopProgramming ()
     
552. {
     
553.   // turn off pull-ups
     
554.   digitalWrite (RESET, LOW);
     
555.   digitalWrite (MSPIM_SCK, LOW);
     
556.   digitalWrite (BB_MOSI, LOW);
     
557.   digitalWrite (BB_MISO, LOW);
     
558. 
     
559.   // set everything back to inputs
     
560.   pinMode (RESET, INPUT);
     
561.   pinMode (MSPIM_SCK, INPUT);
     
562.   pinMode (BB_MOSI, INPUT);
     
563.   pinMode (BB_MISO, INPUT);
     
564. 
     
565. } // end of stopProgramming
     
566. 
     
567. void getSignature ()
     
568. {
     
569.   foundSig = -1;
     
570.   lastAddressMSB = 0;
     
571. 
     
572.   byte sig [3];
     
573.   // Serial.print (F("Signature = "));
     
574. 
     
575. 
     
576. 
     
577. 
     
578.   for (byte i = 0; i < 3; i++)
     
579.   {
     
580.     sig [i] = program (readSignatureByte, 0, i);
     
581.     //   showHex (sig [i]);
     
582.   }  // end for each signature byte
     
583.   Serial.println ("");
     
584.   for (unsigned int j = 0; j < NUMITEMS (signatures); j++)
     
585.   {
     
586.     memcpy_P (&currentSignature, &signatures [j], sizeof currentSignature);
     
587. 
     
588.     if (memcmp (sig, currentSignature.sig, sizeof sig) == 0)
     
589.     {
     
590.       foundSig = j;
     
591.       // make sure extended address is zero to match lastAddressMSB variable
     
592.       program (loadExtendedAddressByte, 0, 0);
     
593.       return;
     
594.     }  // end of signature found
     
595.   }  // end of for each signature
     
596. 
     
597.   ShowMessage (MSG_UNRECOGNIZED_SIGNATURE);
     
598. }  // end of getSignature
     
599. 
     
600. void getFuseBytes ()
     
601. {
     
602.   fuses [lowFuse]   = program (readLowFuseByte, readLowFuseByteArg2);
     
603.   fuses [highFuse]  = program (readHighFuseByte, readHighFuseByteArg2);
     
604.   fuses [extFuse]   = program (readExtendedFuseByte, readExtendedFuseByteArg2);
     
605.   fuses [lockByte]  = program (readLockByte, readLockByteArg2);
     
606.   fuses [calibrationByte]  = program (readCalibrationByte);
     
607. 
     
608.   Serial.print (F("LFuse = "));
     
609.   showHex (fuses [lowFuse], true);
     
610.   Serial.print (F("HFuse = "));
     
611.   showHex (fuses [highFuse], true);
     
612.   Serial.print (F("EFuse = "));
     
613.   showHex (fuses [extFuse], true);
     
614.   Serial.print (F("Lock byte = "));
     
615.   showHex (fuses [lockByte], true);
     
616.   Serial.print (F("Clock calibration = "));
     
617.   showHex (fuses [calibrationByte], true);
     
618. 
     
619. }  // end of getFuseBytes
     
620. 
     
621. 
     
622. // write specified value to specified fuse/lock byte
     
623. void writeFuse (const byte newValue, const byte instruction)
     
624. {
     
625.   //  if (newValue == 0)
     
626.   //    return;  // ignore
     
627. 
     
628.   program (progamEnable, instruction, 0, newValue);
     
629.   pollUntilReady ();
     
630. }  // end of writeFuse
     
631. 
     
632. // returns true if error, false if OK
     
633. bool updateFuses (const bool writeIt)
     
634. {
     
635.   unsigned long addr;
     
636.   unsigned int  len;
     
637. 
     
638.   byte fusenumber = currentSignature.fuseWithBootloaderSize;
     
639. 
     
640.   // if no fuse, can't change it
     
641.   if (fusenumber == NO_FUSE)
     
642.   {
     
643.     //    ShowMessage (MSG_NO_BOOTLOADER_FUSE);   // maybe this doesn't matter?
     
644.     return false;  // ok return
     
645.   }
     
646. 
     
647.   addr = currentSignature.flashSize;
     
648.   len = currentSignature.baseBootSize;
     
649. 
     
650.   if (lowestAddress == 0)
     
651.   {
     
652.     // don't use bootloader
     
653.     fuses [fusenumber] |= 1;
     
654.   }
     
655.   else
     
656.   {
     
657.     byte newval = 0xFF;
     
658. 
     
659.     if (lowestAddress == (addr - len))
     
660.       newval = 3;
     
661.     else if (lowestAddress == (addr - len * 2))
     
662.       newval = 2;
     
663.     else if (lowestAddress == (addr - len * 4))
     
664.       newval = 1;
     
665.     else if (lowestAddress == (addr - len * 8))
     
666.       newval = 0;
     
667.     else
     
668.     {
     
669.       ShowMessage (MSG_BAD_START_ADDRESS);
     
670.       return true;
     
671.     }
     
672. 
     
673.     if (newval != 0xFF)
     
674.     {
     
675.       newval <<= 1;
     
676.       fuses [fusenumber] &= ~0x07;   // also program (clear) "boot into bootloader" bit
     
677.       fuses [fusenumber] |= newval;
     
678.     }  // if valid
     
679. 
     
680.   }  // if not address 0
     
681. 
     
682.   if (writeIt)
     
683.   {
     
684.     writeFuse (fuses [fusenumber], fuseCommands [fusenumber]);
     
685. 
     
686.   }
     
687. 
     
688.   return false;
     
689. }  // end of updateFuses
     
690. 
     
691. // returns true if error, false if OK
     
692. bool chooseInputFile ()
     
693. {
     
694. 
     
695.   if (readHexFile(name, checkFile))
     
696.   {
     
697.     return true;  // error, don't attempt to write
     
698.   }
     
699. 
     
700.   // check file would fit into device memory
     
701.   if (highestAddress > currentSignature.flashSize)
     
702.   {
     
703.     ShowMessage (MSG_FILE_TOO_LARGE_FOR_FLASH);
     
704.     return true;
     
705.   }
     
706. 
     
707.   // check start address makes sense
     
708.   if (updateFuses (false))
     
709.   {
     
710.     return true;
     
711.   }
     
712. 
     
713.   return false;
     
714. }  // end of chooseInputFile
     
715. 
     
716. // returns true if OK, false on error
     
717. bool writeFlashContents ()
     
718. {
     
719. 
     
720.   errors = 0;
     
721. 
     
722.   if (chooseInputFile ())
     
723.     return false;
     
724. 
     
725. 
     
726.   // ensure back in programming mode
     
727.   if (!startProgramming ())
     
728.     return false;
     
729. 
     
730.   // now commit to flash
     
731.   if (readHexFile(name, writeToFlash))
     
732.     return false;
     
733. 
     
734.   // turn ready LED on during verification
     
735.   digitalWrite (readyLED, HIGH);
     
736. 
     
737.   // verify
     
738.   if (readHexFile(name, verifyFlash))
     
739.     return false;
     
740. 
     
741.   // now fix up fuses so we can boot
     
742.   if (errors == 0)
     
743.     updateFuses (true);
     
744. 
     
745.   return errors == 0;
     
746. }  // end of writeFlashContents

复制代码

yzw92

耗电问题

wing

看上去代码有点长...
另外,这块和耗电有什么关系么?

eddiewwm

這是 AVR ATmega328P 的燒寫器，跟耗電沒關係！

活得精彩

这个可以作为 LGT328P的编程器使用吗？

eddiewwm

活得精彩 发表于 2019-10-17 10:24
这个可以作为 LGT328P的编程器使用吗？

不可以，LGT8F328P 的燒寫方法跟 ATmega328P 不同。