Mikrocontroller – Ein Leitfaden für Anfänger – String-Übergabe an das LCD mittels Zeiger

Mikrocontroller – Ein Anfängerhandbuch – Übergabe eines Strings an das LCD mittels Zeiger

Wir hatten eine großartige Möglichkeit, Zeichen auf dem Display anzuzeigen und das Display so zu steuern, wie wir es wollten. Warum sollten wir also etwas anderes tun müssen? Wenn wir ein Zeichen nach dem anderen senden müssten, wäre die Programmierung sehr mühsam. Wir hätten auch keine gute Möglichkeit, Zahlen anzuzeigen. Lassen Sie uns also das Programm erweitern, um viele Zeichen mit einem einzigen Befehl anzuzeigen.

Wie wird das Programm funktionieren? Wir werden den Zeichenstring zuerst in einem Befehl einführen, wie folgt:

Send_A_String("NewbieHack.com");. Wir müssen das Programm dazu bringen, den Zeichenstring zu durchlaufen. Wir haben einige Optionen, wie wir dies tun können. Wir könnten den String in einem Zeichenarray speichern und dann eine Schleife erstellen, um das Array zu durchlaufen und jedes Zeichen anzuzeigen. Aber wir wissen bereits ein wenig über die Verwendung von Arrays. Fordern wir uns selbst heraus und verwenden Zeiger. Zeiger mögen tatsächlich in den mittleren Programmierbereich vorstoßen, aber es gibt keinen Grund, warum wir den Zeiger für diese Operation nicht verwenden können.

Zeiger beschreiben sich ziemlich gut selbst. Sie zeigen. Der Zeiger akzeptiert Speicheradressen, aber er gibt den Wert der Daten an dieser Speicheradresse zurück. Das heißt, sie zeigen auf Speicherorte "sehen den Wert", anstatt den Wert zu enthalten. Im Video verwende ich die Analogie, Speicheradressen mit den Adressen von Häusern in einer Stadt zu vergleichen. Jeder Speicherort muss eine Adresse enthalten (ähnlich der Adresse eines Hauses). Sie können Daten in diesen Speicherorten speichern. Nehmen wir also an, wir speichern einen Zeichenstring wie "NewbieHack.com" im Speicher und wir weisen den Zeiger an, auf diesen Zeichenstring zu zeigen. Anfänglich wird dieser Zeiger auf das "N" im String zeigen. Wenn Sie den Zeiger um eins (1) erhöhen, zeigt er auf das "e". Wenn Sie dies für jedes Zeichen tun, gelangen Sie schließlich zum Ende, das mit einer 0 oder null gefüllt ist. Das Nullzeichen oder "0" informiert uns, wo wir die Schleife anhalten können, während wir den String durchlaufen.

Der Zeiger sieht aus wie eine Standardvariable, aber mit einem kleinen Unterschied. Der Zeiger verwendet das Sternchen (*) vor der Variable. Zum Beispiel könnte eine Standarddeklaration einer Variablen mit dem Datentyp char sein: char aCharacter = 0x41;. 0x41 ist ein ASCII-Code (American Standard Code for Information Interchange) und repräsentiert das Zeichen "A". "aCharacter" ist die Variable, die den Datentyp "char" hat. Wenn wir ein * direkt vor die Variable setzen (kann auch direkt nach dem Datentyp stehen), wird die Variable zu einem Zeiger.

Wir wissen also, wie der Befehl aussehen könnte: Send_A_String("NewbieHack.com");. Wie könnte die Routine aussehen, um jedes Zeichen an das Display zu senden? Sie wird eine Schleife enthalten, die das Ende des Strings überprüft, und der Zeiger wird am Ende mit dem unären Operator "++" inkrementiert. Denken Sie daran, dass ++ nur eine Abkürzung zum Inkrementieren einer Variablen ist. Es könnte so aussehen: aValue++; Unseres wird ein Sternchen haben, es könnte also so aussehen: *aPointer++; Lassen Sie sich nicht vom Variablennamen verwirren, er kann fast alles sein. Hier ist also, wie die Routine aussehen könnte:

void Send_A_String(char *StringOfCharacters)
{
while(*StringOfCharacters > 0)
{
Send_A_Character(*StringOfCharacters++);
}
}

Wow, das ist eine sehr kurze Routine. Das ist der Vorteil der Verwendung von Zeigern. Wenn Sie den Befehl Send_A_String("NewbieHack.com"); senden, wird der String "NewbieHack.com" automatisch an einem vom Mikrocontroller gewählten Speicherort gespeichert, aber wir MENSCHEN haben nicht die geringste Ahnung, wo sich dieser Speicherort befindet. Deshalb hat der MENSCH Zeiger geschaffen!! Gott sei Dank für den Zeiger, denn jetzt können Sie diesen Zeiger einfach inkrementieren und er zeigt auf jedes der Zeichen und informiert den MENSCHEN über den Inhalt jedes dieser Speicherorte. Das wirklich Coole ist, dass all dies im Befehl Send_A_Character() geschieht. Innerhalb dieser schönen Klammern. Beachten Sie die Sternchen, die überall in der Routine verstreut sind.

So könnte das vollständige Programm aussehen:

include
#include

#define MrLCDsCrib PORTB
#define DataDir_MrLCDsCrib DDRB
#define MrLCDsControl PORTD
#define DataDir_MrLCDsControl DDRD
#define LightSwitch 5
#define ReadWrite 7
#define BiPolarMood 2
void Check_IF_MrLCD_isBusy(void);
void Peek_A_Boo(void);
void Send_A_Command(unsigned char command);
void Send_A_Character(unsigned char character);
void Send_A_String(char *StringOfCharacters);

int main(void)
{
DataDir_MrLCDsControl |= 1< _delay_ms(15);

Send_A_Command(0x01); //Clear Screen 0x01 = 00000001
_delay_ms(2);
Send_A_Command(0x38);
_delay_us(50);
Send_A_Command(0b00001110);
_delay_us(50);

Send_A_String("NewbieHack.com");

while(1)
{
}
}

void Check_IF_MrLCD_isBusy()
{
DataDir_MrLCDsCrib = 0;
MrLCDsControl |= 1< MrLCDsControl &= ~1<
while (MrLCDsCrib >= 0x80)
{
Peek_A_Boo();
}

DataDir_MrLCDsCrib = 0xFF; //0xFF means 0b11111111
}
void Peek_A_Boo()
{
MrLCDsControl |= 1< asm volatile ("nop");
asm volatile ("nop");
MrLCDsControl &= ~1< }

void Send_A_Command(unsigned char command)
{
Check_IF_MrLCD_isBusy();
MrLCDsCrib = command;
MrLCDsControl &= ~ ((1< Peek_A_Boo();
MrLCDsCrib = 0;
}

void Send_A_Character(unsigned char character)
{
Check_IF_MrLCD_isBusy();
MrLCDsCrib = character;
MrLCDsControl &= ~ (1< MrLCDsControl |= 1< Peek_A_Boo();
MrLCDsCrib = 0;
}

void Send_A_String(char *StringOfCharacters)
{
while(*StringOfCharacters > 0)
{
Send_A_Character(*StringOfCharacters++);
}
}

Wenn Ihnen dieser Code verwirrend erscheint, sollten Sie das frühere Tutorial durchlesen.

Zurück zum Blog

Hinterlasse einen Kommentar

Bitte beachte, dass Kommentare vor der Veröffentlichung freigegeben werden müssen.