Online Programmieranleitung

IDE VS Code – Installation, Einrichtung und Anwendung

Anmerkung zur Installation:

•  Download der Entwicklungsumgebung von https://code.visualstudio.com/download

•  Erweiterung PlatformIO installieren

Erstellen einer ATMEGA-Anwendung:

Überprüfen sie zuerst die Funktion und USB Verbindung der Controllerplatine! (Geräte-Manager, COM-Port)

1. 1. PlatformIO Home auswählen, Button New Project

   2. Programmnamen eingeben

   3. Platine auswählen: „Arduino Nano Atmega328“ oder „Arduino Mega Atmega2560“

   4. für "Arduino-C" Framework Arduino auswählen, für Ansci C diese Auswahl frei lassen

   5. Use default location NICHT auswählen, danach gewünschtes Verzeichnis auswählen

   6. Button Finish

   7. Programmvorlagen aus a.oswald\Atmel\Programmvorlage in die Programmordner kopieren:
      code_atmega.c in den Ordner src kopieren
      Datei main.cpp aus dem Ordner src löschen
      AODEF.h in den Ordner include kopieren

   8. Aktuelles Programm als Arbeitsbereich auswählen (Menüpunkt in der Fußzeile)

   9. Kompilieren

   10. Programm auf den AtMega Hochladen

Achtung:

Arduino Nano-Platine: Atmega328 auswählen, NICHT Variante New Bootloader

Arduino Mega-Platine: Atmega2560 auswählen

Immer aktuelles Programm in der PlatformIO Fußzeile prüfen

Platformio.ini Einstellungen:

Vorlage für Platine ArduinoNano:

[env:nanoatmega328]
platform = atmelavr
board = nanoatmega328
framework = oder framework = arduino (Für Arduino-C Befehle)

Vorlage für Platine ArduinoMega:

[env:megaatmega2560]
platform = atmelavr
board = megaatmega2560
framework = oder framework = arduino (Für Arduino-C Befehle)

Standard bei mehreren Varianten:

[platformio]
default_envs = nanoatmega328

Weitere Optionen:

; Serial Monitor options
monitor_speed = 115200
; Minimalistic printf version
build_flags = -Wl,-u,vfprintf -lprintf_min
;Floating point printf version (requires MATH_LIB = -lm below)
build_flags = -Wl,-u,vfprintf -lprintf_flt -lm

Setzen von Fuse Bits: (Beispiel Mega328 interner Oszillator 8Mhz)

board_fuses.efuse = 0xFF
board_fuses.hfuse = 0xD9
board_fuses.lfuse = 0xE2

Verwenden alternativer Programmer: (Beispiel Programmer USBASP)

upload_flags =
-Pusb
-e
-E reset,novc

Arduino IDE: 

Menü Datei(File), Punkt Einstellungen(Preferences): Compiler- und Upload-Meldungen anzeigen aktivieren.
Die Verwendete Hardware wird im Menü Wekzeuge, Punkt Board, eingestellt

Arduino Nano-Platine: Atmega328 auswählen, NICHT Variante New Bootloader
Arduino Mega-Platine: Atmega2560 auswählen
ESP-CAM (für Robobar): AI Thinker ESP32-CAM auswählen

Mikrocontroller-Programmierung mit C

Links und Quellverweis:

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial

http://www.kreatives-chaos.com/artikel/avr

http://www.roboternetz.de/wissen/index.php/Avr-gcc

http://www.pronix.de/pronix-4.html

http://www.atmel.com/products/AVR/overview.asp

avr-libc Standard C library for AVR-GCC https://www.nongnu.org/avr-libc/user-manual/index.html

Datentypen (<inttypes.h>)

Typ Länge Bereich
uint8_t 8 Bit 0 ... 255
int8_t 8 Bit -128 … 127
uint16_t 16 Bit 0 ... 65.535
int16_t 16 Bit -32.768 ... 32.767
uint32_t 32 Bit 0 ... 4.294.967.295
int32_t 32 Bit -2.147.483.648 … 2.147.483.647
float 32 Bit Reelle Zahlen mit ca. 7 Kommastellen

Schreiben von Bits 

Ein ganzes Byte kann durch Befüllen mit einer Dezimal-, Binär- oder HEX-Zahl gesetzt werden:

x = 7; // Bitmuster 0000 1001 gesetzt (dezimal)
x = 0x22; // Bitmuster 0010 0010 gesetzt (hexadezimal)
x = 0b01000100; // Bitmuster 0100 0100 gesetzt (binär)

Einzelne Bits setzt man mittels logischer (Bit-) Operationen:

x |= (1 << Bitnummer); // wird ein Bit in x gesetzt (1)
x &= ~(1 << Bitnummer); // wird ein Bit in x geloescht (0)

Setzten mehrerer Bits:

x |= (1<<1) | (1<<4); // BIT 1 und 4 in x gesetzt (1)
x &= ~( (1<<0) | (1<<3) ); // BIT 0 und 3 in x gelöscht (0) 

Bit Toggeln (invertieren):

PORTB ^= (1<<0); /* toggle Bit 0, Ex-OR mit Standardschreibweise */

Anwendungsbeispiel: Setzten von Registern:

DDRB |= (1 << 2); // Port B.2 auf OUTPUT (1)
PORTB &= ~(1 << 2); // Port B.2 auf LOW (0)

Bitsstatus abfragen

if ( x & (1<<5) ) /* Fuehre Aktion aus, wenn Bit Nr. 5 in x gesetzt (1) ist */
{
/* Aktion */
}

if ( !(x & (1<<6)) ) /* Fuehre Aktion aus, wenn Bit Nr. 6 in x gelöscht ist */
{
/* Aktion */
}

C-Makros - Zur Vereinfachung der Schreibweise können Befehle durch C-Makros umbenannt werden: 

// Setzen und Löschen von Bits als Macro
#define SETBIT1(ADRESS,BIT) (ADRESS |= (1<<BIT))
#define SETBIT0(ADRESS,BIT) (ADRESS &= ~(1<<BIT))
#define SETBITT(ADRESS,BIT) (ADRESS ^= (1<<BIT))
//Macro zur BIT-Abfrage
#define CHECKBIT1(ADRESS,BIT) (ADRESS & (1<<BIT))
#define CHECKBIT0(ADRESS,BIT) (!(ADRESS & (1<<BIT)))

Diese C-Makros stehen in der Vorlage AODEF.h zur Verfügung.

Um diese Makros zu verwenden muss im Kopf der C-Datei folgender include stehen:

 #include "AODEF.h"

Zugriff auf Digitale Anschlüsse

Verwenden der seriellen Schnittstelle

Für die Kommunikation zwischen PC und Mikrocontroller und besonders zur Fehlersuche in Programmen kann die serielle Schnittstelle verwendet werden:

1.) Übertragungsgeschwindigkeit einstellen und starten (Unterprogramme aus Programmvorlage)

void uart_init(void)
int uart_putchar(char c, FILE *stream)
int uart_getchar(FILE *stream)

2.) Schnittstelle festlegen (Unterprogramme aus Programmvorlage)

uart_init();
fdevopen(uart_putchar, uart_getchar); // Standard-IO festlegen

3.) Senden vom Controller an den PC

printf("PROGRAMMSTART");

4.) Daten Empfangen

if ( CHECKBIT1(UCSR0A, RXC0) ) // Ist etwas angekommen?
{
Zeichen = UDR0; // Das empfangene Zeichen ist im Register UDR
printf("Zeichen %c empfangen!", Zeichen);
}

Einstellungen der Programmvorlage: 

• Übertragung 9600 Bit/s, 8 Datenbits, 1 Stopbit, keine Parität, keine Flusssteuerung

•  Ausgabe einer 8 oder 16 bit Zahl ohne Vorzeichen: printf("Zahl: %u ", Variable);

•  Ausgabe einer 32 bit Zahl: printf("Zahl: %ld ", Variable);

•  Die Ausgabe von Float-Zahlen durch:

- Umwandlung der Float-Variable in einen Text dtostrf (fZahl, 4, 2, TextZahl); 

- Aktivieren der erweiterten printf-Variante in der PlatformIO.ini

Arduino IDE - Verwenden der seriellen Schnittstelle: 

Für das Festlegen von Seriellen Kommunikation sind Makros vordefiniert:

1.) Übertragungsgeschwindigkeit einstellen und starten

Serial.begin(9600);

2.) Senden vom Controller an den PC

Serial.print("Hallo Welt");
Serial.println("Hallo Welt");
Serial.write("Hallo Welt")

4.) Daten Empfangen

if (Serial.available())
{
char Zeichen = (char)Serial.read();
Serial.print(">>"); Serial.println(Zeichen);
if (Zeichen=='e')
{
Serial.println("Zeichen e empfangen");
}
}