Mikrocontroller in C von Grund auf programmieren. CodeVisionAVR. Allgemeine Informationen für Anfänger in der Programmierung in der Sprache C. Welchen Mikrocontroller soll man für die Arbeit wählen?

Irgendwie verspürte ich sofort das Bedürfnis, Ratschläge zur Auswahl einer Programmierumgebung für AVR-Controller zu geben. Wirf bloß keine Hausschuhe nach mir. Ich bin nur ein bisschen :)

Es gibt viele Programmiersprachen für Mikrocontroller. Es gibt auch eine ganze Reihe von Programmierumgebungen und es ist falsch, sie miteinander zu vergleichen. Beste Sprachen Programmierung existiert nicht. Das bedeutet, dass Sie die für Sie am besten geeignete Sprache und Programmierumgebung auswählen müssen.

Wenn Sie derzeit vor der Entscheidung stehen, womit Sie mit der Arbeit beginnen möchten, finden Sie hier einige Empfehlungen.

Vorherige Programmiererfahrung. Vernachlässigen Sie nicht Ihre bisherigen Programmiererfahrungen. Auch wenn es BASIC war. Auch wenn es in der Schule schon lange her ist. Programmieren ist wie Fahrradfahren – wenn man einmal angefangen hat, merkt man sich schnell alles, was man vergessen hat. Beginnen Sie mit BASIC – beherrschen Sie es – später wird es einfacher sein, etwas zu wählen, das für Ihre Zwecke besser geeignet ist.

Hilfe aus der Umwelt. Schreiben deine Freunde in Pascal? Das Problem ist für Sie gelöst – schreiben Sie in Pascal! Sie stehen Ihnen jederzeit mit Ratschlägen zur Seite, stellen Ihnen Bibliotheken zur Verfügung und geben Ihnen fertige Projekte zum Lernen. Im Allgemeinen freuen sie sich, Sie in ihrer Community willkommen zu heißen. Wenn Sie das Gegenteil tun, erhalten Sie das gegenteilige Ergebnis. Freunde der GUS-Branche werden auf Sie stoßen, wenn Sie sich für ein Assembler-Studium entscheiden. Erwarte keine Hilfe.

Gutes Buch zum Thema AVR-Programmierung wird sehr helfen. Leider gibt es nur sehr wenige davon. Wenn Sie auf ein Buch stoßen und denken, dass alles sehr verständlich erklärt wird, probieren Sie es aus. Ich empfehle nicht, mit E-Books zu lernen; als letzten Ausweg sollten Sie sie ausdrucken. Es ist sehr umständlich, zwischen der Umgebung und dem Text der Buchdatei zu wechseln. Es ist viel angenehmer, ein Buch zu lesen und es gleich auszuprobieren, ohne sich durch das Umblättern ablenken zu lassen; außerdem kann man sich Randnotizen machen und die aufkommenden Ideen aufschreiben.

Die Programmierumgebung ist einfacher. Wenn für Ihre Sprache mehrere Programmierumgebungen zur Auswahl stehen, zögern Sie nicht und wählen Sie die einfachere. Lassen Sie es weniger funktional sein. Lassen Sie sie schrecklich aufgeblähten Code kompilieren. Die Hauptsache ist, einfach mit der Arbeit anzufangen. Sobald Sie sich in einer einfachen Umgebung wohlgefühlt haben, können Sie problemlos zu einer fortgeschritteneren und „richtigeren“ Umgebung wechseln. Und hören Sie nicht auf diejenigen, die sagen, dass Sie mehr Zeit verlieren werden – sie liegen falsch. Grundschüler werden nicht gebeten, „Krieg und Frieden“ zu lesen, sondern erhalten einfachere Bücher – mit Bildern.

Bibliotheken. Die Verfügbarkeit von Bibliotheken ist für das Sprachenlernen umstritten. Natürlich werden sie später das Leben viel einfacher machen, aber „Black Box“-Bibliotheken sind zunächst unverständlich und tragen nicht wirklich zum Verständnis der Sprache bei. Andererseits machen sie Programme leichter lesbar und ermöglichen es einem Anfänger, ohne großen Aufwand komplexe Programme zu erstellen. Kümmern Sie sich also nicht zu sehr um ihre Anwesenheit. Zumindest zunächst.

Effizienter Code. Es ist keine gute Idee, eine Programmierumgebung zum Erlernen des Programmierens ausschließlich auf der Grundlage der Effizienz des kompilierten Codes auszuwählen. Die Hauptsache ist, dass man sich zu Beginn des Studiums wohlfühlt – was dabei herauskommt, ist das Zehnte. Natürlich können Sie später daran arbeiten.

Zauberer. Jedes Gerät an Bord des Chips muss mithilfe von Ports konfiguriert werden. Das Verfahren ist recht langwierig und es sind Datenblätter erforderlich. Darüber hinaus gibt es Nuancen, die für einen Anfänger nicht leicht zu verstehen sind. Daher ist es sehr wünschenswert, Assistenten in der Umgebung zu haben. Vyzards sind automatische Tuner für SPI, I2C, USART usw. Je mehr Geräte unterstützt werden, desto besser. Sie legen die erforderlichen Peripherieparameter fest und der Assistent generiert selbst Code, der die angegebenen Parameter bereitstellt. Macht das Leben viel einfacher.


Allgemeine Empfehlungen So sollte die Programmierung in der Anfangsphase so einfach wie möglich (sogar primitiv) sein. Die Programmierumgebung sollte leicht zu erlernen sein (da Sie zunächst die Programmierung beherrschen müssen und keine Zeit damit verschwenden müssen, mit den Einstellungen herumzuspielen). Vorzugsweise russifiziert. Ein russisches Handbuch und Beispielprogramme wären ebenfalls hilfreich. Die Fähigkeit, den Kristall aus der Umgebung herauszulösen, ist wünschenswert. Wenn Sie dann die Grundlagen der Programmierung beherrschen, können Sie mit komplexeren Shells fortfahren.


Eine letzte Empfehlung: Arbeiten Sie mit einem echten Kristall. Haben Sie keine Angst, es zu verbrennen. Sammeln Sie Praxiserfahrung. Die Arbeit mit Emulatoren (z. B. Proteus) wird Sie zwar von der Arbeit mit einem Lötkolben befreien, wird Ihnen jedoch nie die Zufriedenheit verschaffen, die Sie durch das funktionierende Programm und das erste Blinken der LED bekommen! Zu verstehen, dass Sie mit Ihren eigenen Händen ein echtes Arbeitsdiagramm erstellt haben, gibt Ihnen Selbstvertrauen und Ansporn, weiterzumachen!

(7.377 Mal besucht, 1 Besuch heute)

Hallo, lieber Habrazhitel!

In diesem Artikel möchte ich darüber sprechen, wie ich mich einst dazu entschlossen habe, mit der Programmierung von Mikrocontrollern zu beginnen, was dafür nötig war und was dabei herausgekommen ist.

Das Thema Mikrocontroller interessierte mich schon vor langer Zeit, im Jahr 2001. Doch dann stellte sich heraus, dass es problematisch war, an meinem Wohnort einen Programmierer zu bekommen, und an einen Kauf über das Internet war nicht zu denken. Ich musste diese Angelegenheit auf bessere Zeiten verschieben. Und dann, eines schönen Tages, entdeckte ich, dass bessere Zeiten gekommen waren, ohne das Haus zu verlassen, ich konnte alles kaufen, was ich brauchte. Ich beschloss, es zu versuchen. Was wir also brauchen:

1. Programmierer
Es gibt viele Optionen auf dem Markt – von den günstigsten ISP-Programmierern (In-System Programming) für ein paar Dollar bis hin zu leistungsstarken Programmier-Debuggern für ein paar Hundert. Da ich in dieser Angelegenheit nicht viel Erfahrung hatte, entschied ich mich zunächst für eines der einfachsten und günstigsten Programme – USBasp. Ich habe es einmal für 12 $ bei eBay gekauft, jetzt gibt es es sogar für 3-4 $. Dabei handelt es sich tatsächlich um eine chinesische Version des Programmierers von Thomas Fischl. Was kann ich über ihn sagen? Nur eines: Es funktioniert. Darüber hinaus unterstützt es eine ganze Reihe von AVR-Controllern der ATmega- und ATtiny-Serie. Unter Linux ist kein Treiber erforderlich.

Um die Firmware zu flashen, müssen Sie die Ausgänge des Programmiergeräts VCC, GND, RESET, SCK, MOSI, MISO mit den entsprechenden Ausgängen des Mikrocontrollers verbinden. Der Einfachheit halber habe ich den Hilfsstromkreis direkt auf dem Steckbrett montiert:

Links auf der Platine befindet sich derselbe Mikrocontroller, den wir flashen werden.

2. Mikrocontroller
Ich habe mich nicht allzu sehr um die Wahl des Mikrocontrollers gekümmert und habe den ATmega8 von Atmel genommen – 23 I/O-Pins, zwei 8-Bit-Timer, einer 16-Bit, Frequenz bis zu 16 MHz, geringer Verbrauch (1-3,6 mA) , günstig (2 $). Im Allgemeinen für den Anfang mehr als genug.

Unter Linux funktioniert die Kombination avr-gcc + avrdude gut zum Kompilieren und Laden von Firmware auf den Controller. Die Installation ist trivial. Wenn Sie den Anweisungen folgen, können Sie die gesamte erforderliche Software in wenigen Minuten installieren. Die einzige Nuance, die Sie beachten sollten, ist, dass avrdude (Software zum Aufzeichnen auf dem Controller) möglicherweise Superuser-Rechte erfordert, um auf den Programmierer zuzugreifen. Die Lösung besteht darin, es über sudo auszuführen (keine sehr gute Idee) oder spezielle udev-Rechte zu registrieren. Die Syntax kann in verschiedenen Betriebssystemversionen unterschiedlich sein, aber in meinem Fall ( Linux Mint 15) Das Hinzufügen der folgenden Regel zur Datei /etc/udev/rules.d/41-atmega.rules hat funktioniert:

# USBasp-Programmierer SUBSYSTEM=="usb", ATTR(idVendor)=="16c0", ATTR(idProduct)=="05dc", GROUP="plugdev", MODE="0666"

Danach müssen Sie den Dienst natürlich neu starten
Dienst udev neu starten
Sie können problemlos direkt daraus kompilieren und flashen Befehlszeile(Wer würde das bezweifeln), aber wenn es viele Projekte gibt, ist es bequemer, ein Plugin zu installieren und alles direkt aus der Eclipse-Umgebung heraus zu erledigen.

Für Windows müssen Sie einen Treiber installieren. Ansonsten gibt es keine Probleme. Aus wissenschaftlichem Interesse habe ich die Kombination AVR Studio + eXtreme Burner unter Windows ausprobiert. Auch hier funktioniert alles super.

Beginnen wir mit der Programmierung

AVR-Controller können sowohl in Assembler (AVR-Assembler) als auch in C programmiert werden. Hier sollte meiner Meinung nach jeder seine eigene Wahl treffen, abhängig von der konkreten Aufgabe und seinen Vorlieben. Persönlich habe ich zuerst angefangen, mit Assembler herumzubasteln. Beim Programmieren in Assembler wird die Architektur des Geräts klarer und man hat das Gefühl, direkt in das Innere des Controllers einzutauchen. Darüber hinaus glaube ich, dass bei Programmen, die besonders kritisch in Größe und Leistung sind, Assembler-Kenntnisse sehr nützlich sein können. Nachdem ich mich mit dem AVR-Assembler vertraut gemacht hatte, kroch ich zu C.

Nachdem ich mich mit der Architektur und den Grundprinzipien vertraut gemacht hatte, beschloss ich, etwas Nützliches und Interessantes zusammenzustellen. Hier hat mir meine Tochter geholfen, sie spielt Schach und eines schönen Abends sagte sie, sie wolle eine Zeitschaltuhr für zeitgesteuerte Spiele haben. BAM! Hier ist sie – die Idee des ersten Projekts! Sie könnten sie natürlich bei eBay bestellen, aber ich wollte meine eigene Uhr herstellen, mit schwarzen... äh... Indikatoren und Knöpfen. Gesagt, getan!

Als Anzeige wurde beschlossen, zwei 7-Segment-Diodenanzeigen zu verwenden. Zur Steuerung reichten 5 Tasten – „Spieler 1“, „Spieler 2“, „Zurücksetzen“, „Einstellungen“ und „Pause“. Vergessen Sie nicht die akustische Anzeige des Endes des Spiels. Sieht so aus, als wäre es das. Die folgende Abbildung zeigt ein allgemeines Diagramm zum Anschluss des Mikrocontrollers an Anzeigen und Tasten. Wir benötigen es beim Parsen des Quellcodes des Programms:

Nachbesprechung

Beginnen wir wie erwartet am Einstiegspunkt des Programms – der Hauptfunktion. Tatsächlich gibt es daran nichts Besonderes – das Einrichten von Ports, das Initialisieren von Daten und eine Endlosschleife von Verarbeitungstastendrücken. Nun, der Aufruf von sei() ermöglicht die Interrupt-Verarbeitung, mehr dazu später.

Int main(void) ( init_io(); init_data(); sound_off(); sei(); while(1) ( handle_buttons(); ) return 0; )
Schauen wir uns jede Funktion einzeln an.

Void init_io() ( // Ausgang DDRB = 0xFF setzen; DDRD = 0xFF; // Eingang DDRC = 0b11100000 setzen; // Pull-Up-Widerstände PORTC |= 0b00011111; // Timer unterbricht TIMSK = (1<

Das Einrichten von E/A-Ports ist sehr einfach: In das DDRx-Register wird eine Zahl geschrieben (wobei x der Buchstabe ist, der den Port bezeichnet), wobei jedes Bit angibt, ob der entsprechende Pin ein Eingabegerät (entspricht 0) oder ein Eingabegerät ist Ausgabegerät (entspricht 1). Durch das Senden der Nummer 0xFF an DDRB und DDRD haben wir also B- und D-Ausgangsports erstellt. Dementsprechend lautet der DDRC-Befehl = 0b11100000; Verwandelt die ersten 5 Pins von Port C in Eingangspins und die restlichen in Ausgangspins. PORTC-Befehl |= 0b00011111; Enthält interne Pull-Up-Widerstände an 5 Controller-Eingängen. Gemäß dem Diagramm sind an diese Eingänge Tasten angeschlossen, die bei Betätigung einen Kurzschluss mit Masse verursachen. Auf diese Weise versteht der Controller, dass die Taste gedrückt wird.

Als nächstes folgt die Einrichtung von zwei Timern, Timer0 und Timer1. Wir verwenden den ersten, um die Indikatoren zu aktualisieren, und den zweiten, um die Zeit herunterzuzählen, nachdem wir ihn zuvor so konfiguriert haben, dass er jede Sekunde ausgelöst wird. Eine detaillierte Beschreibung aller Konstanten und der Methode zum Einstellen des Timers auf ein bestimmtes Intervall finden Sie in der ATmega8-Dokumentation.

Interrupt-Behandlung

ISR (TIMER0_OVF_vect) ( display(); if (_buzzer > 0) ( _buzzer--; if (_buzzer == 0) sound_off(); ) ) ISR(TIMER1_COMPA_vect) ( if (ActiveTimer == 1 && Timer1 > 0) ( Timer1--; if (Timer1 == 0)process_timeoff(); ) if (ActiveTimer == 2 && Timer2 > 0) ( Timer2--; if (Timer2 == 0)process_timeoff(); ) )

Wenn der Timer ausgelöst wird, wird die Steuerung an den entsprechenden Interrupt-Handler übertragen. In unserem Fall ist dies der Handler TIMER0_OVF_vect, der die Prozedur zur Anzeige der Zeit auf Indikatoren aufruft, und TIMER1_COMPA_vect, der den Countdown verarbeitet.

Ausgabe an Indikatoren

Void display() ( display_number((Timer1/60)/10, 0b00001000); _delay_ms(0.25); display_number((Timer1/60)%10, 0b00000100); _delay_ms(0.25); display_number((Timer1%60)/10 , 0b00000010); _delay_ms(0.25); display_number((Timer1%60)%10, 0b00000001); _delay_ms(0.25); display_number((Timer2/60)/10, 0b10000000); _delay_ms(0.25); display_number((Timer2/ 60)%10, 0b01000000); _delay_ms(0.25); display_number((Timer2%60)/10, 0b00100000); _delay_ms(0.25); display_number((Timer2%60)%10, 0b00010000); _delay_ms(0.25); PORTD = 0; ) void display_number(int number, int mask) ( PORTB = number_mask(number); PORTD = mask; )

Die Anzeigefunktion verwendet eine dynamische Anzeigemethode. Tatsache ist, dass jede einzelne Anzeige über 9 Kontakte verfügt (7 für die Segmentsteuerung, 1 für den Punkt und 1 für die Stromversorgung). Zur Ansteuerung von 4 Ziffern wären 36 Kontakte nötig. Zu verschwenderisch. Daher ist die Ausgabe von Ziffern an einen mehrstelligen Indikator nach folgendem Prinzip organisiert:

Jeder der gemeinsamen Kontakte wird abwechselnd mit Spannung versorgt, sodass Sie mit denselben 8 Steuerkontakten die gewünschte Zahl auf der entsprechenden Anzeige markieren können. Bei einer ausreichend hohen Ausgangsfrequenz sieht es für das Auge wie ein statisches Bild aus. Deshalb sind alle 8 Leistungskontakte beider Anzeigen im Diagramm mit 8 Ausgängen von Port D verbunden, und 16 segmentsteuernde Kontakte sind paarweise verbunden und mit 8 Ausgängen von Port B verbunden. Somit funktioniert die Anzeige mit einer Verzögerung von 0,25 ms zeigt abwechselnd die gewünschte Zahl auf jedem der Indikatoren an. Abschließend werden alle Ausgänge, die die Anzeigen mit Spannung versorgen, abgeschaltet (Befehl PORTD = 0;). Geschieht dies nicht, bleibt die zuletzt angezeigte Ziffer bis zum nächsten Aufruf der Anzeigefunktion weiterhin beleuchtet, was zu einem helleren Leuchten im Vergleich zu den übrigen führt.

Umgang mit Klicks

Void handle_buttons() ( handle_button(KEY_SETUP); handle_button(KEY_RESET); handle_button(KEY_PAUSE); handle_button(KEY_PLAYER1); handle_button(KEY_PLAYER2); ) void handle_button(int key) ( int bit; switch (key) ( case KEY_SETUP: bit = SETUP_BIT; break; case KEY_RESET: bit = RESET_BIT; break; case KEY_PAUSE: bit = PAUSE_BIT; break; case KEY_PLAYER1: bit = PLAYER1_BIT; break; case KEY_PLAYER2: bit = PLAYER2_BIT; break; Standard: return; ) if (bit_is_clear( BUTTON_PIN, Bit)) ( if (_pressed == 0) ( _delay_ms(DEBOUNCE_TIME); if (bit_is_clear(BUTTON_PIN, bit)) ( _pressed |= key; // Tastenaktionsschalter (Taste) ( case KEY_SETUP:process_setup(); break; case KEY_RESET: Process_reset(); Break; Case KEY_PAUSE: Process_Pause(); Break; Case KEY_PLAYER1: Process_Player1(); Break; Case KEY_PLAYER2: Process_Player2(); Break; ) Sound_on(15); ) ) ) Sonst ( _pressed &= ~key; ) )

Diese Funktion fragt nacheinander alle 5 Schaltflächen ab und verarbeitet den Klick, falls vorhanden. Der Klick wird durch die Prüfung von bit_is_clear(BUTTON_PIN, bit) registriert, d.h. Die Taste wird gedrückt, wenn der entsprechende Eingang mit Masse verbunden ist, was laut Diagramm beim Drücken der Taste der Fall ist. Eine Verzögerung von DEBOUNCE_TIME und wiederholte Überprüfungen sind erforderlich, um mehrere unnötige Vorgänge aufgrund von Kontaktabsprüngen zu vermeiden. Das Speichern des gedrückten Status in den entsprechenden Bits der Variablen _pressed dient dazu, ein wiederholtes Auslösen bei längerem Drücken der Taste zu verhindern.
Die Funktionen zur Verarbeitung von Klicks sind recht trivial und meiner Meinung nach bedürfen sie keiner weiteren Kommentare.

Vollständiger Text des Programms

#define F_CPU 4000000UL #include #enthalten #enthalten # DEBOUNCE_TIME 20 definieren # BUTTON_PIN PINC definieren # SETUP_BIT PC0 definieren # RESET_BIT PC1 definieren # PAUSE_BIT PC2 definieren # PLAYER1_BIT PC3 definieren # PLAYER2_BIT PC4 definieren # KEY_SETUP 0b00000001 definieren # KEY_RESET 0b00000010 definieren # KEY_PAUSE 0b00000 definieren 100 #define KEY_PLAYER1 0b00001000 #define KEY_PLAYER2 0b00010000 volatile int ActiveTimer = 0; volatile int Timer1 = 0; volatile int Timer2 = 0; volatile int _buzzer = 0; volatile int _pressed = 0; // Funktionsdeklarationen void init_io(); void init_data(); int number_mask(int num); void handle_buttons(); void handle_button(int key); void Process_setup(); void Process_reset(); void Process_pause(); void Process_timeoff(); void Process_player1(); void Process_player2(); void display(); void display_number(int mask, int number); void sound_on(int Interval); void sound_off(); // unterbricht ISR (TIMER0_OVF_vect) ( display(); if (_buzzer > 0) ( _buzzer--; if (_buzzer == 0) sound_off(); ) ) ISR(TIMER1_COMPA_vect) ( if (ActiveTimer == 1 && Timer1 > 0) ( Timer1--; if (Timer1 == 0)process_timeoff(); ) if (ActiveTimer == 2 && Timer2 > 0) ( Timer2--; if (Timer2 == 0)process_timeoff(); ) ) int main (void) ( init_io(); init_data(); sound_off(); sei(); while(1) ( handle_buttons(); ) return 0; ) void init_io() ( // setze Ausgabe DDRB = 0xFF; DDRD = 0xFF ; // Eingang DDRC = 0b11100000 setzen; // Pull-Up-Widerstände PORTC |= 0b00011111; // Timer-Interrupts TIMSK = (1<5940 || Timer2 > 5940) ( Timer1 = 0; Timer2 = 0; ) ) void Process_reset() ( init_data(); ) void Process_timeoff() ( init_data(); sound_on(30); ) void Process_pause() ( ActiveTimer = 0; ) void Process_player1() ( ActiveTimer = 2; ) void Process_player2() ( ActiveTimer = 1; ) void handle_button(int key) ( int bit; switch (key) ( case KEY_SETUP: bit = SETUP_BIT; break; case KEY_RESET: bit = RESET_BIT ; break; case KEY_PAUSE: bit = PAUSE_BIT; break; case KEY_PLAYER1: bit = PLAYER1_BIT; break; case KEY_PLAYER2: bit = PLAYER2_BIT; break; Standard: return; ) if (bit_is_clear(BUTTON_PIN, bit)) ( if (_pressed == 0) ( _delay_ms(DEBOUNCE_TIME); if (bit_is_clear(BUTTON_PIN, bit)) ( _pressed |= key; // Tastenaktionsschalter (Taste) ( case KEY_SETUP: Process_setup(); break; Case KEY_RESET: Process_reset(); Break; case KEY_PAUSE: Process_Pause(); Break; Case KEY_PLAYER1: Process_Player1(); Break; Case KEY_PLAYER2: Process_Player2(); Break; ) Sound_on(15); ) ) ) Sonst ( _pressed &= ~key; ) ) void handle_buttons() ( handle_button(KEY_SETUP); handle_button(KEY_RESET); handle_button(KEY_PAUSE); handle_button(KEY_PLAYER1); handle_button(KEY_PLAYER2); ) void display() ( display_number((Timer1/60)/10, 0b00001000) ; _delay_ms(0.25); display_number((Timer1/60)%10, 0b00000100); _delay_ms(0.25); display_number((Timer1%60)/10, 0b00000010); _delay_ms(0.25); display_number((Timer1%60)% 10, 0b00000001); _delay_ms(0.25); display_number((Timer2/60)/10, 0b10000000); _delay_ms(0.25); display_number((Timer2/60)%10, 0b01000000); _delay_ms(0.25); display_number((Timer2 %60)/10, 0b00100000); _delay_ms(0.25); display_number((Timer2%60)%10, 0b00010000); _delay_ms(0.25); PORTD = 0; ) void display_number(int number, int mask) ( PORTB = number_mask (Zahl); PORTD = Maske; ) void sound_on(int Intervall) ( _buzzer = Intervall; // Summer-Pin auf High setzen PORTC |= 0b00100000; ) void sound_off() ( // Summer-Pin auf Low setzen PORTC &= ~0b00100000; )

Der Prototyp wurde auf einem Steckbrett zusammengebaut.

Lektion 0.

Deshalb eröffnen wir heute eine Reihe von Lektionen zum Programmieren von Mikrocontrollern der AVR-Familie.

Heute werden folgende Fragen besprochen:

  1. Was ist ein Mikrocontroller?
  2. Wo werden Mikrocontroller eingesetzt?

Einführung.

Mikrocontroller gibt es überall. In Telefonen, Waschmaschinen, „Smart Homes“, Werkzeugmaschinen in Fabriken und auch in unzähligen anderen technischen Geräten. Ihre weit verbreitete Verwendung ermöglicht es, komplexe analoge Schaltkreise durch stärker komprimierte digitale Schaltkreise zu ersetzen.

Was ist also ein Mikrocontroller?

Mikrocontroller (Mikrocontroller-Einheit, MCU) - eine Mikroschaltung zur Steuerung elektronischer Geräte. Sie können es sich als einen einfachen Computer vorstellen, der mit externen Geräten interagieren kann. Zum Beispiel Transistoren öffnen und schließen, Daten von Temperatursensoren empfangen, Daten auf LCD-Bildschirmen anzeigen usw. Darüber hinaus kann der Mikrocontroller, genau wie Ihr Personal Computer, verschiedene Verarbeitungen von Eingabedaten durchführen.

Das heißt, Mikrocontroller bieten uns dank des Vorhandenseins von I/0-Ports (Eingangs-/Ausgangsports) sowie der Möglichkeit, diese zu programmieren, nahezu unbegrenzte Möglichkeiten zur Steuerung beliebiger Geräte.

Wo werden Mikrocontroller eingesetzt?

  1. Haushaltsgeräte (Waschmaschinen, Mikrowellenherde usw.).
  2. Mobile Technologie (Roboter, Robotersysteme, Kommunikationsgeräte usw.).
  3. Industrieausrüstung (Maschinensteuerungssysteme).
  4. Computertechnik (Motherboards, Steuerungssysteme für Peripheriegeräte).
  5. Unterhaltungsausrüstung (Kinderspielzeug, Dekorationen).
  6. Transport (Steuerungssysteme für Automotoren, Sicherheitssysteme)

Dies ist keine vollständige Liste der Anwendungen für Mikrocontroller. Aufgrund der vereinfachten Produktion und des geringeren Stromverbrauchs ist es oft sehr profitabel, einen Satz Steuerchips durch einen Mikrocontroller zu ersetzen.

Erste Schritte mit AVR

AVR- eine Familie von Mikrocontrollern von Atmel. Sie bieten ausreichend Leistung für die meisten Amateurgeräte. Sie werden auch häufig in der Industrie eingesetzt.

Es gibt verschiedene Programmiersprachen für AVR-Mikrocontroller, aber am besten geeignet sind vielleicht Assembler und C, da diese Sprachen alle notwendigen Fähigkeiten zur Verwaltung der Mikrocontroller-Hardware am besten umsetzen.

Assemblersprache ist eine Low-Level-Programmiersprache, die den direkten Befehlssatz des Mikrocontrollers verwendet. Um ein Programm in dieser Sprache zu erstellen, sind gute Kenntnisse des Befehlssystems des programmierbaren Chips und ausreichend Zeit für die Entwicklung des Programms erforderlich. Die Assemblersprache ist C hinsichtlich Geschwindigkeit und Einfachheit der Programmentwicklung unterlegen, bietet jedoch deutliche Vorteile bei der Größe des endgültigen ausführbaren Codes und dementsprechend bei der Geschwindigkeit seiner Ausführung.

Mit C können Sie Programme wesentlich komfortabler erstellen und dem Entwickler alle Vorteile einer Hochsprache bieten.
Es sei noch einmal darauf hingewiesen, dass die Architektur und das Befehlssystem von AVR unter direkter Beteiligung der Entwickler des C-Sprachcompilers erstellt wurden und die Besonderheiten dieser Sprache berücksichtigen. Das Kompilieren von C-Quellcode geht schnell und erzeugt kompakten, effizienten Code.

Die Hauptvorteile von C gegenüber Assembler: hohe Geschwindigkeit der Programmentwicklung; Universalität, die kein gründliches Studium der Mikrocontroller-Architektur erfordert; bessere Dokumentierbarkeit und Lesbarkeit des Algorithmus; Verfügbarkeit von Funktionsbibliotheken; Unterstützung für Gleitkommaberechnungen.

Die Sprache C kombiniert auf harmonische Weise Low-Level-Programmierfähigkeiten mit den Eigenschaften einer High-Level-Sprache. Die Fähigkeit zur Low-Level-Programmierung ermöglicht Ihnen die einfache Bedienung direkt auf der Hardware und die Eigenschaften der High-Level-Sprache ermöglichen die Erstellung von leicht lesbarem und modifizierbarem Programmcode. Darüber hinaus verfügen fast alle C-Compiler über die Möglichkeit, Assembler-Einfügungen zum Schreiben von Programmabschnitten zu verwenden, die hinsichtlich Ausführungszeit und Ressourcenverbrauch kritisch sind.

Kurz gesagt, C ist die bequemste Sprache sowohl für Anfänger, die sich mit AVR-Mikrocontrollern vertraut machen, als auch für ernsthafte Entwickler.

Compiler werden verwendet, um den Quellcode eines Programms in eine Mikrocontroller-Firmware-Datei zu konvertieren.

Atmel bietet einen leistungsstarken Assembly-Compiler, der in der unter Windows ausgeführten Entwicklungsumgebung Atmel Studio enthalten ist. Die Entwicklungsumgebung enthält neben dem Compiler einen Debugger und einen Emulator.
Atmel Studio ist völlig kostenlos und auf der Atmel-Website verfügbar.

Derzeit gibt es eine ganze Reihe von C-Compilern für AVR. Als leistungsfähigster gilt der Compiler von IAR Systems aus Stockholm. Es waren seine Mitarbeiter, die Mitte der 90er Jahre an der Entwicklung des AVR-Befehlssystems beteiligt waren. Der IAR C Compiler verfügt über umfangreiche Funktionen zur Codeoptimierung und ist Teil der integrierten Entwicklungsumgebung IAR Embedded Workbench (EWB), die außerdem einen Assembler-Compiler, einen Linker, einen Projekt- und Bibliotheksmanager sowie einen Debugger umfasst. Der Preis für die Vollversion des Pakets beträgt 2820 EUR. Auf der Website des Unternehmens können Sie eine kostenlose Testversion für 30 Tage oder eine unbegrenzte Version mit einer Codegrößenbeschränkung von 4 KB herunterladen.

Das amerikanische Unternehmen Image Craft aus Palo Alto, Kalifornien, produziert einen C-Sprach-Compiler, der sich großer Beliebtheit erfreut. JumpStart C für AVR bietet eine akzeptable Codeoptimierung und einen nicht zu hohen Preis (von 50 bis 499 US-Dollar je nach Version). Die Demoversion von JumpStart C für AVR ist 45 Tage lang voll funktionsfähig.

Der rumänische Code Vision AVR C Compiler erfreut sich nicht weniger Beliebtheit; der Preis der Vollversion dieses Compilers ist relativ niedrig und beträgt 150 EUR. Der Compiler verfügt über eine integrierte Entwicklungsumgebung, die zusätzlich zu den Standardfunktionen eine recht interessante Funktion enthält – CodeWizardAVR Automatic Program Generator. Das Vorhandensein eines seriellen Terminals in der Entwicklungsumgebung ermöglicht das Debuggen von Programmen über die serielle Schnittstelle des Mikrocontrollers. Sie können von den Entwicklern eine kostenlose Testversion mit einer Codegrößenbeschränkung von 4 KB und deaktivierter Speicherung des generierten Quellcodes in C herunterladen.

Das in der serbischen Stadt Belgrad ansässige Unternehmen MikroElektronika produziert eine ganze Familie von Compilern für AVR-Mikrocontroller. Ein Compiler für die C-Sprache namens mikroC PRO für AVR kostet 249 US-Dollar. Zum gleichen Preis gibt es auch mikroBasic und mikroPascal. Auf der Website der Entwickler gibt es Demoversionen mit einer Codegrößenbeschränkung von 4096 Byte. Der Vorteil dieser Compilerfamilie ist eine einzige Plattform und eine einzige Ideologie, die einen einfachen Übergang nicht nur zwischen Sprachen, sondern auch zwischen Mikrocontrollern ermöglichen kann (es gibt Compilerversionen für PIC, STM32, 8051...).

Die integrierte Entwicklungsumgebung ist zu einer echten Ikone geworden. Es umfasst leistungsstarke C- und Assembler-Compiler, den AVRDUDE-Programmierer, einen Debugger, einen Simulator und viele andere unterstützende Programme und Dienstprogramme. WinAVR lässt sich nahtlos in die Entwicklungsumgebung AVR Studio von Atmel integrieren. Der Assembler ist im Eingabecode identisch mit dem AVR Studio-Assembler. C- und Assembler-Compiler haben die Möglichkeit, Debug-Dateien im COFF-Format zu erstellen, wodurch Sie nicht nur integrierte Tools, sondern auch den leistungsstarken AVR Studio-Simulator verwenden können. Ein weiterer wichtiger Vorteil besteht darin, dass WinAVR ohne Einschränkungen kostenlos vertrieben wird (Hersteller unterstützen die GNU General Public License).

Zusammenfassend lässt sich sagen, dass WinAVR eine ideale Wahl für diejenigen ist, die anfangen, AVR-Mikrocontroller zu beherrschen. Diese Entwicklungsumgebung wird in diesem Kurs als die wichtigste betrachtet.

Kiselev Roman, Mai 2007 Artikel aktualisiert am 26. Mai 2014

Was ist also ein Mikrocontroller (im Folgenden als MK bezeichnet)? Dabei handelt es sich relativ gesehen um einen kleinen Computer, der in einem einzigen integrierten Schaltkreis untergebracht ist. Es verfügt über einen Prozessor (arithmetische Logikeinheit oder ALU), einen Flash-Speicher, einen EEPROM-Speicher, viele Register, I/O-Ports sowie zusätzlichen Schnickschnack wie Timer, Zähler, Komparatoren, USARTs usw. Nach dem Anlegen der Stromversorgung , startet der Mikrocontroller und beginnt mit der Ausführung des in seinem Flash-Speicher gespeicherten Programms. Gleichzeitig kann er über I/O-Ports verschiedenste externe Geräte steuern.

Was bedeutet das? Dies bedeutet, dass Sie im MK jede logische Schaltung implementieren können, die bestimmte Funktionen ausführt. Das bedeutet, dass der MK ein Mikroschaltkreis ist, dessen interner Inhalt wir tatsächlich selbst erstellen. Dies ermöglicht es, nach dem Kauf mehrerer völlig identischer MKs völlig unterschiedliche Schaltungen und Geräte darauf aufzubauen. Wenn Sie Änderungen an der Funktionsweise eines elektronischen Geräts vornehmen möchten, benötigen Sie keinen Lötkolben, sondern lediglich eine Neuprogrammierung des MK. In diesem Fall müssen Sie ihn nicht einmal von Ihrem Gerät entfernen, wenn Sie einen AVR verwenden, da diese MKs In-Circuit-Programmierung unterstützen. Mikrocontroller schließen somit die Lücke zwischen Programmierung und Elektronik.

AVRs sind 8-Bit-Mikrocontroller, d. h. ihre ALU kann einfache Operationen mit nur 8-Bit-Zahlen in einem Taktzyklus ausführen. Jetzt ist es an der Zeit, darüber zu sprechen, welchen MK wir verwenden werden. Ich arbeite mit einem ATMega16 MK. Es ist sehr verbreitet und kann in fast jedem Radioteileladen für etwa 100 Rubel gekauft werden. Wenn Sie es nicht finden, können Sie jedes andere MK der MEGA-Serie kaufen. In diesem Fall müssen Sie jedoch nach einer Dokumentation dafür suchen, da dieselben „Beine“ verschiedener MKs unterschiedliche Funktionen ausführen können und Nach der Verbindung scheint es so zu sein, dass Sie, wenn alle Schlussfolgerungen richtig sind, ein funktionierendes Gerät oder vielleicht nur eine stinkende Rauchwolke erhalten. Achten Sie beim Kauf eines ATMega16 darauf, dass dieser in einem großen 40-Pin-DIP-Gehäuse geliefert wird, und kaufen Sie auch einen Sockel dafür, in den er gesteckt werden kann. Um damit arbeiten zu können, benötigen Sie außerdem zusätzliche Geräte: LEDs, Tasten, Anschlüsse usw.

ATMega16 verfügt über eine sehr große Anzahl unterschiedlicher Funktionen. Hier sind einige seiner Eigenschaften:

  • Maximale Taktfrequenz – 16 MHz (8 MHz für ATMega16L)
  • Die meisten Befehle werden in einem Taktzyklus ausgeführt
  • 32 8-Bit-Arbeitsregister
  • 4 volle 8-Bit-I/O-Ports
  • zwei 8-Bit-Timer/Zähler und ein 16-Bit
  • 10-Bit-Analog-Digital-Wandler (ADC)
  • interner Taktgenerator mit 1 MHz
  • analoger Komparator
  • Schnittstellen SPI, I2C, TWI, RS-232, JTAG
  • In-Circuit-Programmierung und Selbstprogrammierung
  • Modul zur Pulsweitenmodulation (PWM).

Die vollständigen Eigenschaften dieses Geräts sowie Anweisungen zu seiner Verwendung finden Sie im Nachschlagewerk (Datenblatt) dieses MK. Stimmt, es ist auf Englisch. Wenn Sie Englisch sprechen, laden Sie unbedingt dieses Datenblatt herunter, es enthält viele nützliche Informationen.

Kommen wir endlich zur Sache. Ich empfehle, ein spezielles Entwicklungs- und Debugging-Board für den Mikrocontroller zu erstellen, auf dem Sie jeden Stromkreis mit einem Mikrocontroller ohne Lötkolben (oder fast ohne) zusammenbauen können. Die Verwendung einer solchen Karte erleichtert die Arbeit mit dem MK erheblich und beschleunigt das Erlernen seiner Programmierung. Es sieht aus wie das:

Was benötigen Sie dafür?

Zunächst benötigen Sie die Platine selbst. Ich habe ein fertiges Exemplar für 115 Rubel in einem Radioteileladen gekauft. Dann habe ich alle notwendigen Teile daran angelötet. Das Ergebnis ist eine unglaublich praktische Sache, auf der Sie in wenigen Minuten jeden Stromkreis aufbauen können, indem Sie Kabel anschließen und Mikroschaltungen und Anzeigen installieren.

Um Schaltungselemente zu verbinden, ist es sehr praktisch, Kabel mit Steckern an den Enden zu verwenden. Diese Anschlüsse werden auf die „Beine“ gesteckt, die neben jedem Anschluss des MK herausragen. Der Mikrocontroller sollte im Sockel installiert und nicht mit der Platine verlötet sein, da er sonst bei versehentlichem Verbrennen sehr schwer zu entfernen ist. Unten ist die Pinbelegung des ATMEGA16 MK:

Lassen Sie uns erklären, welche Beine uns jetzt interessieren.

  • VCC – hier erfolgt die Stromversorgung (4,5 – 5,5 V) aus einer stabilisierten Quelle
  • GND – Masse
  • RESET – Reset (bei niedrigem Spannungsniveau)
  • XTAL1, XTAL2 – hier wird ein Quarzresonator angeschlossen
  • PA, PB, PC, PD – Ein-/Ausgangsports (A, B, C bzw. D).

Als Stromquelle kann alles verwendet werden, was 7-11 V Gleichspannung erzeugt. Für einen stabilen Betrieb des MK ist eine stabilisierte Stromversorgung erforderlich. Als Stabilisator können Sie Mikroschaltungen der Serie 7805 verwenden. Hierbei handelt es sich um lineare integrierte Stabilisatoren, deren Eingang mit 7–11 V unstabilisiertem Gleichstrom und der Ausgang mit 5 V stabilisiertem Strom versorgt wird. Vor und nach 7805 müssen Sie Filterkondensatoren installieren (Elektrolyt zum Filtern von Niederfrequenzstörungen und Keramik für Hochfrequenzstörungen). Wenn Sie keinen Stabilisator finden, können Sie als Stromquelle eine 4,5-V-Batterie verwenden. Der MK muss direkt von dieser mit Strom versorgt werden.

Nachfolgend finden Sie ein Diagramm der MK-Verbindung:

Lassen Sie uns nun herausfinden, was hier gemeint ist.

BQ1 ist ein Quarzresonator, der die Betriebsfrequenz des MK einstellt. Sie können jede bis 16 MHz einstellen, aber da wir planen, in Zukunft mit einem COM-Port zu arbeiten, empfehle ich die Verwendung von Resonatoren für die folgenden Frequenzen: 14,7456 MHz, 11,0592 MHz, 7,3725 MHz, 3,6864 MHz oder 1,8432 MHz (später). es wird klar werden, warum). Ich habe 11,0592 MHz verwendet. Es ist klar, dass die Geschwindigkeit des Geräts umso höher ist, je höher die Frequenz ist.

R1 ist ein Pull-up-Widerstand, der am RESET-Eingang eine Spannung von 5 V aufrechterhält. Ein niedriger Spannungspegel an diesem Eingang weist auf einen Reset hin. Nach dem Reset fährt der MK hoch (10 - 15 ms) und beginnt erneut mit der Programmausführung. Da es sich um einen hochohmigen Eingang handelt, können Sie ihn nicht „in der Luft baumeln lassen“ – ein kleiner Impuls darauf führt zu einem unerwarteten Reset des MK. Genau dafür ist R1 gedacht. Aus Gründen der Zuverlässigkeit empfehle ich außerdem den Einbau des Kondensators C6 (nicht mehr als 20 µF).

SB1 – Reset-Taste.

Der Quarzresonator und Siebkondensator C3 sollten möglichst nahe am MK platziert werden (nicht weiter als 5-7 cm), da es sonst zu Störungen in den Leitungen und damit zu Fehlfunktionen des MK kommen kann.

Das blaue Rechteck im Diagramm umreißt den Programmierer selbst. Es ist praktisch, es in Form eines Kabels herzustellen, dessen eines Ende in den LPT-Anschluss und das andere in einen bestimmten Anschluss neben dem MK gesteckt wird. Der Draht sollte nicht zu lang sein. Sollten mit diesem Kabel Probleme auftreten (normalerweise nicht, aber es kann alles passieren), müssen Sie den Altera ByteBlaster-Adapter anlöten. Wie das geht, steht in der Beschreibung des AVReal-Programmierers.

Nachdem wir uns nun mit der Hardware befasst haben, ist es an der Zeit, mit der Software fortzufahren.

Für die AVR-Programmierung gibt es mehrere Entwicklungsumgebungen. Erstens ist dies AVR Studio – das offizielle Programmiersystem von Atmel. Es ermöglicht das Schreiben von Assembler- und Debug-Programmen, die in Assembly, C und C++ geschrieben sind. IAR ist ein kommerzielles Programmiersystem in C, C++ und Assembler. WinAVR ist ein Open-Source-Compiler. AtmanAVR ist ein Programmiersystem für AVR mit einer Schnittstelle, die fast genau der von Visual C++ 6 entspricht. AtmanAVR ermöglicht Ihnen auch das Debuggen von Programmen und enthält viele Hilfsfunktionen, die das Schreiben von Code erleichtern. Dieses Programmiersystem ist kommerziell, kann aber laut Lizenz einen Monat lang kostenlos genutzt werden.

Ich schlage vor, mit IAR als der transparentesten Entwicklungsumgebung zu arbeiten. In IAR wird ein Projekt vollständig von Hand erstellt; daher wissen Sie nach Abschluss mehrerer Projekte bereits genau, was jede Codezeile bedeutet und was passiert, wenn Sie sie ändern. Wenn Sie mit AtmanAVR arbeiten, müssen Sie entweder eine vorgefertigte Vorlage verwenden, die für eine Person ohne Erfahrung sehr umständlich und schwer verständlich ist, oder Sie haben viele Probleme mit Header-Dateien, wenn Sie das Projekt von Grund auf neu zusammenstellen. Nachdem wir uns mit IAR befasst haben, werden wir uns anschließend andere Compiler ansehen.

Besorgen Sie sich also zunächst ein IAR. Es kommt sehr häufig vor und es sollte kein Problem sein, es zu finden. Nachdem Sie IAR 3.20 von irgendwoher heruntergeladen haben, installieren Sie den Compiler/die Arbeitsumgebung und starten Sie ihn. Danach können Sie mit der Arbeit beginnen.

Nachdem Sie IAR gestartet haben, wählen Sie Datei/Neu/Arbeitsbereich, wählen Sie den Pfad zu unserem Projekt aus, erstellen Sie einen Ordner dafür und geben Sie ihm einen Namen, zum Beispiel „Prog1“. Jetzt erstellen wir ein Projekt: Projekt / Neues Projekt erstellen… Nennen wir es auch „Prog1“. Klicken Sie mit der rechten Maustaste auf den Projekttitel im Projektbaum und wählen Sie „Optionen“

Hier konfigurieren wir den Compiler für einen bestimmten MK. Zuerst müssen Sie auf der Registerkarte „Ziel“ den Prozessortyp ATMega16 auswählen und auf der Registerkarte „Bibliothekskonfiguration“ das Kontrollkästchen „Bitdefinitionen in I/O-include-Dateien aktivieren“ aktivieren (damit Sie die Bitnamen verschiedener MK-Register im Programmcode verwenden können). ) und wählen Sie dort den C-Bibliothekstyp /EU++ aus. In der Kategorie ICCAVR müssen Sie das Kontrollkästchen „Multibyte-Unterstützung aktivieren“ auf der Registerkarte „Sprache“ aktivieren und die Optimierung auf der Registerkarte „Optimierung“ deaktivieren (andernfalls wird unser erstes Programm dadurch ruiniert).

Wählen Sie als Nächstes die Kategorie XLINK aus. Hier müssen Sie das Format der kompilierten Datei bestimmen. Da wir nun, wie im Titel beschrieben, Optionen für den Debug-Modus festlegen, benötigen wir eine Debug-Datei als Ausgabe. Später werden wir es in AVR Studio öffnen. Dazu müssen Sie die Erweiterung.cof auswählen und der Dateityp ist ubrof 7.

Klicken Sie nun auf „OK“ und ändern Sie dann „Debug“ in „Release“.

Gehen Sie erneut zu Optionen, wo alle Parameter außer XLINK auf den gleichen Wert eingestellt sind. Ändern Sie in XLINK die Erweiterung in .hex und das Dateiformat in Intel-Standard.

Das ist alles. Jetzt können Sie mit dem Schreiben Ihres ersten Programms beginnen. Erstellen Sie eine neue Quelle/einen neuen Text und geben Sie darin den folgenden Code ein:

#enthalten„iom16.h“ short unsigned int i; Leere hauptsächlich( Leere) (DDRB = 255; PORTB = 0; während(1) { Wenn(PORTB == 255) PORTB = 0; anders PORTB++; für(i=0; ich

Die Datei „iom16.h“ befindet sich im Ordner (C:\Programme)\IAR Systems\Embedded Workbench 3.2\avr\inc. Wenn Sie ein anderes MK verwenden, zum Beispiel ATMega64, dann wählen Sie die Datei „iom64.h“ aus. Diese Header-Dateien speichern Informationen über den MK: die Namen von Registern, Bits in Registern und die Namen von Interrupts. Jeder einzelne Pin von Port A, B, C oder D kann entweder als Eingang oder Ausgang fungieren. Dies wird durch das Data Direction Register (DDR) bestimmt. 1 macht das Bein zu einem Ausgang, 0 zu einem Eingang. Wenn wir also beispielsweise DDRA = 13 einstellen, machen wir die „Beine“ PB0, PB2, PB3 zu Ausgängen, den Rest zu Eingängen, weil 13 im Binärformat ist 00001101.

PORTB ist ein Register, das den Zustand der Port-Pins bestimmt. Nachdem wir dort 0 geschrieben haben, setzen wir die Spannung an allen Ausgängen auf 0 V. Dann gibt es eine Endlosschleife. Beim Programmieren des MK wird immer eine Endlosschleife erstellt, in der der MK eine Aktion ausführt, bis er zurückgesetzt wird oder eine Unterbrechung auftritt. In diesem Zyklus schreiben sie sozusagen „Hintergrundcode“, den der MK als letztes ausführt. Dies könnte beispielsweise die Anzeige von Informationen auf einem Display sein. In unserem Fall wird der Inhalt des PORTB-Registers erhöht, bis es voll ist. Danach beginnt alles von vorne. Zum Schluss eine Zehntausend-Zyklus-for-Schleife. Es wird benötigt, um eine sichtbare Verzögerung beim Umschalten des Zustands von Port B zu erzeugen.



Jetzt speichern wir diese Datei im Projektordner als Prog1.c, kopieren die Datei iom16.h in den Projektordner, wählen Projekt/Dateien hinzufügen und fügen „iom16.h“ und „Prog1.c“ hinzu. Wählen Sie „Release“, drücken Sie F7, das Programm wird kompiliert und die Meldung sollte erscheinen:


Gesamtzahl der Fehler: 0
Gesamtzahl der Warnungen: 0

Hier ist ein Foto meines Programmierers:

Laden Sie den AVReal-Programmierer herunter. Kopieren Sie es (AVReal32.exe) in den Ordner Release/exe, wo sich die Datei Prog1.hex befinden sollte. Wir versorgen den MK mit Strom, schließen das Programmierkabel an. Öffnen Sie Far Manager (am bequemsten ist es, MK zu flashen), gehen Sie zu diesem Ordner und drücken Sie Strg+O. Da wir einen komplett neuen MK haben, stopfen wir

avreal32.exe +MEGA16 -o11.0592MHZ -p1 -fblev=0,jtagen=1,cksel=F,sut=1 –w

Vergessen Sie nicht, die richtige Frequenz einzugeben, wenn Sie nicht 11059200 Hz verwenden! Gleichzeitig ist das sogenannte Sicherungen – Register, die den Betrieb steuern (Verwendung eines internen Generators, Jtag usw.). Danach ist es bereit, das erste Programm zu empfangen. Der Programmierer erhält den verwendeten LPT-Port, die Frequenz, den Dateinamen und andere als Parameter (alle sind in der Beschreibung von AVReal aufgeführt). Wir wählen:

Avreal32.exe +Mega16 -o11.0592MHz -p1 -e -w -az -% Prog1.hex

Bei korrekter Verbindung meldet der Programmierer die erfolgreiche Programmierung. Es gibt keine Garantie dafür, dass dies beim ersten Mal (dem ersten Aufruf des Programms) funktioniert. Ich selbst werde manchmal das zweite Mal programmiert. Möglicherweise ist der LPT-Anschluss defekt oder es liegt eine Störung im Kabel vor. Wenn Probleme auftreten, überprüfen Sie Ihr Kabel sorgfältig. Aus eigener Erfahrung weiß ich, dass 60 % der Störungen auf einen fehlenden Kontakt an der richtigen Stelle zurückzuführen sind, 20 % auf das Vorhandensein eines unnötigen und weitere 15 % auf fehlerhaftes Anlöten des falschen Dings an das falsche Ding. Wenn alles andere fehlschlägt, lesen Sie die Beschreibung des Programmierers und versuchen Sie, Byte Blaster zu erstellen.

Nehmen wir an, dass bei Ihnen alles funktioniert. Wenn Sie nun acht LEDs an Port B des MK anschließen (tun Sie dies bei ausgeschaltetem MK, und es empfiehlt sich, 300-400 Ohm-Widerstände in Reihe mit den LEDs zu schalten) und Strom anlegen, geschieht ein kleines Wunder – ein „ Welle“ wird durch sie laufen!

© Kiselev Roman
Mai 2007


Spitze