Programming an ATmega8A utilizing Arduino

In case you are occupied with programming and electronics, you in all probability don’t want an introduction to Arduino. If you wish to make your Arduino initiatives everlasting, then it’s a good suggestion to make use of solo microcontrollers quite than Arduino boards within the ultimate setup. Whereas Arduino boards are nice for prototyping, shopping for an Arduino board for every venture might not be very budget-friendly. Single microcontrollers typically value lower than a full Arduino board. In some instances, one may have a couple of microcontroller for his or her venture, and in that scenario, utilizing two Arduino boards might not be the very best resolution. The power to program microcontrollers with Arduino will enable customers to write down supply code in C after which merely add it to the MCU.

On this article, I’ll present you learn how to program an ATmega8A microcontroller utilizing Arduino. I’ll assume that you’ve got some primary expertise in Arduino. With out additional ado, let’s get began.

{Hardware} Necessities

1. An Arduino board (boards with ATmel AVR microcontrollers, like Uno, Mega, and many others.; ##3.3~mathrm{V}## boards like Due or Zero should not most popular) with a USB cable,
2. ATmega8A microcontroller,
3. A breadboard,
4. Two ##22~mathrm{pF}## capacitors,
5. One ##100~mathrm{nF}## capacitor,
6. One ##2.2~mathrm{mu F}## capacitor,
7. One ##16~mathrm{MHz}## or ##11.0592~mathrm{MHz}## crystal,
8. One ##10~mathrm{kOmega}## resistor,
9. One ##330~Omega## resistor,
10. One/two LEDs,
11. Jumper wires.

Terminology and model

I ought to briefly point out the terminology we can be utilizing. You have got an Arduino board (Uno, Mega, and many others.) which itself has a microcontroller (“MCU” briefly). For instance, the Uno board has an ATmega328P, whereas the Mega 2560 board has the ATmega2560. This MCU can be referred to as the “on-board microcontroller” to tell apart it from the ATmega8A.

We can be referring to 4 sorts of pins on this article:

1. The pins on the Arduino board. You employ these pin numbers immediately within the Arduino sketch, like digital pin 13 or analog pin A2.
2. The pins of the onboard microcontroller. These are linked to the assorted pins on the Arduino board, however the mapping differs from one Arduino board to a different. So, when needed, we might immediately discuss with/entry some pins of the onboard MCU quite than the corresponding pins on the Arduino board.
3. The native pins/ports of the ATmega8A. These are named PCx, PDx, PBx, and so forth. For particulars, discuss with the pinout diagram within the ATmega8A datasheet.
4. The Arduino pins of the ATmega8A. These are the pin numbers you’ll be utilizing in your sketch that can be uploaded to the ATmega8A. There’s a good pinout diagram that reveals which native pin of the ATmega8A corresponds to which Arduino pin quantity; we’ll come to it later.

Lastly, all sketches and steps on this article have been written w.r.t. Arduino IDE v1.8.13. These steps might change with main revisions within the IDE, and I’ll attempt to maintain the article updated so far as potential.

Getting ready the Arduino board

1. Plug the Arduino into your pc by way of the USB cable, and ensure the Arduino IDE can detect it (go to Instruments ##rightarrow## Get Board information; if nothing is proven, the IDE tells you to pick out a port, and the Ports menu is greyed out, your Arduino has not been detected by your pc).
2. Open the ArduinoISP sketch: Go to File ##rightarrow## Examples ##rightarrow## ArduinoISP ##rightarrow## ArduinoISP.
3. Ensure that the board definition within the IDE is about as per your Arduino board (Instruments ##rightarrow## Board) and the programmer is about to AVRISP mkII (Instruments ##rightarrow## Programmer).
4. Add the ArduinoISP sketch to your Arduino.

Putting in the board definition for ATmega8A

We will use the MiniCore board definition by MCUdude. On this article, we’re utilizing v2.1.3, which is the most recent on the time of writing. To put in the board, please comply with the steps within the GitHub web page.

Establishing the circuit

At this juncture, you must first research the pinout diagram close to the underside of the README.md of the MiniCore GitHub repo. The pinout diagram reveals which native pin of the ATmega8A corresponds to which Arduino pin. When writing your supply code for the ATmega8A, you’ll use these Arduino pin numbers to discuss with the pins. The pinout diagram will even aid you in wiring the {hardware} later.

With the intention to program the ATmega8A, we will be connecting the MOSI (Grasp Out – Slave In), MISO (Grasp In – Slave Out), and SCK (Serial Clock) pins on the ATmega8A to the corresponding pins of the onboard MCU. These pins will enable the onboard MCU to speak with the ATmega8A.

As we’ve got acknowledged earlier, the mapping from the pins of the onboard MCU to the pins on the Arduino board differs from one board to a different. Therefore, we will be utilizing the ICSP header pins on the Arduino board, the pinout of which can be common and invariant throughout Arduino boards. Be aware that boards like Uno and Mega (which have a separate chip for USB communication) have two units of ICSP headers. We’ll use the headers for the primary microcontroller, and these typically have the label “ICSP” beside them.

The headers have the next pinout:

The pinout of the ICSP headers can be proven within the ArduinoISP sketch within the feedback.

The total circuit, connecting the Arduino to the ATmega8A, is proven within the following diagram:

A couple of factors to notice:

• We do not use the ##mathtt{RESET}## pin of the ICSP header. We’ve linked the ##overline{mathtt{RESET}}## (pin PC6) of the ATmega8A to pin 10 of the Arduino board and not to the ICSP header. The ##mathtt{RESET}## pin of the ICSP header corresponds to the ##overline{mathtt{RESET}}## of the on-board MCU. Resetting the ATmega8A and the onboard MCU are two totally different tales and should not associated to one another. We should always be capable to reset the ATmega8A independently once we are programming it. To this impact, the ArduinoISP sketch, by default, makes use of the digital pin 10 on the Arduino board. Therefore, no matter the board you might be utilizing, the ##overline{mathtt{RESET}}## of the ATmega8A will at all times be linked to digital pin 10 on the Arduino board. You could change this pin as per your want by modifying the ArduinoISP sketch.
• I’ve used an ##11.0592~mathrm{MHz}## crystal. You’ll be able to select any crystal from this listing.
• Whereas burning the bootloader or importing a sketch, you need to compulsorily energy the ATmega8A from the Arduino board. You could use the 5V and GND pins on the ICSP header, or immediately hook up with the 5V and GND sockets on the Arduino board. In case you are prototyping on a breadboard, then you could join the ability rails to the Arduino board.

Burning the bootloader

After you have arrange the circuit, as proven above, you might be able to burn the bootloader.

1. First, you need to select the proper board definition. Within the Arduino IDE, go to Instruments ##rightarrow## Boards ##rightarrow## MiniCore ##rightarrow## ATmega8.
2. Set the programmer to Arduino as ISP (MiniCore) [Tools ##rightarrow## Programmer ##rightarrow## Arduino as ISP (MiniCore)].
3. Select the clock (crystal) you could have used (Instruments ##rightarrow## Clock ##rightarrow## …).
4. The opposite choices could also be as follows:
   • BOD: ##2.7~mathrm{V}, ##
   • EEPROM: EEPROM retained,
   • Compiler LTO: LTO enabled
   • Bootloader: Sure (UART0).
5. Go to File ##rightarrow## Preferences ##rightarrow## Settings tab ##rightarrow## “Present verbose output throughout…” and choose each “Compilation” and “Add” checkboxes. It will aid you troubleshoot any errors that will come up.
6. Click on on Instruments ##rightarrow## Burn bootloader.

If all the pieces goes nicely, there needs to be a message within the IDE: “Finished burning bootloader“; if there are errors, scroll by way of the article to the “Coping with runtime errors” part. If in case you have linked the LED to the SCK line of the ATmega8A as proven within the circuit diagram, it ought to begin blinking after this if the burn succeeds.

Importing sketches to the ATmega8A

To add any sketch,

1. Be sure you have chosen the proper board definition. The underside-right nook of the IDE ought to present you the chosen board choices.
2. Compile the sketch.
3. On the Arduino board, join a ##2.2~mathrm{mu F}## capacitor between the RESET and GND pins. It will be sure that the on-board MCU stays reset throughout the add course of. (In case you are utilizing the Uno board, you could detach the on-board microcontroller by eradicating it from its IC base.)
4. The circuit would be the identical because it was if you had burnt the bootloader.
5. Go to Sketch ##rightarrow## Add utilizing Programmer.

Take a look at with a Blink sketch

Now you might be able to add sketches to the ATmega8A. We will take a look at with the next Blink sketch, which is akin to the “HelloWorld” program.

void setup() {
    pinMode(17, OUTPUT);
}

void loop() {
    digitalWrite(17, HIGH);
    delay(1000);
    digitalWrite(17, LOW);
    delay(1000);
}

Be aware that digital pin no. 17 of the ATmega8A corresponds to port PC3. It is best to be capable to find this pin on the pinout diagram given within the MiniCore repo.

Join a LED with a resistor between digital pin 17 of the ATmega8A and GND, and add the sketch. If all the pieces goes high quality, the LED ought to begin blinking. In the event you disconnect and reconnect energy to the ATmega8A, the LED ought to begin blinking once more. Congratulations! You have got efficiently uploaded your first sketch to the ATmega8A.

Appropriate microcontrollers

Though we’ve got used the ATmega8A on this article to show the process, you may program many different microcontrollers similarly. MCUdude has written many different board definitions like MicroCore, MajorCore, MightyCore, and so forth. The listing of supported microcontrollers is given within the GitHub repos. For example, MiniCore helps not solely the ATmega8A, but in addition ATmega48, ATmega88, ATmega168, ATmega328, and ATmega328PB, and these may be programmed equally. For different microcontrollers, ensure you research the pinout and minimal setup diagrams and modify the circuit accordingly.

Some factors to bear in mind

• As soon as a sketch is uploaded, you could disconnect all pins from the Arduino board. You could present the ability supply to the microcontroller externally with out utilizing an Arduino (like a 9V battery with a LM7805 voltage regulator, or immediately from the mains AC utilizing an AC-DC adapter).
• Not all Arduino libraries have been applied in different microcontrollers. Once you compile your sketch, you’re going to get errors if the library you might be utilizing shouldn’t be applied.
• Microcontrollers have various sizes of flash reminiscence. In case your sketch requires extra reminiscence than is offered, the compiler will throw an error. Be aware that the bootloader makes use of 513 bytes of flash reminiscence.
• You could use an inside clock and thereby acquire two additional pins. However except needed, it’s preferable to make use of an exterior clock.
• By default, LTO is disabled within the MiniCore board definition. This has been completed to keep up backward compatibility with earlier variations of the IDE. It is suggested to allow LTO, which may shrink your code and scale back its dimension on the time of linking. In some board definitions by MCUdude, LTO is enabled by default. Be aware that if you wish to change the LTO choice, it isn’t essential to burn the bootloader once more. You could merely change the choice and compile your code once more.
• It isn’t essential to burn the bootloader each time you want to add a sketch. It’s, nonetheless, essential to burn the bootloader once more in case you wish to change any of the next choices:
  • BOD
  • Clock frequency
  • EEPROM choice

Coping with runtime errors

There are two sorts of errors that you could be often encounter whereas importing a sketch or burning the bootloader:

1. Machine signature invalid, and
2. Timeout after no response from the microcontroller.

The most typical motive for these errors is connections. Verify in case you have a unfastened connection someplace, and confirm that you’ve got arrange the circuit correctly. Verify connections for continuity with a multimeter. Typically, the IC might not have been firmly connected to the breadboard, so examine that too. Whereas importing a sketch, ensure you join the capacitor between RESET and GND within the Arduino board.

That’s all for this text. Thanks for studying by way of it, and I hope you will see that it useful.

I want to take this chance to thank Greg Bernhardt, the creator, and admin of Physics Boards, for continually motivating us to write down articles within the Insights Weblog and offering us with a platform the place we will share our information. I additionally thank the Mentors of Physics Boards for his or her dedication and laborious work (which is totally voluntary), with out which the web site couldn’t have change into what it’s at present.

Questions, feedback, and ideas are at all times welcome.

Finding out physics at a school in Kolkata, India. Interested by accelerator physics, beam instrumentation and diagnostics, and particle physics detector design. Additionally passionate in electronics and programming in Java, Android, MATLAB and Python.