آموزش برنامه نویسی AVR با استفاده از بوت لودر و نرم افزار آردوینو

در واقع بوت لودر فایل هگزی بر روی میکروکنترلر می باشد که این اجازه را به ما میدهد تا پس از روشن شدن میکروکنترلر بتوان از طریق درگاه UART میکروکنترلر را پروگرام کنیم. این شبیه به BIOS است که بر روی کامپیوتر اجرا می شود. در این آموزش قصد داریم تا بوت لودر آردوینو را بر روی میکروکنترلر Atmega8 انتقال دهیم و سپس با استفاده از مبدل USB to TTL و نرم افزار Arduino IDE میکروکنترلر Atmega8 را پروگرام کنیم. در ادامه با مرجع تخصصی بردهای امبدد به زبان فارسی، دیجی اسپارک همراه باشید.

انتقال بوت لودر به میکروکنترلر Atmega8

ابتدا مدار را طبق نقشه زیر بر روی بِردبُرد ببندید و سپس کد را بر روی برد آردوینو آپلود کنید. با این کار بوت لودر بر روی میکروکنترلر منتقل می‌شود. سریال مانیتور را باز کنید تا از اینکه بوت لودر به طور صحیح انتقال یافته و هیچ خطایی وجود ندارد مطمئن شوید.

کدهای زیر مخصوص بوت لودر برای آی سی میکرو هستند. کافیست یکبار روی آی سی آپلود شوند. پس از آن امکان پروگرام کردن تراشه‌های میکروکنترلر با مبدل USB to TTL وجود دارد. بنابراین کدهای زیر را کپی کرده و بر روی برد آردوینو آپلود کنید. کتابخانه optiLoader.h را همراه با کد زیر میتوانید از لینک دانلود فرمایید.

// optiLoader.pde
//
// this sketch allows an Arduino to program Optiboot onto any other
// Arduino-like device containing ATmega8, ATmega168, or ATmega328
// microcontroller chips.
//
// Copyright (c) 2011, 2015 by Bill Westfield ("WestfW")

//-------------------------------------------------------------------------------------
// "MIT Open Source Software License":
// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in the
// Software without restriction, including without limitation the rights to use, copy,
// modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//-------------------------------------------------------------------------------------

//
// this sketch allows an Arduino to program Optiboot onto any other
// Arduino-like device containing ATmega8, ATmega168, or ATmega328
// microcontroller chips.
//
// It is based on AVRISP
//
// Designed to connect to a generic programming cable,
// using the following pins:
// ۱۰: slave reset
// ۱۱: MOSI
// ۱۲: MISO
// ۱۳: SCK
//  ۹: Power to external chip.
//     This is a little questionable, since the power it is legal to draw
//     from a PIC pin is pretty close to the power consumption of an AVR
//     chip being programmed.  But it permits the target to be entirely
//     powered down for safe reconnection of the programmer to additional
//     targets, and it seems to work for most Arduinos.  If the target board
//     contains additional circuitry and is expected to draw more than 40mA,
//     connect the target power to a stronger source of +5V.  Do not use pin
//     ۹ to power more complex Arduino boards that draw more than 40mA, such
//     as the Arduino Uno Ethernet !
//
// If the aim is to reprogram the bootloader in one Arduino using another
// Arudino as the programmer, you can just use jumpers between the connectors
// on the Arduino board.  In this case, connect:
// Pin 13 to Pin 13
// Pin 12 to Pin 12
// Pin 11 to Pin 11
// Pin 10 (of "programmer") to RESET (of "target" (on the "power" connector))
// +۵V to +5V and GND to GND.  Only the "programmer" board should be powered
//     by USB or external power.
//
// ----------------------------------------------------------------------

// The following credits are from AVRISP.  It turns out that there isn't
// a lot of AVRISP left in this sketch, but probably if AVRISP had never
// existed,  this sketch would not have been written.
//
// October 2009 by David A. Mellis
// - Added support for the read signature command
//
// February 2009 by Randall Bohn
// - Added support for writing to EEPROM (what took so long?)
// Windows users should consider WinAVR's avrdude instead of the
// avrdude included with Arduino software.
//
// January 2008 by Randall Bohn
// - Thanks to Amplificar for helping me with the STK500 protocol
// - The AVRISP/STK500 (mk I) protocol is used in the arduino bootloader
// - The SPI functions herein were developed for the AVR910_ARD programmer
// - More information at http://code.google.com/p/mega-isp


#include <avr/pgmspace.h>
#include "optiLoader.h"

char Arduino_preprocessor_hint;

/*
   Pins to target
*/
#define SCK 13
#define MISO 12
#define MOSI 11
#define RESET 10
#define POWER 9

// STK Definitions; we can still use these as return codes
#define STK_OK 0x10
#define STK_FAILED 0x11


// Useful message printing definitions
#define fp(string) flashprint(PSTR(string));
#define debug(string) // flashprint(PSTR(string));
#define error(string) flashprint(PSTR(string));

// Forward references
void pulse(int pin, int times);
void read_image(const image_t *ip);

// Global Variables

/*
   Table of defined images
*/
const image_t * images[] = {
  &image_328, &image_328p, &image_168, &image_8, 0
};

/*
   Table of "Aliases."  Chips that are effectively the same as chips
   that we have a bootloader for.  These work by simply overriding the
   signature read with the signature of the chip we "know."
*/
const alias_t aliases[] = {
  { "ATmega168PA", 0x940B, 0x9406 },	/* Treat 168P same as 168 */
  { "ATmega168PB", 0x9415, 0x9406 },	/* Treat 168PB same as 168 */
  { "ATmega328PB", 0x9516, 0x950F },	/* Treat 328PB same as 328P */
  { "ATmega328",   0x9514, 0x950F },	/* Treat 328 same as 328P */
};

int pmode = 0;
// address for reading and writing, set by 'U' command
int here;

uint16_t target_type = 0;		/* type of target_cpu */
uint16_t target_startaddr;
uint8_t target_pagesize;       /* Page size for flash programming (bytes) */
uint8_t *buff;

const image_t *target_flashptr; 	       /* pointer to target info in flash */
uint8_t target_code[512];	       /* The whole code */

void setup (void) {
  Serial.begin(19200); 			/* Initialize serial for status msgs */
  pinMode(13, OUTPUT); 			/* Blink the pin13 LED a few times */
#ifdef PIN_SPI_SS
#if PIN_SPI_SS != RESET
  // on non-AtmegaXX8 boards (MEGA, Leonardo, etc) the SPI SS pin is NOT pin 10,
  // and although SS is driven manually (RESET to the target), SS should not be
  // allowed to default to INPUT and floating, or the SPI hardware may decide that
  // some other SPI master is trying to use the bus.  (See Datasheet SS description.)
  pinMode(PIN_SPI_SS, INPUT_PULLUP);
#endif
#endif
  pulse(13, 20);
}

void loop (void) {
  fp("\nOptiLoader Bootstrap programmer.\n2011 by Bill Westfield (WestfW)\n\n");
  if (target_poweron()) {		/* Turn on target power */
    do {
      if (!target_identify()) 		/* Figure out what kind of CPU */
        break;
      if (!target_findimage())		/* look for an image */
        break;
      if (!target_progfuses())		/* get fuses ready to program */
        break;
      if (!target_program()) 		/* Program the image */
        break;
      (void) target_normfuses(); 	/* reset fuses to normal mode */
    }
    while (0);
  }
  else {
    Serial.println();
  }
  target_poweroff(); 			/* turn power off */

  fp ("\nType 'G' or hit RESET for next chip\n")
  while (1) {
    if (Serial.read() == 'G')
      break;
  }
}

/*
   Low level support functions
*/

/*
   flashprint
   print a text string direct from flash memory to Serial
*/
void flashprint (const char p[])
{
  uint8_t c;
  while (0 != (c = pgm_read_byte(p++))) {
    Serial.write(c);
  }
}

/*
   hexton
   Turn a Hex digit (0..9, A..F) into the equivalent binary value (0-16)
*/
uint8_t hexton (uint8_t h)
{
  if (h >= '0' && h <= '9')
    return (h - '0');
  if (h >= 'A' && h <= 'F')
    return ((h - 'A') + 10);
  error("Bad hex digit!");
  return (0);
}

/*
   pulse
   turn a pin on and off a few times; indicates life via LED
*/
#define PTIME 30
void pulse (int pin, int times) {
  do {
    digitalWrite(pin, HIGH);
    delay(PTIME);
    digitalWrite(pin, LOW);
    delay(PTIME);
  }
  while (times--);
}

/*
   spi_init
   initialize the AVR SPI peripheral
*/
void spi_init (void) {
  uint8_t x;
  SPCR = 0x53;  // SPIE | MSTR | SPR1 | SPR0
  x = SPSR;
  x = SPDR;
}

/*
   spi_wait
   wait for SPI transfer to complete
*/
void spi_wait (void) {
  debug("spi_wait");
  do {
  }
  while (!(SPSR & (1 << SPIF)));
}

/*
   spi_send
   send a byte via SPI, wait for the transfer.
*/
uint8_t spi_send (uint8_t b) {
  uint8_t reply;
  SPDR = b;
  spi_wait();
  reply = SPDR;
  return reply;
}


/*
   Functions specific to ISP programming of an AVR
*/

/*
   target_identify
   read the signature bytes (if possible) and check whether it's
   a legal value (atmega8, atmega168, atmega328)
*/

boolean target_identify ()
{
  boolean result;
  target_type = 0;
  fp("\nReading signature:");
  target_type = read_signature();
  if (target_type == 0 || target_type == 0xFFFF) {
    fp(" Bad value: ");
    result = false;
  }
  else {
    result = true;
  }
  Serial.println(target_type, HEX);
  if (target_type == 0) {
    fp("  (no target attached?)\n");
  }
  return result;
}

unsigned long spi_transaction (uint8_t a, uint8_t b, uint8_t c, uint8_t d) {
  uint8_t n, m;
  spi_send(a);
  n = spi_send(b);
  //if (n != a) error = -1;
  m = spi_send(c);
  return 0xFFFFFF & ((((uint32_t)n) << 16) + (m << 8) + spi_send(d));
}

uint16_t start_pmode () {
  uint16_t result;

  pinMode(13, INPUT); // restore to default
  spi_init();
  debug("...spi_init done");
  // following delays may not work on all targets...
  pinMode(RESET, OUTPUT);
  digitalWrite(RESET, HIGH);
  pinMode(SCK, OUTPUT);
  digitalWrite(SCK, LOW);
  delay(50);
  digitalWrite(RESET, LOW);
  delay(50);
  pinMode(MISO, INPUT);
  pinMode(MOSI, OUTPUT);
  debug("...spi_transaction");
  result = spi_transaction(0xAC, 0x53, 0x00, 0x00);
  debug("...Done");
  pmode = 1;
  return result;
}

void end_pmode (void) {
  SPCR = 0; 				/* reset SPI */
  digitalWrite(MISO, 0); 		/* Make sure pullups are off too */
  pinMode(MISO, INPUT);
  digitalWrite(MOSI, 0);
  pinMode(MOSI, INPUT);
  digitalWrite(SCK, 0);
  pinMode(SCK, INPUT);
  digitalWrite(RESET, 0);
  pinMode(RESET, INPUT);
  pmode = 0;
}

/*
   read_image

   Read an intel hex image from a string in pgm memory.
   We assume that the image does not exceed the 512 bytes that we have
   allowed for it to have.  that would be bad.
   Also read other data from the image, such as fuse and protecttion byte
   values during programming, and for after we're done.
*/
void read_image (const image_t *ip)
{
  uint16_t len, totlen = 0, addr;
  const char *hextext = &ip->image_hexcode[0];
  target_startaddr = 0;
  target_pagesize = pgm_read_byte(&ip->image_pagesize);
  uint8_t b, cksum = 0;

  while (1) {
    if (pgm_read_byte(hextext++) != ':') {
      error("No colon");
      break;
    }
    len = hexton(pgm_read_byte(hextext++));
    len = (len << 4) + hexton(pgm_read_byte(hextext++));
    cksum = len;

    b = hexton(pgm_read_byte(hextext++)); /* record type */
    b = (b << 4) + hexton(pgm_read_byte(hextext++));
    cksum += b;
    addr = b;
    b = hexton(pgm_read_byte(hextext++)); /* record type */
    b = (b << 4) + hexton(pgm_read_byte(hextext++));
    cksum += b;
    addr = (addr << 8) + b;
    if (target_startaddr == 0) {
      target_startaddr = addr;
      fp("  Start address at ");
      Serial.println(addr, HEX);
    }
    else if (addr == 0) {
      break;
    }

    b = hexton(pgm_read_byte(hextext++)); /* record type */
    b = (b << 4) + hexton(pgm_read_byte(hextext++));
    cksum += b;

    for (uint8_t i = 0; i < len; i++) {
      b = hexton(pgm_read_byte(hextext++));
      b = (b << 4) + hexton(pgm_read_byte(hextext++));
      if (addr - target_startaddr >= sizeof(target_code)) {
        error("Code extends beyond allowed range");
        break;
      }
      target_code[addr++ - target_startaddr] = b;
      cksum += b;
#if VERBOSE
      Serial.print(b, HEX);
      Serial.write(' ');
#endif
      totlen++;
      if (totlen >= sizeof(target_code)) {
        error("Too much code");
        break;
      }
    }
    b = hexton(pgm_read_byte(hextext++)); /* checksum */
    b = (b << 4) + hexton(pgm_read_byte(hextext++));
    cksum += b;
    if (cksum != 0) {
      error("Bad checksum: ");
      Serial.print(cksum, HEX);
    }
    if (pgm_read_byte(hextext++) != '\n') {
      error("No end of line");
      break;
    }
#if VERBOSE
    Serial.println();
#endif
  }
  fp("  Total bytes read: ");
  Serial.println(totlen);
}

/*
   target_findimage

   given target_type loaded with the relevant part of the device signature,
   search the hex images that we have programmed in flash, looking for one
   that matches.
*/

boolean target_findimage ()
{
  const image_t *ip;
  fp("Searching for image...\n");
  /*
     Search through our table of chip aliases first
  */
  for (uint8_t i = 0; i < sizeof(aliases) / sizeof(aliases[0]); i++) {
    const alias_t *a = &aliases[i];
    if (a->real_chipsig == target_type) {
      fp("  Compatible bootloader for ");
      Serial.println(a->alias_chipname);
      target_type = a->alias_chipsig;  /* Overwrite chip signature */
      break;
    }
  }
  /*
     Search through our table of self-contained images.
  */
  for (uint8_t i = 0; i < sizeof(images) / sizeof(images[0]); i++) {
    target_flashptr = ip = images[i];
    if (ip && (pgm_read_word(&ip->image_chipsig) == target_type)) {
      fp("  Found \"");
      flashprint(&ip->image_name[0]);
      fp("\" for ");
      flashprint(&ip->image_chipname[0]);
      fp("\n");
      read_image(ip);
      return true;
    }
  }
  fp(" Not Found\n");
  return (false);
}

/*
   target_progfuses
   given initialized target image data, re-program the fuses to allow
   the optiboot image to be programmed.
*/

boolean target_progfuses ()
{
  uint8_t f;
  fp("\nSetting fuses for programming");

  f = pgm_read_byte(&target_flashptr->image_progfuses[FUSE_PROT]);
  if (f) {
    fp("\n  Lock: ");
    Serial.print(f, HEX);
    fp(" ");
    Serial.print(spi_transaction(0xAC, 0xE0, 0x00, f), HEX);
  }
  f = pgm_read_byte(&target_flashptr->image_progfuses[FUSE_LOW]);
  if (f) {
    fp("  Low: ");
    Serial.print(f, HEX);
    fp(" ");
    Serial.print(spi_transaction(0xAC, 0xA0, 0x00, f), HEX);
  }
  f = pgm_read_byte(&target_flashptr->image_progfuses[FUSE_HIGH]);
  if (f) {
    fp("  High: ");
    Serial.print(f, HEX);
    fp(" ");
    Serial.print(spi_transaction(0xAC, 0xA8, 0x00, f), HEX);
  }
  f = pgm_read_byte(&target_flashptr->image_progfuses[FUSE_EXT]);
  if (f) {
    fp("  Ext: ");
    Serial.print(f, HEX);
    fp(" ");
    Serial.print(spi_transaction(0xAC, 0xA4, 0x00, f), HEX);
  }
  Serial.println();
  return true; 			/* */
}

/*
   target_program
   Actually program the image into the target chip
*/

boolean target_program ()
{
  int l; 				/* actual length */

  fp("\nProgramming bootloader: ");
  here = target_startaddr >> 1; 		/* word address */
  buff = target_code;
  l = 512;
  Serial.print(l, DEC);
  fp(" bytes at 0x");
  Serial.println(here, HEX);

  spi_transaction(0xAC, 0x80, 0, 0); 	/* chip erase */
  delay(1000);
  if (write_flash(l) != STK_OK) {
    error("\nFlash Write Failed");
    return false;
  }
  return true; 			/*  */
}

/*
   target_normfuses
   reprogram the fuses to the state they should be in for bootloader
   based programming
*/
boolean target_normfuses ()
{
  uint8_t f;
  fp("\nRestoring normal fuses");

  f = pgm_read_byte(&target_flashptr->image_normfuses[FUSE_PROT]);
  if (f) {
    fp("\n  Lock: ");
    Serial.print(f, HEX);
    fp(" ");
    Serial.print(spi_transaction(0xAC, 0xE0, 0x00, f), HEX);
  }
  f = pgm_read_byte(&target_flashptr->image_normfuses[FUSE_LOW]);
  if (f) {
    fp("  Low: ");
    Serial.print(f, HEX);
    fp(" ");
    Serial.print(spi_transaction(0xAC, 0xA0, 0x00, f), HEX);
  }
  f = pgm_read_byte(&target_flashptr->image_normfuses[FUSE_HIGH]);
  if (f) {
    fp("  High: ");
    Serial.print(f, HEX);
    fp(" ");
    Serial.print(spi_transaction(0xAC, 0xA8, 0x00, f), HEX);
  }
  f = pgm_read_byte(&target_flashptr->image_normfuses[FUSE_EXT]);
  if (f) {
    fp("  Ext: ");
    Serial.print(f, HEX);
    fp(" ");
    Serial.print(spi_transaction(0xAC, 0xA4, 0x00, f), HEX);
  }
  Serial.println();
  return true; 			/* */
}

/*
   target_poweron
   Turn on power to the target chip (assuming that it is powered through
   the relevant IO pin of THIS arduino.)
*/
boolean target_poweron ()
{
  uint16_t result;

  fp("Target power on! ...");
  digitalWrite(POWER, LOW);
  pinMode(POWER, OUTPUT);
  digitalWrite(POWER, HIGH);
  digitalWrite(RESET, LOW);  // reset it right away.
  pinMode(RESET, OUTPUT);
  /*
     Check if the target is pulling RESET HIGH by reverting to input
  */
  delay(5);
  pinMode(RESET, INPUT);
  delay(1);
  if (digitalRead(RESET) != HIGH) {
    fp("No RESET pullup detected! - no target?");
    return false;
  }
  pinMode(RESET, OUTPUT);

  delay(200);
  fp("\nStarting Program Mode");
  result = start_pmode();
  if ((result & 0xFF00) != 0x5300) {
    fp(" - Failed, result = 0x");
    Serial.print(result, HEX);
    return false;
  }
  fp(" [OK]\n");
  return true;
}

boolean target_poweroff ()
{
  end_pmode();
  digitalWrite(POWER, LOW);
  delay(200);
  pinMode(POWER, INPUT);
  fp("\nTarget power OFF!\n");
  return true;
}

void flash (uint8_t hilo, int addr, uint8_t data) {
#if VERBOSE
  Serial.print(data, HEX);
  fp(":");
  Serial.print(spi_transaction(0x40 + 8 * hilo,
                               addr >> 8 & 0xFF,
                               addr & 0xFF,
                               data), HEX);
  fp(" ");
#else
  (void) spi_transaction(0x40 + 8 * hilo,
                         addr >> 8 & 0xFF,
                         addr & 0xFF,
                         data);
#endif
}

void commit (int addr) {
  fp("  Commit Page: ");
  Serial.print(addr, HEX);
  fp(":");
  Serial.println(spi_transaction(0x4C, (addr >> 8) & 0xFF, addr & 0xFF, 0), HEX);
  delay(100);
}

//#define _current_page(x) (here & 0xFFFFE0)
int current_page (int addr) {
  if (target_pagesize == 32) return here & 0xFFFFFFF0;
  if (target_pagesize == 64) return here & 0xFFFFFFE0;
  if (target_pagesize == 128) return here & 0xFFFFFFC0;
  return here;
}

uint8_t write_flash (int length) {
  if (target_pagesize < 1) return STK_FAILED;
  //if (target_pagesize != 64) return STK_FAILED;
  int page = current_page(here);
  int x = 0;
  while (x < length) {
    if (page != current_page(here)) {
      commit(page);
      page = current_page(here);
    }
    flash(LOW, here, buff[x]);
    flash(HIGH, here, buff[x + 1]);
    x += 2;
    here++;
  }

  commit(page);

  return STK_OK;
}

uint16_t read_signature () {
  uint8_t sig_middle = spi_transaction(0x30, 0x00, 0x01, 0x00);
  uint8_t sig_low = spi_transaction(0x30, 0x00, 0x02, 0x00);
  return ((sig_middle << 8) + sig_low);
}

/*
   Bootload images.
   These are the intel Hex files produced by the optiboot makefile,
   with a small amount of automatic editing to turn them into C strings,
   and a header attched to identify them

   Emacs keyboard macro:

      ۴*SPC			;; self-insert-command
      "			;; self-insert-command
      C-e			;; move-end-of-line
      \			;; self-insert-command
      n"			;; self-insert-command * 2
      C-n			;; next-line
      C-a			;; move-beginning-of-line

*/


const image_t PROGMEM image_328 = {
  {
    "optiboot_atmega328.hex"
  }
  ,
  {
    "atmega328"
  }
  ,
  ۰x9514,				/* Signature bytes for 328 (non-P) */
  {
    ۰x3F, 0xFF, 0xDE, 0x05, 0
  }
  ,
  {
    ۰x2F, 0, 0, 0, 0
  }
  ,
  ۱۲۸,
  {
    ":۱۰۷E0000112484B714BE81FFF0D085E080938100F7\n"
    ":۱۰۷E100082E08093C00088E18093C10086E0809377\n"
    ":۱۰۷E2000C20080E18093C4008EE0C9D0259A86E02C\n"
    ":۱۰۷E300020E33CEF91E0309385002093840096BBD3\n"
    ":۱۰۷E4000B09BFECF1D9AA8958150A9F7CC24DD24C4\n"
    ":۱۰۷E500088248394B5E0AB2EA1E19A2EF3E0BF2EE7\n"
    ":۱۰۷E6000A2D0813461F49FD0082FAFD0023811F036\n"
    ":۱۰۷E7000013811F484E001C083E08DD089C08234E0\n"
    ":۱۰۷E800011F484E103C0853419F485E0A6D080C0E4\n"
    ":۱۰۷E9000853579F488D0E82EFF2485D0082F10E0AE\n"
    ":۱۰۷EA000102F00270E291F29000F111F8ED06801E7\n"
    ":۱۰۷EB0006FC0863521F484E090D080E0DECF843638\n"
    ":۱۰۷EC00009F040C070D06FD0082F6DD080E0C81688\n"
    ":۱۰۷ED00080E7D80618F4F601B7BEE895C0E0D1E017\n"
    ":۱۰۷EE00062D089930C17E1F7F0E0CF16F0E7DF06D8\n"
    ":۱۰۷EF00018F0F601B7BEE89568D007B600FCFDCFD4\n"
    ":۱۰۷F0000A601A0E0B1E02C9130E011968C91119780\n"
    ":۱۰۷F100090E0982F8827822B932B1296FA010C0160\n"
    ":۱۰۷F200087BEE89511244E5F5F4FF1E0A038BF0790\n"
    ":۱۰۷F300051F7F601A7BEE89507B600FCFDCF97BE46\n"
    ":۱۰۷F4000E89526C08437B1F42ED02DD0F82E2BD052\n"
    ":۱۰۷F50003CD0F601EF2C8F010F5F1F4F84911BD097\n"
    ":۱۰۷F6000EA94F801C1F70894C11CD11CFA94CF0C13\n"
    ":۱۰۷F7000D11C0EC0853739F428D08EE10CD085E9AC\n"
    ":۱۰۷F80000AD08FE07ACF813511F488E018D01DD067\n"
    ":۱۰۷F900080E101D065CF982F8091C00085FFFCCF94\n"
    ":۱۰۷FA0009093C60008958091C00087FFFCCF809118\n"
    ":۱۰۷FB000C00084FD01C0A8958091C6000895E0E648\n"
    ":۱۰۷FC000F0E098E1908380830895EDDF803219F02E\n"
    ":۱۰۷FD00088E0F5DFFFCF84E1DECF1F93182FE3DFCA\n"
    ":۱۰۷FE0001150E9F7F2DF1F91089580E0E8DFEE27F6\n"
    ":۰۴۷FF000FF270994CA\n"
    ":۰۲۷FFE00040479\n"
    ":۰۴۰۰۰۰۰۳۰۰۰۰۷E007B\n"
    ":۰۰۰۰۰۰۰۱FF\n"
  }
};

const image_t PROGMEM image_328p = {
  {
    "optiboot_atmega328.hex"
  }
  ,
  {
    "atmega328P"
  }
  ,
  ۰x950F,				/* Signature bytes for 328P */
  {
    ۰x3F, 0xFF, 0xDE, 0x05, 0
  }
  ,
  {
    ۰x2F, 0, 0, 0, 0
  }
  ,
  ۱۲۸,
  {
    ":۱۰۷E0000112484B714BE81FFF0D085E080938100F7\n"
    ":۱۰۷E100082E08093C00088E18093C10086E0809377\n"
    ":۱۰۷E2000C20080E18093C4008EE0C9D0259A86E02C\n"
    ":۱۰۷E300020E33CEF91E0309385002093840096BBD3\n"
    ":۱۰۷E4000B09BFECF1D9AA8958150A9F7CC24DD24C4\n"
    ":۱۰۷E500088248394B5E0AB2EA1E19A2EF3E0BF2EE7\n"
    ":۱۰۷E6000A2D0813461F49FD0082FAFD0023811F036\n"
    ":۱۰۷E7000013811F484E001C083E08DD089C08234E0\n"
    ":۱۰۷E800011F484E103C0853419F485E0A6D080C0E4\n"
    ":۱۰۷E9000853579F488D0E82EFF2485D0082F10E0AE\n"
    ":۱۰۷EA000102F00270E291F29000F111F8ED06801E7\n"
    ":۱۰۷EB0006FC0863521F484E090D080E0DECF843638\n"
    ":۱۰۷EC00009F040C070D06FD0082F6DD080E0C81688\n"
    ":۱۰۷ED00080E7D80618F4F601B7BEE895C0E0D1E017\n"
    ":۱۰۷EE00062D089930C17E1F7F0E0CF16F0E7DF06D8\n"
    ":۱۰۷EF00018F0F601B7BEE89568D007B600FCFDCFD4\n"
    ":۱۰۷F0000A601A0E0B1E02C9130E011968C91119780\n"
    ":۱۰۷F100090E0982F8827822B932B1296FA010C0160\n"
    ":۱۰۷F200087BEE89511244E5F5F4FF1E0A038BF0790\n"
    ":۱۰۷F300051F7F601A7BEE89507B600FCFDCF97BE46\n"
    ":۱۰۷F4000E89526C08437B1F42ED02DD0F82E2BD052\n"
    ":۱۰۷F50003CD0F601EF2C8F010F5F1F4F84911BD097\n"
    ":۱۰۷F6000EA94F801C1F70894C11CD11CFA94CF0C13\n"
    ":۱۰۷F7000D11C0EC0853739F428D08EE10CD085E9AC\n"
    ":۱۰۷F80000AD08FE07ACF813511F488E018D01DD067\n"
    ":۱۰۷F900080E101D065CF982F8091C00085FFFCCF94\n"
    ":۱۰۷FA0009093C60008958091C00087FFFCCF809118\n"
    ":۱۰۷FB000C00084FD01C0A8958091C6000895E0E648\n"
    ":۱۰۷FC000F0E098E1908380830895EDDF803219F02E\n"
    ":۱۰۷FD00088E0F5DFFFCF84E1DECF1F93182FE3DFCA\n"
    ":۱۰۷FE0001150E9F7F2DF1F91089580E0E8DFEE27F6\n"
    ":۰۴۷FF000FF270994CA\n"
    ":۰۲۷FFE00040479\n"
    ":۰۴۰۰۰۰۰۳۰۰۰۰۷E007B\n"
    ":۰۰۰۰۰۰۰۱FF\n"
  }
};

const image_t PROGMEM image_168 = {
  {
    "optiboot_atmega168.hex"
  }
  ,
  {
    "atmega168"
  }
  ,
  ۰x9406,				/* Signature bytes for 168 */
  {
    ۰x3F, 0xC6, 0xDD, 0x04
  }
  ,
  {
    ۰x2F, 0, 0, 0, 0
  }
  ,
  ۱۲۸,
  {
    ":۱۰۳E0000112484B714BE81FFF0D085E08093810037\n"
    ":۱۰۳E100082E08093C00088E18093C10086E08093B7\n"
    ":۱۰۳E2000C20080E18093C4008EE0C9D0259A86E06C\n"
    ":۱۰۳E300020E33CEF91E0309385002093840096BB13\n"
    ":۱۰۳E4000B09BFECF1D9AA8958150A9F7CC24DD2404\n"
    ":۱۰۳E500088248394B5E0AB2EA1E19A2EF3E0BF2E27\n"
    ":۱۰۳E6000A2D0813461F49FD0082FAFD0023811F076\n"
    ":۱۰۳E7000013811F484E001C083E08DD089C0823420\n"
    ":۱۰۳E800011F484E103C0853419F485E0A6D080C024\n"
    ":۱۰۳E9000853579F488D0E82EFF2485D0082F10E0EE\n"
    ":۱۰۳EA000102F00270E291F29000F111F8ED0680127\n"
    ":۱۰۳EB0006FC0863521F484E090D080E0DECF843678\n"
    ":۱۰۳EC00009F040C070D06FD0082F6DD080E0C816C8\n"
    ":۱۰۳ED00088E3D80618F4F601B7BEE895C0E0D1E053\n"
    ":۱۰۳EE00062D089930C17E1F7F0E0CF16F8E3DF0614\n"
    ":۱۰۳EF00018F0F601B7BEE89568D007B600FCFDCF14\n"
    ":۱۰۳F0000A601A0E0B1E02C9130E011968C911197C0\n"
    ":۱۰۳F100090E0982F8827822B932B1296FA010C01A0\n"
    ":۱۰۳F200087BEE89511244E5F5F4FF1E0A038BF07D0\n"
    ":۱۰۳F300051F7F601A7BEE89507B600FCFDCF97BE86\n"
    ":۱۰۳F4000E89526C08437B1F42ED02DD0F82E2BD092\n"
    ":۱۰۳F50003CD0F601EF2C8F010F5F1F4F84911BD0D7\n"
    ":۱۰۳F6000EA94F801C1F70894C11CD11CFA94CF0C53\n"
    ":۱۰۳F7000D11C0EC0853739F428D08EE10CD084E9ED\n"
    ":۱۰۳F80000AD086E07ACF813511F488E018D01DD0B0\n"
    ":۱۰۳F900080E101D065CF982F8091C00085FFFCCFD4\n"
    ":۱۰۳FA0009093C60008958091C00087FFFCCF809158\n"
    ":۱۰۳FB000C00084FD01C0A8958091C6000895E0E688\n"
    ":۱۰۳FC000F0E098E1908380830895EDDF803219F06E\n"
    ":۱۰۳FD00088E0F5DFFFCF84E1DECF1F93182FE3DF0A\n"
    ":۱۰۳FE0001150E9F7F2DF1F91089580E0E8DFEE2736\n"
    ":۰۴۳FF000FF2709940A\n"
    ":۰۲۳FFE000404B9\n"
    ":۰۴۰۰۰۰۰۳۰۰۰۰۳E00BB\n"
    ":۰۰۰۰۰۰۰۱FF\n"
  }
};

const image_t PROGMEM image_8 = {
  {
    "optiboot_atmega8.hex"
  }
  ,
  {
    "atmega8"
  }
  ,
  ۰x9307,				/* Signature bytes for 8 */
  {
    ۰x3F, 0xBF, 0xCC, 0, 0
  }
  ,
  {
    ۰x2F, 0xBF, 0xCC, 0, 0
  }
  ,
  ۶۴,
  {
    ":۱۰۱E000011248FE594E09EBF8DBF84B714BE81FF7F\n"
    ":۱۰۱E1000E2D085E08EBD82E08BB988E18AB986E8A0\n"
    ":۱۰۱E200080BD80E189B98EE0C2D0BD9A96E020E302\n"
    ":۱۰۱E30003CEF54E040E23DBD2CBD58BF08B602FE69\n"
    ":۱۰۱E4000FDCF88B3842788BBA8959150A1F7CC24F7\n"
    ":۱۰۱E5000DD2488248394B5E0AB2EA1E19A2EF3E033\n"
    ":۱۰۱E6000BF2E9ED0813461F49BD0082FA4D00238BD\n"
    ":۱۰۱E700011F0013811F484E001C083E08DD089C0F5\n"
    ":۱۰۱E8000823411F484E103C0853419F485E09BD0D9\n"
    ":۱۰۱E900080C0853579F484D0E82EFF2481D0082FC6\n"
    ":۱۰۱EA00010E0102F00270E291F29000F111F83D0CB\n"
    ":۱۰۱EB00068016FC0863521F484E085D080E0DECFF4\n"
    ":۱۰۱EC000843609F040C06CD06BD0082F69D080E018\n"
    ":۱۰۱ED000C81688E1D80618F4F601B7BEE895C0E048\n"
    ":۱۰۱EE000D1E05ED089930C17E1F7F0E0CF16F8E16E\n"
    ":۱۰۱EF000DF0618F0F601B7BEE8955DD007B600FC26\n"
    ":۱۰۱F0000FDCFA601A0E0B1E02C9130E011968C91BC\n"
    ":۱۰۱F1000119790E0982F8827822B932B1296FA0125\n"
    ":۱۰۱F20000C0187BEE89511244E5F5F4FF1E0A034AD\n"
    ":۱۰۱F3000BF0751F7F601A7BEE89507B600FCFDCF35\n"
    ":۱۰۱F400097BEE89526C08437B1F42AD029D0F82E60\n"
    ":۱۰۱F500027D031D0F601EF2C8F010F5F1F4F8491F6\n"
    ":۱۰۱F60001BD0EA94F801C1F70894C11CD11CFA9463\n"
    ":۱۰۱F7000CF0CD11C0EC0853739F41DD08EE10CD0AA\n"
    ":۱۰۱F800083E90AD087E07ACF813511F488E00FD059\n"
    ":۱۰۱F900012D080E101D065CF5D9BFECF8CB9089552\n"
    ":۱۰۱FA0005F9BFECF5C9901C0A8958CB1089598E124\n"
    ":۱۰۱FB00091BD81BD0895F4DF803219F088E0F7DF2C\n"
    ":۱۰۱FC000FFCF84E1E9CF1F93182FEADF1150E9F723\n"
    ":۱۰۱FD000F2DF1F91089580E0EADFEE27FF270994E2\n"
    ":۰۲۱FFE000404D9\n"
    ":۰۴۰۰۰۰۰۳۰۰۰۰۱E00DB\n"
    ":۰۰۰۰۰۰۰۱FF\n"
  }
};

تنظیمات نرم افزار آردوینو

حالا بوت لودر بر روی میکروکنترلر اپلود شده و اماده برای انتقال برنامه می باشد. برد آردوینو را جدا کنید و  مدار را طبق نقشه زیر بر روی بِردبُرد ببندید.

حالا باید برای انتقال برنامه بر روی میکروکنترلر Atmega8 آن را بعنوان یک برد به نرم افزار آردوینو معرفی کنیم، برای این کار ابتدا باید از منو ی File گزینه ی Preferences را انتخاب کنید. داخل بخش Additional Boards Manager URLs آدرس زیر را کپی کنید. (اگر از قبل آدرس دیگری داخل این بخش موجود بود، از , استفاده کنید و سپس لینک را جلو , کپی کنید) و سپس گزینه OK را انتخاب کنید.

https://mcudude.github.io/MiniCore/package_MCUdude_MiniCore_index.json

از منو ی Tools گزینه ی Board بخش …Boards Manager را انتخاب کنید. سپس کلمه MiniCore را سرچ کنید و سپس گزینه ی Install را انتخاب کنید. پس نصب برد، مبدل USB to TTL را به سیستم متصل کنید و از منو ی Tools گزینه ی Board میکروکنترلر Atmega8 را انتخاب کنید. کد زیر را داخل نرم افزار آردوینو کپی کنید. سپس کلید بر روی بِردبُرد را نگه داشته و گزینه ی Upload را انتخاب کنید. تا زمانی که داخل نوار ابی قسمت پایینی نرم افزار آردوینو ...Compiling sketch نوشته شده است کلید را نگه دارید و به محض تغیر کلمه به …Uploading کلید را رها کنید.

void setup() {
  // initialize digital pin 13 as an output.
  pinMode(13, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(13, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  digitalWrite(13, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second
}

لوازم مورد نیاز

• برد آردوینو Uno
• میکروکنترلر Atmega8
• مبدل USB to TTL
• پک ۳ عددی کابل فلت رنگی Jumper color kit
• کریستال ۱۶ مگاهرتز
• خازن عدسی ۲۲ پیکو فاراد
• مقاومت ۱۰ کیلو اهم
• کلید فشاری Push Button

چنانچه در مراحل راه اندازی و انجام این پروژه با مشکل مواجه شدید، بدون هیچ نگرانی در انتهای همین پست، به صورت ثبت نظر سوالتان را مطرح کنید. من در سریع‌ترین زمان ممکن پاسخ رفع مشکل شما را خواهم داد. همچنین اگر ایرادی در کدها و یا مراحل اجرایی وجود دارند می‌توانید از همین طریق اطلاع رسانی کنید.

پروژه و دریافت بن ارسال رایگان

برای دریافت بن خرید از دانشجو کیت، کاربران بایستی با استفاده از وسایل این آموزش، پروژه را اجرا کرده و یا حتی مدار جدیدی تعریف کنید. سپس از اجرای کار فیلم گرفته و در شبکه‌های اجتماعی از جمله آپارات و اینستگرام، با هشتگ‌های دیجی_اسپارک   دانشجوکیت    digispark    daneshjookit منتشر کنند. سپس از طریق بخش نظرات در ادامه همین آموزش، جهت دریافت بن خرید ارسال رایگان به ارزش ۱۲۰۰۰ تومان از دانشجو کیت، لینک را زیر همین پست ارسال کنید.

در پایان نظرات و پیشنهادات خود را با ما درمیان بگذارید و با اشتراک گذاری این آموزش در شبکه های اجتماعی , از وبسایت دیجی اسپارک حمایت کنید.