Arduino UNO和Mega2560的口定义是一样的吗

　　打开arduino IDE 软件，菜单栏文件--》示例--》ArduinoISP，这就是官方的isp下载器代码。直接打开
　　
　　这里介绍下icsp口的定义
　　味噌（50个）5V
　　SCK（52名）MOSI（51个）
　　RST地线
　　洋洋装着这个电容是10uf的，接地
　　
　　当然也能这样接，这样要下载的板子就不用再接电源了
　　
　　这里下，Arduino UNO和Mega2560的口定义是不一样的，需要按修改。程直接操作是不能
　　改变的地方是这样的代码
　　#define USE_OLD_STYLE_WIRING
　　#ifdef USE_OLD_STYLE_WIRING
　　#define PIN_MOSI 11
　　#define PIN_MISO 12
　　#define PIN_SCK 13
　　#endif
　　改成这个改成这个因为mega2560的原因就是这样定义，具体可查看手册
　　#define USE_OLD_STYLE_WIRING //此处别忘记取消注释
　　#ifdef USE_OLD_STYLE_WIRING
　　#define PIN_MOSI 51 //mega2560的MOSI 11
　　#define PIN_MISO 50 //mega2560的MISO 12
　　#define PIN_SCK 52 //mega2560的SCK 13
　　#endif
　　下面附上修改的代码
　　// ArduinoISP
　　//reset引脚接10uf电容 到 gnd ，就是10号引脚
　　// Copyright （c） 2008-2011 Randall Bohn
　　// If you require a license， see
　　// ［url=http://www.opensource.org/licenses/bsd-license.php］http://www.opensource.org/licenses/bsd-license.php［/url］
　　//
　　// This sketch turns the Arduino into a AVRISP
　　// using the following arduino pins：
　　//
　　// Pin 10 is used to reset the target microcontroller.
　　//
　　// By default， the hardware SPI pins MISO， MOSI and SCK pins are used
　　// to communicate with the target. On all Arduinos， these pins can be found
　　// on the ICSP/SPI header：
　　//
　　// MISO °。 。 5V （！） Avoid this pin on Due， Zero.。。
　　// SCK 。 。 MOSI
　　// 。 。 GND
　　//
　　// On some Arduinos （Uno，。。.）， pins MOSI， MISO and SCK are the same pins
　　// as digital pin 11， 12 and 13， respectively. That is why many tutorials
　　// instruct you to hook up the target to these pins. If you find this wiring
　　// more practical， have a define USE_OLD_STYLE_WIRING. This will work even
　　// even when not using an Uno. （On an Uno this is not needed）。
　　//
　　// Alternatively you can use any other digital pin by configuring software （‘BitBanged’）
　　// SPI and having appropriate defines for PIN_MOSI， PIN_MISO and PIN_SCK.
　　//
　　// IMPORTANT： When using an Arduino that is not 5V tolerant （Due， Zero， 。。.）
　　// as the programmer， make sure to not expose any of the programmer‘s pins to 5V.
　　// A simple way to accomplish this is to power the complete system （programmer
　　// and target） at 3V3.
　　//
　　// Put an LED （with resistor） on the following pins：
　　// 9： Heartbeat - shows the programmer is running
　　// 8： Error - Lights up if something goes wrong （use red if that makes sense）
　　// 7： Programming - In communication with the slave
　　//
　　#include “Arduino.h”
　　#undef SERIAL
　　#define PROG_FLICKER true
　　// Configure SPI clock （in Hz）。
　　// E.g. for an attiny @128 kHz： the datasheet states that both the high
　　// and low spi clock pulse must be 》 2 cpu cycles， so take 3 cycles i.e.
　　// divide target f_cpu by 6：
　　// #define SPI_CLOCK （128000/6）
　　//
　　// A clock slow enough for an attiny85 @ 1MHz， is a reasonable default：
　　#define SPI_CLOCK （1000000/6）
　　// Select hardware or software SPI， depending on SPI clock.
　　// Currently only for AVR， for other archs （Due， Zero，。。.），
　　// hardware SPI is probably too fast anyway.
　　#if defined（ARDUINO_ARCH_AVR）
　　#if SPI_CLOCK 》 （F_CPU / 128）
　　#define USE_HARDWARE_SPI
　　#endif
　　#endif
　　// Configure which pins to use：
　　// The standard pin configuration.
　　#ifndef ARDUINO_HOODLOADER2
　　#define RESET 10 // Use pin 10 to reset the target rather than SS
　　#define LED_HB 9
　　#define LED_ERR 8
　　#define LED_PMODE 7
　　// Uncomment following line to use the old Uno style wiring
　　// （using pin 11， 12 and 13 instead of the SPI header） on Leonardo， Due.。。
　　#define USE_OLD_STYLE_WIRING //此处别忘记取消注释
　　#ifdef USE_OLD_STYLE_WIRING
　　#define PIN_MOSI 51 //mega2560的MOSI 11
　　#define PIN_MISO 50 //mega2560的MISO 12
　　#define PIN_SCK 52 //mega2560的SCK 13
　　#endif
　　// HOODLOADER2 means running sketches on the atmega16u2
　　// serial converter chips on Uno or Mega boards.
　　// We must use pins that are broken out：
　　#else
　　#define RESET 10
　　#define LED_HB 7
　　#define LED_ERR 6
　　#define LED_PMODE 5
　　#endif
　　By default， use hardware SPI pins：
　　//#ifndef PIN_MOSI
　　//#define PIN_MOSI MOSI
　　//#endif
　　//
　　//#ifndef PIN_MISO
　　//#define PIN_MISO MISO
　　//#endif
　　//
　　//#ifndef PIN_SCK
　　//#define PIN_SCK SCK
　　//#endif
　　//
　　Force bitbanged SPI if not using the hardware SPI pins：
　　//#if （PIN_MISO ！= MISO） || （PIN_MOSI ！= MOSI） || （PIN_SCK ！= SCK）
　　//#undef USE_HARDWARE_SPI
　　//#endif
　　// Configure the serial port to use.
　　//
　　// Prefer the USB virtual serial port （aka. native USB port）， if the Arduino has one：
　　// - it does not autoreset （except for the magic baud rate of 1200）。
　　// - it is more reliable because of USB handshaking.
　　//
　　// Leonardo and similar have an USB virtual serial port： ’Serial‘。
　　// Due and Zero have an USB virtual serial port： ’SerialUSB‘。
　　//
　　// On the Due and Zero， ’Serial‘ can be used too， provided you disable autoreset.
　　// To use ’Serial‘： #define SERIAL Serial
　　#ifdef SERIAL_PORT_USBVIRTUAL
　　#define SERIAL SERIAL_PORT_USBVIRTUAL
　　#else
　　#define SERIAL Serial
　　#endif
　　// Configure the baud rate：
　　#define BAUDRATE 19200
　　// #define BAUDRATE 115200
　　// #define BAUDRATE 1000000
　　#define HWVER 2
　　#define SWMAJ 1
　　#define SWMIN 18
　　// STK Definitions
　　#define STK_OK 0x10
　　#define STK_FAILED 0x11
　　#define STK_UNKNOWN 0x12
　　#define STK_INSYNC 0x14
　　#define STK_NOSYNC 0x15
　　#define CRC_EOP 0x20 //ok it is a space.。。
　　void pulse（int pin， int times）;
　　#ifdef USE_HARDWARE_SPI
　　#include “SPI.h”
　　#else
　　#define SPI_MODE0 0x00
　　class SPISettings {
　　public：
　　// clock is in Hz
　　SPISettings（uint32_t clock， uint8_t bitOrder， uint8_t dataMode） ： clock（clock）{
　　（void） bitOrder;
　　（void） dataMode;
　　};
　　private：
　　uint32_t clock;
　　friend class BitBangedSPI;
　　};
　　class BitBangedSPI {
　　public：
　　void begin（） {
　　digitalWrite（PIN_SCK， LOW）;
　　digitalWrite（PIN_MOSI， LOW）;
　　pinMode（PIN_SCK， OUTPUT）;
　　pinMode（PIN_MOSI， OUTPUT）;
　　pinMode（PIN_MISO， INPUT）;
　　}
　　void beginTransaction（SPISettings settings） {
　　pulseWidth = （500000 + settings.clock - 1） / settings.clock;
　　if （pulseWidth == 0）
　　pulseWidth = 1;
　　}
　　void end（） {}
　　uint8_t transfer （uint8_t b） {
　　for （unsigned int i = 0; i 《 8; ++i） {
　　digitalWrite（PIN_MOSI， （b & 0x80） ？ HIGH ： LOW）;
　　digitalWrite（PIN_SCK， HIGH）;
　　delayMicroseconds（pulseWidth）;
　　b = （b 《《 1） | digitalRead（PIN_MISO）;
　　digitalWrite（PIN_SCK， LOW）; // slow pulse
　　delayMicroseconds（pulseWidth）;
　　}
　　return b;
　　}
　　private：
　　unsigned long pulseWidth; // in microseconds
　　};
　　static BitBangedSPI SPI;
　　#endif
　　void setup（） {
　　SERIAL.begin（BAUDRATE）;
　　pinMode（LED_PMODE， OUTPUT）;
　　pulse（LED_PMODE， 2）;
　　pinMode（LED_ERR， OUTPUT）;
　　pulse（LED_ERR， 2）;
　　pinMode（LED_HB， OUTPUT）;
　　pulse（LED_HB， 2）;
　　}
　　int error = 0;
　　int pmode = 0;
　　// address for reading and writing， set by ’U‘ command
　　unsigned int here;
　　uint8_t buff［256］; // global block storage
　　#define beget16（addr） （*addr * 256 + *（addr+1） ）
　　typedef struct param {
　　uint8_t devicecode;
　　uint8_t revision;
　　uint8_t progtype;
　　uint8_t parmode;
　　uint8_t polling;
　　uint8_t selftimed;
　　uint8_t lockbytes;
　　uint8_t fusebytes;
　　uint8_t flashpoll;
　　uint16_t eeprompoll;
　　uint16_t pagesize;
　　uint16_t eepromsize;
　　uint32_t flashsize;
　　}
　　parameter;
　　parameter param;
　　// this provides a heartbeat on pin 9， so you can tell the software is running.
　　uint8_t hbval = 128;
　　int8_t hbdelta = 8;
　　void heartbeat（） {
　　static unsigned long last_time = 0;
　　unsigned long now = millis（）;
　　if （（now - last_time） 《 40）
　　return;
　　last_time = now;
　　if （hbval 》 192） hbdelta = -hbdelta;
　　if （hbval 《 32） hbdelta = -hbdelta;
　　hbval += hbdelta;
　　analogWrite（LED_HB， hbval）;
　　}
　　static bool rst_active_high;
　　void reset_target（bool reset） {
　　digitalWrite（RESET， （（reset && rst_active_high） || （！reset && ！rst_active_high）） ？ HIGH ： LOW）;
　　}
　　void loop（void） {
　　// is pmode active？
　　if （pmode） {
　　digitalWrite（LED_PMODE， HIGH）;
　　} else {
　　digitalWrite（LED_PMODE， LOW）;
　　}
　　// is there an error？
　　if （error） {
　　digitalWrite（LED_ERR， HIGH）;
　　} else {
　　digitalWrite（LED_ERR， LOW）;
　　}
　　// light the heartbeat LED
　　heartbeat（）;
　　if （SERIAL.available（）） {
　　avrisp（）;
　　}
　　}
　　uint8_t getch（） {
　　while （！SERIAL.available（））;
　　return SERIAL.read（）;
　　}
　　void fill（int n） {
　　for （int x = 0; x 《 n; x++） {
　　buff［x］ = getch（）;
　　}
　　}
　　#define PTIME 30
　　void pulse（int pin， int times） {
　　do {
　　digitalWrite（pin， HIGH）;
　　delay（PTIME）;
　　digitalWrite（pin， LOW）;
　　delay（PTIME）;
　　} while （times--）;
　　}
　　void prog_lamp（int state） {
　　if （PROG_FLICKER） {
　　digitalWrite（LED_PMODE， state）;
　　}
　　}
　　uint8_t spi_transaction（uint8_t a， uint8_t b， uint8_t c， uint8_t d） {
　　SPI.transfer（a）;
　　SPI.transfer（b）;
　　SPI.transfer（c）;
　　return SPI.transfer（d）;
　　}
　　void empty_reply（） {
　　if （CRC_EOP == getch（）） {
　　SERIAL.print（（char）STK_INSYNC）;
　　SERIAL.print（（char）STK_OK）;
　　} else {
　　error++;
　　SERIAL.print（（char）STK_NOSYNC）;
　　}
　　}
　　void breply（uint8_t b） {
　　if （CRC_EOP == getch（）） {
　　SERIAL.print（（char）STK_INSYNC）;
　　SERIAL.print（（char）b）;
　　SERIAL.print（（char）STK_OK）;
　　} else {
　　error++;
　　SERIAL.print（（char）STK_NOSYNC）;
　　}
　　}
　　void get_version（uint8_t c） {
　　switch （c） {
　　case 0x80：
　　breply（HWVER）;
　　break;
　　case 0x81：
　　breply（SWMAJ）;
　　break;
　　case 0x82：
　　breply（SWMIN）;
　　break;
　　case 0x93：
　　breply（’S‘）; // serial programmer
　　break;
　　default：
　　breply（0）;
　　}
　　}
　　void set_parameters（） {
　　// call this after reading paramter packet into buff［］
　　param.devicecode = buff［0］;
　　param.revision = buff［1］;
　　param.progtype = buff［2］;
　　param.parmode = buff［3］;
　　param.polling = buff［4］;
　　param.selftimed = buff［5］;
　　param.lockbytes = buff［6］;
　　param.fusebytes = buff［7］;
　　param.flashpoll = buff［8］;
　　// ignore buff［9］ （= buff［8］）
　　// following are 16 bits （big endian）
　　param.eeprompoll = beget16（&buff［10］）;
　　param.pagesize = beget16（&buff［12］）;
　　param.eepromsize = beget16（&buff［14］）;
　　// 32 bits flashsize （big endian）
　　param.flashsize = buff［16］ * 0x01000000
　　+ buff［17］ * 0x00010000
　　+ buff［18］ * 0x00000100
　　+ buff［19］;
　　// avr devices have active low reset， at89sx are active high
　　rst_active_high = （param.devicecode 》= 0xe0）;
　　}
　　void start_pmode（） {
　　// Reset target before driving PIN_SCK or PIN_MOSI
　　// SPI.begin（） will configure SS as output，
　　// so SPI master mode is selected.
　　// We have defined RESET as pin 10，
　　// which for many arduino’s is not the SS pin.
　　// So we have to configure RESET as output here，
　　// （reset_target（） first sets the correct level）
　　reset_target（true）;
　　pinMode（RESET， OUTPUT）;
　　SPI.begin（）;
　　SPI.beginTransaction（SPISettings（SPI_CLOCK， MSBFIRST， SPI_MODE0））;
　　// See avr datasheets， chapter “SERIAL_PRG Programming Algorithm”：
　　// Pulse RESET after PIN_SCK is low：
　　digitalWrite（PIN_SCK， LOW）;
　　delay（20）; // discharge PIN_SCK， value arbitrally chosen
　　reset_target（false）;
　　// Pulse must be minimum 2 target CPU clock cycles
　　// so 100 usec is ok for CPU speeds above 20KHz
　　delayMicroseconds（100）;
　　reset_target（true）;
　　// Send the enable programming command：
　　delay（50）; // datasheet： must be 》 20 msec
　　spi_transaction（0xAC， 0x53， 0x00， 0x00）;
　　pmode = 1;
　　}
　　void end_pmode（） {
　　SPI.end（）;
　　// We‘re about to take the target out of reset
　　// so configure SPI pins as input
　　pinMode（PIN_MOSI， INPUT）;
　　pinMode（PIN_SCK， INPUT）;
　　reset_target（false）;
　　pinMode（RESET， INPUT）;
　　pmode = 0;
　　}
　　void universal（） {
　　uint8_t ch;
　　fill（4）;
　　ch = spi_transaction（buff［0］， buff［1］， buff［2］， buff［3］）;
　　breply（ch）;
　　}
　　void flash（uint8_t hilo， unsigned int addr， uint8_t data） {
　　spi_transaction（0x40 + 8 * hilo，
　　addr 》》 8 & 0xFF，
　　addr & 0xFF，
　　data）;
　　}
　　void commit（unsigned int addr） {
　　if （PROG_FLICKER） {
　　prog_lamp（LOW）;
　　}
　　spi_transaction（0x4C， （addr 》》 8） & 0xFF， addr & 0xFF， 0）;
　　if （PROG_FLICKER） {
　　delay（PTIME）;
　　prog_lamp（HIGH）;
　　}
　　}
　　unsigned int current_page（） {
　　if （param.pagesize == 32） {
　　return here & 0xFFFFFFF0;
　　}
　　if （param.pagesize == 64） {
　　return here & 0xFFFFFFE0;
　　}
　　if （param.pagesize == 128） {
　　return here & 0xFFFFFFC0;
　　}
　　if （param.pagesize == 256） {
　　return here & 0xFFFFFF80;
　　}
　　return here;
　　}
　　void write_flash（int length） {
　　fill（length）;
　　if （CRC_EOP == getch（）） {
　　SERIAL.print（（char） STK_INSYNC）;
　　SERIAL.print（（char） write_flash_pages（length））;
　　} else {
　　error++;
　　SERIAL.print（（char） STK_NOSYNC）;
　　}
　　}
　　uint8_t write_flash_pages（int length） {
　　int x = 0;
　　unsigned int page = current_page（）;
　　while （x 《 length） {
　　if （page ！= current_page（）） {
　　commit（page）;
　　page = current_page（）;
　　}
　　flash（LOW， here， buff［x++］）;
　　flash（HIGH， here， buff［x++］）;
　　here++;
　　}
　　commit（page）;
　　return STK_OK;
　　}
　　#define EECHUNK （32）
　　uint8_t write_eeprom（unsigned int length） {
　　// here is a word address， get the byte address
　　unsigned int start = here * 2;
　　unsigned int remaining = length;
　　if （length 》 param.eepromsize） {
　　error++;
　　return STK_FAILED;
　　}
　　while （remaining 》 EECHUNK） {
　　write_eeprom_chunk（start， EECHUNK）;
　　start += EECHUNK;
　　remaining -= EECHUNK;
　　}
　　write_eeprom_chunk（start， remaining）;
　　return STK_OK;
　　}
　　// write （length） bytes， （start） is a byte address
　　uint8_t write_eeprom_chunk（unsigned int start， unsigned int length） {
　　// this writes byte-by-byte，
　　// page writing may be faster （4 bytes at a time）
　　fill（length）;
　　prog_lamp（LOW）;
　　for （unsigned int x = 0; x 《 length; x++） {
　　unsigned int addr = start + x;
　　spi_transaction（0xC0， （addr 》》 8） & 0xFF， addr & 0xFF， buff［x］）;
　　delay（45）;
　　}
　　prog_lamp（HIGH）;
　　return STK_OK;
　　}
　　void program_page（） {
　　char result = （char） STK_FAILED;
　　unsigned int length = 256 * getch（）;
　　length += getch（）;
　　char memtype = getch（）;
　　// flash memory @here， （length） bytes
　　if （memtype == ’F‘） {
　　write_flash（length）;
　　return;
　　}
　　if （memtype == ’E‘） {
　　result = （char）write_eeprom（length）;
　　if （CRC_EOP == getch（）） {
　　SERIAL.print（（char） STK_INSYNC）;
　　SERIAL.print（result）;
　　} else {
　　error++;
　　SERIAL.print（（char） STK_NOSYNC）;
　　}
　　return;
　　}
　　SERIAL.print（（char）STK_FAILED）;
　　return;
　　}
　　uint8_t flash_read（uint8_t hilo， unsigned int addr） {
　　return spi_transaction（0x20 + hilo * 8，
　　（addr 》》 8） & 0xFF，
　　addr & 0xFF，
　　0）;
　　}
　　char flash_read_page（int length） {
　　for （int x = 0; x 《 length; x += 2） {
　　uint8_t low = flash_read（LOW， here）;
　　SERIAL.print（（char） low）;
　　uint8_t high = flash_read（HIGH， here）;
　　SERIAL.print（（char） high）;
　　here++;
　　}
　　return STK_OK;
　　}
　　char eeprom_read_page（int length） {
　　// here again we have a word address
　　int start = here * 2;
　　for （int x = 0; x 《 length; x++） {
　　int addr = start + x;
　　uint8_t ee = spi_transaction（0xA0， （addr 》》 8） & 0xFF， addr & 0xFF， 0xFF）;
　　SERIAL.print（（char） ee）;
　　}
　　return STK_OK;
　　}
　　void read_page（） {
　　char result = （char）STK_FAILED;
　　int length = 256 * getch（）;
　　length += getch（）;
　　char memtype = getch（）;
　　if （CRC_EOP ！= getch（）） {
　　error++;
　　SERIAL.print（（char） STK_NOSYNC）;
　　return;
　　}
　　SERIAL.print（（char） STK_INSYNC）;
　　if （memtype == ’F‘） result = flash_read_page（length）;
　　if （memtype == ’E‘） result = eeprom_read_page（length）;
　　SERIAL.print（result）;
　　}
　　void read_signature（） {
　　if （CRC_EOP ！= getch（）） {
　　error++;
　　SERIAL.print（（char） STK_NOSYNC）;
　　return;
　　}
　　SERIAL.print（（char） STK_INSYNC）;
　　uint8_t high = spi_transaction（0x30， 0x00， 0x00， 0x00）;
　　SERIAL.print（（char） high）;
　　uint8_t middle = spi_transaction（0x30， 0x00， 0x01， 0x00）;
　　SERIAL.print（（char） middle）;
　　uint8_t low = spi_transaction（0x30， 0x00， 0x02， 0x00）;
　　SERIAL.print（（char） low）;
　　SERIAL.print（（char） STK_OK）;
　　}
　　//
　　//
　　void avrisp（） {
　　uint8_t ch = getch（）;
　　switch （ch） {
　　case ’0‘： // signon
　　error = 0;
　　empty_reply（）;
　　break;
　　case ’1‘：
　　if （getch（） == CRC_EOP） {
　　SERIAL.print（（char） STK_INSYNC）;
　　SERIAL.print（“AVR ISP”）;
　　SERIAL.print（（char） STK_OK）;
　　}
　　else {
　　error++;
　　SERIAL.print（（char） STK_NOSYNC）;
　　}
　　break;
　　case ’A‘：
　　get_version（getch（））;
　　break;
　　case ’B‘：
　　fill（20）;
　　set_parameters（）;
　　empty_reply（）;
　　break;
　　case ’E‘： // extended parameters - ignore for now
　　fill（5）;
　　empty_reply（）;
　　break;
　　case ’P‘：
　　if （！pmode）
　　start_pmode（）;
　　empty_reply（）;
　　break;
　　case ’U‘： // set address （word）
　　here = getch（）;
　　here += 256 * getch（）;
　　empty_reply（）;
　　break;
　　case 0x60： //STK_PROG_FLASH
　　getch（）; // low addr
　　getch（）; // high addr
　　empty_reply（）;
　　break;
　　case 0x61： //STK_PROG_DATA
　　getch（）; // data
　　empty_reply（）;
　　break;
　　case 0x64： //STK_PROG_PAGE
　　program_page（）;
　　break;
　　case 0x74： //STK_READ_PAGE ’t‘
　　read_page（）;
　　break;
　　case ’V‘： //0x56
　　universal（）;
　　break;
　　case ’Q‘： //0x51
　　error = 0;
　　end_pmode（）;
　　empty_reply（）;
　　break;
　　case 0x75： //STK_READ_SIGN ’u‘
　　read_signature（）;
　　break;
　　// expecting a command， not CRC_EOP
　　// this is how we can get back in sync
　　case CRC_EOP：
　　error++;
　　SERIAL.print（（char） STK_NOSYNC）;
　　break;
　　// anything else we will return STK_UNKNOWN
　　default：
　　error++;
　　if （CRC_EOP == getch（））
　　SERIAL.print（（char）STK_UNKNOWN）;
　　else
　　SERIAL.print（（char）STK_NOSYNC）;
　　}
　　}
　　
　　接下来就去引导加载程序通过这个板子烧到目标板子里面，首先在菜单里面工具-》编程器-》arduino as isp
　　
　　选择选择开发板型号菜单的-》工具-》开发板：-》arduino/genuino mega或mega 2560
　　
　　选择处理器菜单-》工具-》处理器-》atmega2560（Mega 2560）
　　
　　烧写写引导程序菜单-》工具-》烧录引导程序
　　
　　亮灯会一闪一闪，就在烧写了，电容一定要接上，菜烧不了，我是这样。