Kummunikation 2.0

[last Update: 22.04.13]
Hallo,

hier endlich mal wieder ein Post von mir ;)

Ich habe mich ein wenig über ein größeres Projekt gedanken gemacht und interessiere mich seit längerem wahnsinnig für Magnetschwebebahnen. Ich plane deswegen schon seit längerem ( ca. 3 Wochen ) wie man soetwas realisieren könnte. Natürlich sollten und werden dann auch Mikrocontroller zum Einsatz kommen.

Unter anderem habe ich mir Gedanken über die Kommunikation "Kontrollstation" -> Zug gemacht. Dies soll möglichst einfach von statten gehen. Der Sinn dahinter ist, dass man dann den Zug wie eine Modellbahn steuern können soll ( wenigstens starten und stoppen ).

Ich habe dazu die vorherige Möglichkeit Daten auszutauschen verändert. Nun kann nur einer Daten senden und der andere empfängt. Dies ist hier sinnvoll, da der Zug lediglich befolgen, aber nicht befehlen soll.

Momentan habe ich die Idee von zwei Möglichkeiten, die mir spontan eingefallen sind und die ich für relativ einfach erachte:

1. Eine begrenzte Anzahl an Möglichkeiten:
   Hierbei gibt es z.B. 3 Leitungen ( Datenleitungen ), an denen entweder eine Spannung anliegt ( 1 ) oder eben nicht ( 0 ). Dabei ist in diesenfall die Zahl der Variationen auf 8 begrenzt ( 2^3 ).
2. Eine UNbegrenzte Anzahl an Möglichkeiten:
   Diese Version funktioniert so ähnlich wie die aus dem letzten Post: Hier gibt es eine Datenleitung, eine Leitung, die angibt ob es ein neues Bit gibt ( dies wird angegeben indem die Leitung von 0 -> 1 bzw. von 1 -> 0 geht ) und eine Kontrolleitung ( diese funktioniert wie die Leitung, die die änderung angibt ).
   Ende der Übertragung ist nach der übertragung einer definierten Menge an Bits. Möglich wäre auch DNA-like eine Art "Stopp-Codon" ( also eine Bestimmte Reihe an Bits ) fest zu legen, nach der die Übertragung beendet wird.

Ich werden die zweite Idee beim nächsten Post mit Bildern, Code, etc. vorstellen.

Hier die Zusammenfassung der 2. Idee ( Leitungen nicht in der obigen Reihenfolge ):

• Leitung 1: Kontrollleitung: Empfangender µController gibt dadurch an, ob der das gesendete Bit erhalten hat.
• Leitung 2: Änderungsleitung: Gibt durch Änderung der Spannung ( 0V o. 5V ) an, dass die momentan auf der Datenleitung anliegende Spannung ( 0V o. 5V ) das nächste Bit ist.
• Leitung 3: Datenleitung: Gibt durch Spannung ( 0V oder 5V ) den Wert des Bits an ( also 0 oder 1 ).
• Ende der Übertragung ( 2 Möglichkeiten ):
  
  1. Ende nach definierter Menge an Bits
  2. Ende nach bestimmter Reihenfolge an Bits

Ich hoffe dieses bisschen Theorie hat euch nicht zum einschlafen gebracht.
Beim nächsten mal gibt es dann ein paar Bilder und Code zum selbst ausprobieren. Ob ich das Projekt mit der Magnetschwebebahn anfange oder doch etwas leichteres mache weiß ich noch nicht ... aber cool wäre so'ne Magnetschwebebahn schon ... ;)

Das ist neu (von 22.04.13):
Code fürs senden von Bits ( ohne Start- / Stopcodon, etc. ) fertig....
und ja er funktioniert ;)

mfg
Hauke

Kommunikation zwischen zwei Mikrocontrollern

Hallo,

Allen erst mal frohe Weihnachten nachträglich und ein Frohes neues Jahr!
Zu Beginn möchte ich euch von einigen Weihnachtesgschenken berichten. Diese haben natürlich mit Elektronik und diesem Blog zu tun, aber hier erst mal eine Liste:
- Abstandswarner
- Berührungssensor
- Motorsteuerung ( Mit Adapterplatine für die Pfostenleiste am Pollin-Board )
Zu diesen drei Sachen gibt es am Ende dieses Artikels und im nächsten Beitrag mehr ( wenn alles fertig verlötet ist ;) ) zudem schreibe ich dann darüber, wie es überhaupt weitergeht.

Heute jedoch zeige ich euch, wie ich es endlich hinbekommen habe, dass zwei Mikrocontroller miteinander "Reden", sprich ein paar Daten austauschen.

Der bei mir Vorhandene Aufbau für diesen Artikel bestand aus:

Das gesamte Steckbrett mit Pfostenleiste

• 1x ATmega8
• 1x ATmega16
• 1x Pollin-Board ( geht natürlich auch ohne, nur ich habe zur Kontrolle die LEDs auf dem Board verwendet ).
• 1x Steckbrett ( s. Bilder ).
• 18x Kabel ( nicht alle sind nötig ;) )

Die Idee und der praktische Nutzen: 

1.) Idee:
4-Bit Austausch mit nur 5 Leitungen und 0 Übertragungsfehlern.

Die ersten vier Leitungen sind für die Daten ( also die 4-Bits ), während die fünfte die Kontrollleitung ist, mit der eine Fehlerlose Übertragung gewährleistet wird ( mehr dazu weiter unten ).
2.) Der Nutzen:
Das ganze dient unter anderem dazu, dass man an einem Mikrocontroller nicht alle Pins belegt hat, sondern nur fünf. Ein zweiter Mikrocontroller übernimmt dann die Arbeit für den ersten, der seine Rechenleistung und auch seine Pins für andere ( eventuell wichtigere ? ) Dinge widmen kann.

Pinbelegung am ATmega8

Die Umsetzung:

1.) Aussuchen der Pins:

Ich habe am ATmega8 die Pins PC0 - PC4 genommen, da diese nahe beieinander liegen, sodass das verkabeln auf dem Steckbrett relativ einfach war. Es können allerdings auch alle möglichen andere Pins gekommen werden!
Am ATmega16 habe ich PA0-PA4 genommen. Da ich durch das Pollin-Board am ATmega16 nichts verkabeln musste und diese noch frei sind, nahm ich diese. Auch hier können alle anderen, freien Pins genommen werden ( Achtung: Beim Pollin-Board sind einige Pins, die z.B. PD5, durch ein Element des Boardes, hier eine LED, vorbelegt! ).

Hier also nochmal die ausgesuchten Pins:

Pin Typ	ATmega8	ATmega16
Datenpins	PC0 - PC3	PA0 - PA3
Kontrollpin	PC4	PA4

Schaltplan für Verbindungen

2.) Vorgang der Software:

Die Software, also die beiden Programme, die auf den Mikrocontrollern laufen, sollten ohne Großen Aufwand und Fehler die Daten übertragen, dabei hat sich nach einigen Fehlversuchen folgender Ablauf ergeben:
Im folgenden sind m16 = ATmega16 und dementsprechend m8 = ATmega8!

Der ATmega8 auf dem Steckbrett

1. m16 setzt PA0-PA3 auf die gewünschten Bits ( also An/Aus ).
2. m16 wartet solange, bis auf PA4 eine Spannung liegt.
3.  m8 prüft ob er etwas mit der Kombination aus 0len und 1en etwas anfangen kann und führt die Aktion aus, die er dann machen soll ( im Code-Beispiel: LED an- / ausschalten ).
4. m8 setzt auf PC4 ( am m16 ist es PA4 ) eine Spannung an.
5. m8 wartet solange, bis PC0-PC3 vom m16 auf 0 geschaltet wurden.
6. m16 registriert, dass auf PA4 eine Spannung liegt und schaltet dementsprechend alle Ports auf 0 ( also PA0-PA3 ).
7. m16 wartet zur Sicherheit solange, bis auf PA4 KEINE Spannung mehr anliegt ( kann man auch weglassen, aber ich habe diese Schleife zur Sicherheit drin gelassen, da ein erneuter Übertragungsversuch nicht immer klappt ).
8. m8 registriert, dass alle Datenpins ( PC0-PC3 ) auf 0 gesetzt wurden, verlässt die Schleife ( 5. ) und setzt PC4 auf low ( 0 ).

Nun können wieder neue Bits gesendet werden, sprich es kann bei 1. wieder losgehen.

3.)  Das Programmieren:
Nach anfänglichen Schwierigkeiten funktionierte der Code dennoch recht schnell und übertrug die Bits bisher ohne Fehler. Er ist zwar nicht sehr sauber programmiert und es gibt auch viele Stellen für Verbesserungen, aber immerhin erfüllt er einen Zweck.


Demnächst kommt eventuell noch ein Beitrag, wo ich dann die check() und send() Funktionen in eine Headerdatei packe und auch noch ein wenig überarbeite.

Download: Kommunikation.7z ( 18 kb )

Der Download Enthält:
- Sourcecode für m8/16
- Makefiles für m8/16 ( stk500v2 Bootloader )

Was als nächstes kommt:
Zu Weihnachten habe ich ja ein paar kleine Spielereien ( s.o. ) bekommen, die man alle prima mit einem Mikrocontroller verbinden kann. Also wird es demnächst ein paar neue Bauteile / Boards geben, die ich dann mit meinem Pollinboard und / oder einem einzelnen µC verbinde.

Viel Spaß beim testen und basteln ;)

mfg
Hauke

LCD Display mit ATmega16

Hallo, endlich kommt mal wieder was ;)

Abb.1: Mein 2x16 LCD Display.

Ich habe vor ca. einem Monat ( ~ Mitte Oktober ) ein 2x16 LCD Display geschenkt bekommen ( siehe Abb.1 ). Nun wollte ich natürlich unbedingt das Teil auch ausprobieren. Allerdings hatte ich so meine Startschwierigkeiten, weswegen ich es erst vor wenigen Tagen geschafft habe.


Problem:
 

Die Anschlussbelegung ( s. Abb.2 ):
Es gibt viele Tutorials, in denen gezeigt wird, wie man so ein LCD Display mit einem Standart Controller anschließt und auch ansteuert. Manche Tutorials sind allerdings unverständlich und auch manchmal falsch, was bei der Anschlussbelegung ( also wie man die 16 Pins des Displays anschließt ) zur Folge hat, dass nichts funktioniert.
Im AVR-GCC Tutorial von mikrocontroller.net habe ich allerdings ein gutes und funktionierendes Tutorial mit Code gefunden. Zum Tutorial

Anschlussbelegung bei einem LCD Display mit dem HD44780-Controller:

Abb.2: Belegung der Pins.

Abb.3: So sieht das ganze verkabelt aus.

Pin #-LCD	Bezeichnung-LCD	Pin-µC
1	Vss	GND
2	Vcc	VCC
3	Vee	mit 330 OHM Wiederstand an GND
4	RS	PD4
5	RW	GND
6	E	PD5
7	DB0	offen (unbenutzt)
8	DB1
9	DB2
10	DB3
11	DB4	PD0 am AVR
12	DB5	PD1 am AVR
13	DB6	PD2 am AVR
14	DB7	PD3 am AVR
15	LED - Beleuchtung: -	VCC
16	LED - Beleuchtung: +	PB7

Abb.4: Mit Pollin-Board von oben.

Programmieren mit C:

Zum Programmieren habe ich die Headerdatei lcd-routines.h, sowie die lcd-routines.c Datei vom Tutorial genommen, da diese gut funktioniert und einfach zu benutzen ist. Danach musste ich die .c Datei noch compilieren, aber das geht mit ProgrammersNotepad2 ( aus WIN-AVR Paket ) ja ganz schnell.

Nach anfänglichen Schwierigkeiten auch auf Seiten des Programmtextes gibts hier nun den fertigen Code.

Abb.5: Steckbrett mit LCD-Display.

//
//    Anpassungen im makefile:
//    lcd-routines.c in SRC = ... Zeile ANHÄNGEN
//
#include <avr/io.h>
#include <util/delay.h>
#include "lcd-routines.h"

int main(void)
{
    DDRB |= 1 << PORTB7;
  // Initialisierung des LCD
  // Nach der Initialisierung müssen auf dem LCD vorhandene schwarze Balken
  // verschwunden sein
  lcd_init();

  lcd_setcursor( 0, 1 );
  lcd_string("Hallo Welt!");
  lcd_setcursor( 0, 2 );
  lcd_string("me-and-my-mc");

  PORTD ^= 1 << PORTD7;
  int i = 0;
  while(1)
  {
  PORTD ^= 1 << PORTD7;
  _delay_us(i);
  }

  return 0;
}

// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/HD44780
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung
//
// Die Pinbelegung ist über defines in lcd-routines.h einstellbar

#include <avr/io.h>
#include "lcd-routines.h"
#include <util/delay.h>

////////////////////////////////////////////////////////////////////////////////
// Erzeugt einen Enable-Puls
static void lcd_enable( void )
{
    LCD_PORT |= (1<<LCD_EN);     // Enable auf 1 setzen
    _delay_us( LCD_ENABLE_US );  // kurze Pause
    LCD_PORT &= ~(1<<LCD_EN);    // Enable auf 0 setzen
}

////////////////////////////////////////////////////////////////////////////////
// Sendet eine 4-bit Ausgabeoperation an das LCD
static void lcd_out( uint8_t data )
{
    data &= 0xF0;                       // obere 4 Bit maskieren

    LCD_PORT &= ~(0xF0>>(4-LCD_DB));    // Maske löschen
    LCD_PORT |= (data>>(4-LCD_DB));     // Bits setzen
    lcd_enable();
}

////////////////////////////////////////////////////////////////////////////////
// Initialisierung: muss ganz am Anfang des Programms aufgerufen werden.
void lcd_init( void )
{
    // verwendete Pins auf Ausgang schalten
    uint8_t pins = (0x0F << LCD_DB) |           // 4 Datenleitungen
                   (1<<LCD_RS) |                // R/S Leitung
                   (1<<LCD_EN);                 // Enable Leitung
    LCD_DDR |= pins;

    // initial alle Ausgänge auf Null
    LCD_PORT &= ~pins;

    // warten auf die Bereitschaft des LCD
    _delay_ms( LCD_BOOTUP_MS );
   
    // Soft-Reset muss 3mal hintereinander gesendet werden zur Initialisierung
    lcd_out( LCD_SOFT_RESET );
    _delay_ms( LCD_SOFT_RESET_MS1 );

    lcd_enable();
    _delay_ms( LCD_SOFT_RESET_MS2 );

    lcd_enable();
    _delay_ms( LCD_SOFT_RESET_MS3 );

    // 4-bit Modus aktivieren
    lcd_out( LCD_SET_FUNCTION |
             LCD_FUNCTION_4BIT );
    _delay_ms( LCD_SET_4BITMODE_MS );

    // 4-bit Modus / 2 Zeilen / 5x7
    lcd_command( LCD_SET_FUNCTION |
                 LCD_FUNCTION_4BIT |
                 LCD_FUNCTION_2LINE |
                 LCD_FUNCTION_5X7 );

    // Display ein / Cursor aus / Blinken aus
    lcd_command( LCD_SET_DISPLAY |
                 LCD_DISPLAY_ON |
                 LCD_CURSOR_OFF |
                 LCD_BLINKING_OFF);

    // Cursor inkrement / kein Scrollen
    lcd_command( LCD_SET_ENTRY |
                 LCD_ENTRY_INCREASE |
                 LCD_ENTRY_NOSHIFT );

    lcd_clear();
}
 
////////////////////////////////////////////////////////////////////////////////
// Sendet ein Datenbyte an das LCD
void lcd_data( uint8_t data )
{
    LCD_PORT |= (1<<LCD_RS);    // RS auf 1 setzen

    lcd_out( data );            // zuerst die oberen,
    lcd_out( data<<4 );         // dann die unteren 4 Bit senden

    _delay_us( LCD_WRITEDATA_US );
}

////////////////////////////////////////////////////////////////////////////////
// Sendet einen Befehl an das LCD
void lcd_command( uint8_t data )
{
    LCD_PORT &= ~(1<<LCD_RS);    // RS auf 0 setzen

    lcd_out( data );             // zuerst die oberen,
    lcd_out( data<<4 );           // dann die unteren 4 Bit senden

    _delay_us( LCD_COMMAND_US );
}

////////////////////////////////////////////////////////////////////////////////
// Sendet den Befehl zur Löschung des Displays
void lcd_clear( void )
{
    lcd_command( LCD_CLEAR_DISPLAY );
    _delay_ms( LCD_CLEAR_DISPLAY_MS );
}

////////////////////////////////////////////////////////////////////////////////
// Sendet den Befehl: Cursor Home
void lcd_home( void )
{
    lcd_command( LCD_CURSOR_HOME );
    _delay_ms( LCD_CURSOR_HOME_MS );
}

////////////////////////////////////////////////////////////////////////////////
// Setzt den Cursor in Spalte x (0..15) Zeile y (1..4)

void lcd_setcursor( uint8_t x, uint8_t y )
{
    uint8_t data;

    switch (y)
    {
        case 1:    // 1. Zeile
            data = LCD_SET_DDADR + LCD_DDADR_LINE1 + x;
            break;

        case 2:    // 2. Zeile
            data = LCD_SET_DDADR + LCD_DDADR_LINE2 + x;
            break;

        case 3:    // 3. Zeile
            data = LCD_SET_DDADR + LCD_DDADR_LINE3 + x;
            break;

        case 4:    // 4. Zeile
            data = LCD_SET_DDADR + LCD_DDADR_LINE4 + x;
            break;

        default:
            return;                                   // für den Fall einer falschen Zeile
    }

    lcd_command( data );
}

////////////////////////////////////////////////////////////////////////////////
// Schreibt einen String auf das LCD

void lcd_string( const char *data )
{
    while( *data != '\0' )
        lcd_data( *data++ );
}

////////////////////////////////////////////////////////////////////////////////
// Schreibt ein Zeichen in den Character Generator RAM

void lcd_generatechar( uint8_t code, const uint8_t *data )
{
    // Startposition des Zeichens einstellen
    lcd_command( LCD_SET_CGADR | (code<<3) );

    // Bitmuster übertragen
    for ( uint8_t i=0; i<8; i++ )
    {
        lcd_data( data[i] );
    }
}

// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung
//

#ifndef LCD_ROUTINES_H
#define LCD_ROUTINES_H

////////////////////////////////////////////////////////////////////////////////
// Hier die verwendete Taktfrequenz in Hz eintragen, wichtig!

#ifndef F_CPU
#define F_CPU 3686400
#endif

////////////////////////////////////////////////////////////////////////////////
// Pinbelegung für das LCD, an verwendete Pins anpassen
// Alle LCD Pins müssen an einem Port angeschlossen sein und die 4
// Datenleitungen müssen auf aufeinanderfolgenden Pins liegen

//  LCD DB4-DB7 <-->  PORTD Bit PD0-PD3
#define LCD_PORT      PORTD
#define LCD_DDR       DDRD
#define LCD_DB        PD0

//  LCD RS      <-->  PORTD Bit PD4     (RS: 1=Data, 0=Command)
#define LCD_RS        PD4

//  LCD EN      <-->  PORTD Bit PD5     (EN: 1-Impuls für Daten)
#define LCD_EN        PD5

////////////////////////////////////////////////////////////////////////////////
// LCD Ausführungszeiten (MS=Millisekunden, US=Mikrosekunden)

#define LCD_BOOTUP_MS           15
#define LCD_ENABLE_US           20
#define LCD_WRITEDATA_US        46
#define LCD_COMMAND_US          42

#define LCD_SOFT_RESET_MS1      5
#define LCD_SOFT_RESET_MS2      1
#define LCD_SOFT_RESET_MS3      1
#define LCD_SET_4BITMODE_MS     5

#define LCD_CLEAR_DISPLAY_MS    2
#define LCD_CURSOR_HOME_MS      2

////////////////////////////////////////////////////////////////////////////////
// Zeilendefinitionen des verwendeten LCD
// Die Einträge hier sollten für ein LCD mit einer Zeilenlänge von 16 Zeichen passen
// Bei anderen Zeilenlängen müssen diese Einträge angepasst werden

#define LCD_DDADR_LINE1         0x00
#define LCD_DDADR_LINE2         0x40
#define LCD_DDADR_LINE3         0x10
#define LCD_DDADR_LINE4         0x50

////////////////////////////////////////////////////////////////////////////////
// Initialisierung: muss ganz am Anfang des Programms aufgerufen werden.
void lcd_init( void );

////////////////////////////////////////////////////////////////////////////////
// LCD löschen
void lcd_clear( void );

////////////////////////////////////////////////////////////////////////////////
// Cursor in die 1. Zeile, 0-te Spalte
void lcd_home( void );

////////////////////////////////////////////////////////////////////////////////
// Cursor an eine beliebige Position
void lcd_setcursor( uint8_t spalte, uint8_t zeile );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines einzelnen Zeichens an der aktuellen Cursorposition
void lcd_data( uint8_t data );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines Strings an der aktuellen Cursorposition
void lcd_string( const char *data );

////////////////////////////////////////////////////////////////////////////////
// Definition eines benutzerdefinierten Sonderzeichens.
// data muss auf ein Array[8] mit den Zeilencodes des zu definierenden Zeichens
// zeigen
void lcd_generatechar( uint8_t code, const uint8_t *data );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines Kommandos an das LCD.
void lcd_command( uint8_t data );


////////////////////////////////////////////////////////////////////////////////
// LCD Befehle und Argumente.
// Zur Verwendung in lcd_command

// Clear Display -------------- 0b00000001
#define LCD_CLEAR_DISPLAY       0x01

// Cursor Home ---------------- 0b0000001x
#define LCD_CURSOR_HOME         0x02

// Set Entry Mode ------------- 0b000001xx
#define LCD_SET_ENTRY           0x04

#define LCD_ENTRY_DECREASE      0x00
#define LCD_ENTRY_INCREASE      0x02
#define LCD_ENTRY_NOSHIFT       0x00
#define LCD_ENTRY_SHIFT         0x01

// Set Display ---------------- 0b00001xxx
#define LCD_SET_DISPLAY         0x08

#define LCD_DISPLAY_OFF         0x00
#define LCD_DISPLAY_ON          0x04
#define LCD_CURSOR_OFF          0x00
#define LCD_CURSOR_ON           0x02
#define LCD_BLINKING_OFF        0x00
#define LCD_BLINKING_ON         0x01

// Set Shift ------------------ 0b0001xxxx
#define LCD_SET_SHIFT           0x10

#define LCD_CURSOR_MOVE         0x00
#define LCD_DISPLAY_SHIFT       0x08
#define LCD_SHIFT_LEFT          0x00
#define LCD_SHIFT_RIGHT         0x04

// Set Function --------------- 0b001xxxxx
#define LCD_SET_FUNCTION        0x20

#define LCD_FUNCTION_4BIT       0x00
#define LCD_FUNCTION_8BIT       0x10
#define LCD_FUNCTION_1LINE      0x00
#define LCD_FUNCTION_2LINE      0x08
#define LCD_FUNCTION_5X7        0x00
#define LCD_FUNCTION_5X10       0x04

#define LCD_SOFT_RESET          0x30

// Set CG RAM Address --------- 0b01xxxxxx  (Character Generator RAM)
#define LCD_SET_CGADR           0x40

#define LCD_GC_CHAR0            0
#define LCD_GC_CHAR1            1
#define LCD_GC_CHAR2            2
#define LCD_GC_CHAR3            3
#define LCD_GC_CHAR4            4
#define LCD_GC_CHAR5            5
#define LCD_GC_CHAR6            6
#define LCD_GC_CHAR7            7

// Set DD RAM Address --------- 0b1xxxxxxx  (Display Data RAM)
#define LCD_SET_DDADR           0x80

#endif

Download als .zip
( Die Makefile-Datei muss natürlich an den Mikrocontroller, den ihr habd angepasst werden. UND die lcd-routines.c muss eingetragen werden -> s.u. )


LCD-Routines.c in Makefile eintragen:

1.) Makefile mit MFile o.ä. öffnen.
1.1) Wenn ihr MFile nutzt: Unter dem Menüpunkt "Makefile" den Punkt "Enable Editing of Makefile" aktivieren.
2.) Unter SRC = ... folgenes ändern:
Normal steht dort:  SRC = $(TARGET).c
Ihr Schreibt hin:     SRC = $(TARGET).c lcd-routines.c
3.) Speichern und fertig


Das wars auch schon wieder. Ich hoffe ich konnte euch ein paar Interessante Dinge zeigen und/oder euch beibringen. Ich werde gucken, was ich dem nächst mache. Schriebt doch mal in die Kommentare, was ihr gerne wissen wollt, oder interessant fändet. Ich freue mich für alle möglichen Antworten ;)

Download Code als .zip

mfg
Hauke

C statt Bascom

Hallo liebe Leute,

ich habe natürlich auch in Foren etc. meinen Blog vorgestellt und somit auch einige Leser gewonnen.
Unter anderem ist auch bekannt geworden, dass ich ja in Bascom programmiere. Das hat dann eine große Welle von "Warum?" und "Bascom ist Sch****!" losgeschlagen.
Bisher haben mir alle zur Sprache C geraten. Als ich dann vor wenigen Tagen bei meinem Onkel war ( selbst Fachinformatiker ) hat er ebenfalls gesagt, dass ich doch in C programmieren solle.
Ich habe mir natürlich Gedanken gemacht und mich informiert, weil selbst mein Onkel mir dazu geraten hat.

Kurz und gut:
Ich bin auf C umgestiegen.

Warum?
1.) Weil alle es mir geraten haben.
2.) Weil ich nach ein bisschen Recherchen auch bemerkt habe, dass es garnicht so schlecht ist.

Unterschiede, sowie Vor- und Nachteile:
Also von der Syntax ist C eine ganz andere Welt wie Bascom. Es ist in manchen Punkten komplizierter ( alleine schon einen Port an/aus stellen, sprich 5 oder 0V geben ). Aber man merkt auch, dass es halt C, also eine weit verbreitete und bekannte Sprache ist: In mehr Foren findet man Infos und Hilfe und die Syntax ist einem evt. schon durch Java o.ä. bekannt. Wer C kann hat da natürlich einen Vorteil ;)

Vor- Nachteile:
+ Mehr Funktionsumfang
+ Bekannte Syntax
+ Mehr Support in Foren und im Internet

- Schwerer zu lernen
- unverständlicher ( für mich ein wenig )


Wie man genau damit programmiert und welche Programme man nutzen kann werde ich dann in den/dem nächsten Post(s) vorstellen.
Auch werde ich demnächst mal ein paar Scripte posten, wenn sie funktionieren. Das kann noch ein wenig dauern, da ich auch bei meinem RPG weiterkommen möchte, aber das krieg ich schon hin.
Man sollte beachten: Ich musste wieder bei 0 anfangen, da ich ja bisher in Bascom programmiert habe.

mfg
Hauke

Steckbrett

Hallöle,

ich wollte nochmal was posten und zwar: Ich habe im Letzten Post ja schon aufgeführt, dass ich mir so eine 40-Polige Steckleiste bekauft habe ( s. Bild rechts ). Ich habe die Einzelteile mal zusammengelötet und auf ein passendes Steckbrett gesteckt ( so viele Stecker ;) ).

Beim basteln habe ich dann bemerkt, dass ich ALLE Pins vom ATMega16 ( auch die zum programmieren des Chips ) auch dieser Pfostenleiste und somit auf der Steckleiste befinden. Zum Glück sind auch der Platine selbst schon die Bezeichnungen abgedruckt ( GND, VCC, etc.: s. Bild rechts ).

Hier ein Bild zu der Pfosten- und Steckleiste:

Ein IDE Kabel verbindet Board mit Steckbrett.

Pollin-Board ( links ) mit Steckbrett ( rechts ). Die Steckleiste ist mit einem
normalen IDE Kabel mit dem Board Verbunden.

Was man beachten sollte:

Bild 1: 35 Stifte ( vorne ) und Pfostenleiste
mit Lücke ( hinten )

• In der Packung die man beim bestellen bekommt sind drei Teile drin: 1x Pfostenleiste, 1x Platine und 1x Stiftleiste. Die Pfosten- und Stiftleiste sind jeweils 40-polig. Die Platine hat aber nur 35 Pole ( !!! ). Man muss daher 5 ( ! ) Stifte abknipsen ( mit einem Seitenschneider o.ä. ) um die anderen 35 Stifte dann an die Platine zu löten.
• In der bitte der Pfostenleiste gibt es eine 2-Pin breite Lücke ( s. Bild 1 ). Diese Lücke muss richtung Stifte zeigen, da sonst die Belegung nicht passt.
• Nicht alle Pins der Pfostenleiste sind mit der Stiftleiste verbunden, einige bleiben unbelegt.
• 

  Bild 2: Die Lücke muss zu den Stiften zeigen!

  Bei manchen Steckbrettern muss man Mut haben die Siftleiste hinein zu drücken. Am besten geht das, wenn man die Platine mit einem Schraubenzieher zwischen Pfosten- und Stiftleiste hineindrückt
• Prüft ob alle Stifte Kontakt zur Pfostenleiste haben!

Programmieren mit der Stiftleiste:
Das Progrsmmieren mit der Stiftleiste ist ganz einfach und unterschiedet sich eigentlich nicht vom normalen Programmieren. Jeder Pin der Stiftleiste hat eine Bezeichnung ( PB0, PB5, PA1, etc. ) Jeden Pin kann man ansteuern ( Output oder Input ). Wenn man nun beim ATMega16 den Port D5 ( PD5 ) als Output definiert und eine Spannung anlegt, dann leuchtet auf dem Pollin-Board die LED1 und gleichzeitig hat man auf dem Steckbrett am 5. Stift von oben eine Spannung anliegen ( dort liegt nämlich der Port D5 ).

Videos:
Demnächst stelle ich ein Video online, wo ich dann zeige, wie das alles genau geht. Eventuell erstelle ich auch einen eigenen Youtube-Kanal. Mal sehen.

• !!! Schreibt bitte in die Kommentare, wie es euch bisher gefällt und wie ihr die Idee mit den Youtube-Kanal findet !!!

mfg
Hauke

Endlich gehts los!

Hallo,

endlich ist mein bestellter Kram da. Was ich mir alles bestellt habe, seht ihr in folgender Liste:

Das habe ich momentan bestellt:

- Atmel Evaluationsboard 2.0.1 ( auch bekannt als "Pollin-Board" )
- Den ATMega 16 von Atmel
- Den MySmart USB light Adapter ( USB auf 6-Poligen ISP )
- Einen Adapter von 6-Poligem ISP auf 10-Poligem ISP ( da auf dem Board der 10 Polige ISP Anschluss zum programmieren da ist )
- Einen Streifen-/Punktrasterplatinenadapter ( 40-Polige Pfostenleiste auf 40-Polige Stiftleiste )

Hier ein paar Fotos der bisherigen Sachen:

Der MySmart USB light Adapter mit ISP-Adapter und Verpackung.

Die beiden Adapter kombiniert. Es bleibt ein 6-Poliges ISP Kabel übrig.

Karton des Pollin-Boardes.

Pollin-Board mit 9V Batterie. Die Netz-LED leuchtet, das heißt, dass das Board unter Strom steht

Die Pfostenleiste ( oben ) und Stiftleiste ( unten ) mit zugehöriger Platine ( mitte ). Alles noch unverlötet.

Programmieren des ATMega16:

Zum Programmieren nehme ich das Programm BASCOM-AVR. Es lässt sich recht einfach Konfigurieren und der Chip lässt sich somit auch von totalen Anfängern programmieren.
Um den Code von Rechner auf den ATMega16 zu bekommen, benutze ich wie oben aufgeführt den MySmart USB light Adapter. Die Konfiguration in BASCOM-AVR war etwas fummelig, aber nach ein paar Versuchen kann man mit F7 oder einem Klick den Code compilieren und direkt auf den Mikrocontroller laden. Das ganze dauert ca. 5-10 Sekunden.

Warum nicht C/C++ oder Assembler:
Weil C/C++ oder Assemlber für mich und evt. auch für euch als Einsteiger nicht einfach ist. Bascom bietet da eine passende Alternative. Eventuell schaue ich mir auch mal Basic an ... mal gucken.

Erster Code:

Erster funktionierender Quellcode in BASCOM-AVR

Downloads:

LED Licht 01.bas ( Quellcode / Source mit Kommentaren )
LED Licht 01.hex ( HEX-Code zum laden per PonyProg o.ä. )


mfg
Hauke

Willkommen

Hallo,

ich starte hier einen neuen Blog zum Thema Mikrocontroller. Ich hoffe einige interessieren sich dafür, bzw. eventuell kann ich einige dafür begeistern.

Warum?
Ich wollte einfach mal sehen ob das ankommt, da ich schon einen anderen Blog habe, habe ich schon ein bisschen Erfahrung im bloggen.
Der Grund, warum ich hier anfange ist der, dass ich mich in die Thematik der Mikrocontroller reinarbeite. Ich habe schon ein paar Sachen bestellt und werde mich darim stetig üben.

Was kommt hier hin?
Alles was ich so erlebe und lerne. Ich teile alle meine Erfahrungen hier und hoffe, dass es nicht langweilig wird. Eventuell drehe ich auch ein paar Videos.

Wann gehts weiter?
Ich habe bei einer gewissen Internetseite ein paar Teile bestellt ( ein Board, einen Mikrocontroller, Zusatzteile ). Wenn alle Teile, die ich gekauft habe ( sind noch ein paar mehr ) eingetroffen sind, beschreibe ich, was ich habe und was ich damit mache.

mfg
Hauke