-         

Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 15

Thema: Zeichen nibbeln

  1. #1
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    06.05.2005
    Ort
    Berlin
    Beiträge
    212

    Zeichen nibbeln

    Anzeige

    Hi,
    bin neu in C- Programmierung und WinAVR.
    Wollte mal fragen, ob's nen netten Menschen gibt, der mir
    beim "Nibbeln" der ASCII-Werte eines Zeichenstrings
    mal auf die Sprünge helfen kann. Ist für die
    4-Bit Ansteuerung eines 4x27 LC-Displays.
    Hab mir schon folgendes Gerüst für eine Unterfunktion
    zurechtgebastelt:

    Code:
    void Textausgabe(void)
    {
    uint8_t UpperNibble,LowerNibble,count;
    //Massstab:   "0xxxxxxxx1xxxxxxxxx2xxxxxx7"
    char Text[27]="0xxxxxxxx1xxxxxxxxx2xxxxxx7";
     for(count=1;count<28;++count)
    	{
    		//Ein Zeichen holen, Typumwandlung uint8_t => char ??? (weiss nicht,ob's das Gleiche ist.)
    		//Unteres Nibbel von Text(count) mit &0xf0 "vernichten", Oberes Nibbel /16 => nach unten (weiss nicht, wie man 4 Bit auf einmal shiftet)
    		//Nibbel ausgeben
    		//Oberes Nibbel "vernullen" ( in Bit 4 und 5 liegen bei mir E1 und E2 des Displays), dann Byte ausgeben.
    	}
    
    }
    Belegung LCDisp. an ATMega8: D4 - D7 an PC0 - PC3, E1 an PC4, E2 an PC5, RS an PB0, R/W an Masse.
    Wär wie gesagt toll, wenn ich da einen "Anschubser" bekäme.
    Vielen Dank schonmal,
    tholan

  2. #2
    Erfahrener Benutzer Robotik Einstein Avatar von SprinterSB
    Registriert seit
    09.06.2005
    Ort
    An der Saar
    Beiträge
    2.801

    Re: Zeichen nibbeln

    Zitat Zitat von tholan
    Hi,
    bin neu in C- Programmierung und WinAVR.
    Wollte mal fragen, ob's nen netten Menschen gibt, der mir
    beim "Nibbeln" der ASCII-Werte eines Zeichenstrings
    mal auf die Sprünge helfen kann. Ist für die
    4-Bit Ansteuerung eines 4x27 LC-Displays.
    Hab mir schon folgendes Gerüst für eine Unterfunktion
    zurechtgebastelt...
    So was in der Richtung? Die Ausgabe hab ich jetzt nicht ausgeführt, das ist abhängig vom Displaytyp/Treiber.

    Code:
    #include <inttypes.h>
    
    void Nibbleausgabe (const uint8_t nibble);
    void Textausgabe (const uint8_t*);
    
    // Massstab:  "0xxxxxxxx1xxxxxxxxx2xxxxxx7"
    char text[] = "0xxxxxxxx1xxxxxxxxx2xxxxxx7";
    
    void Textausgabe (const uint8_t *tx)
    {
            // Zeiger tx läuft durch den String
    
            while (1)
            {
                    uint8_t nibble;
                    // Ein Zeichen holen, Typumwandlung uint8_t => char ??? (weiss nicht,ob's das Gleiche ist.)
                    // Zeichen aus RAM lesen, Zeiger eins weiter
                    uint8_t zeichen = *(tx++);
                    
                    // zeichen == 0 --> Stringende
                    if ('\0' == zeichen)
                            break;
    
                    // Unteres Nibbel von Text(count) mit &0xf0 "vernichten",
                    // Oberes Nibbel /16 => nach unten 
                    nibble = zeichen >> 4;
                    // high Nibbel ausgeben
                    Nibbleausgabe (nibble);
    
                    // Oberes Nibbel "vernullen" 
                    // (in Bit 4 und 5 liegen bei mir E1 und E2 des Displays),
                    // dann Byte ausgeben.
                    nibble = zeichen & 0x0f;
                    // low Nibbel ausgeben
                    Nibbleausgabe (nibble);
            }
    }
    
    void Nibbleausgabe (const uint8_t nibble)
    {
    }
    Disclaimer: none. Sue me.

  3. #3
    Super-Moderator Robotik Visionär Avatar von PicNick
    Registriert seit
    23.11.2004
    Ort
    Wien
    Beiträge
    6.836
    VIelleicht der Zusatz: SPrinter hat auf das "obere Nibble vernichten" verzichtet, da das
    nibble = Zeichen >> 4
    sowieso diese Bits löscht.
    mfg robert
    Wer glaubt zu wissen, muß wissen, er glaubt.

  4. #4
    Erfahrener Benutzer Robotik Einstein Avatar von SprinterSB
    Registriert seit
    09.06.2005
    Ort
    An der Saar
    Beiträge
    2.801
    Jau, dabei ist aber darauf zu achten, daß man die Zeichen als unsigned char (bzw. uint8_t) ausliest.

    Ansonsten wird als oberes Bit beim Schieben nicht die 0 nachgeschoben, sondern das Vorzeichen. Bei Werten von 0x80..0xff bzw -128..-1 müsste man dann explizit noch mit einer Maske die oberen Bits löschen.
    Disclaimer: none. Sue me.

  5. #5
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    21.10.2005
    Ort
    Erde
    Alter
    50
    Beiträge
    1.195
    dann noch:

    while (*tx)

    und man kann die if -abfrage sparen

    Das ausmaskieren des oberen Nibbles ist nur dann nötig, wenn die Portpins anderweitig benutzt und in Nibbleausgabe nicht gesetzt werden.

  6. #6
    Super-Moderator Robotik Visionär Avatar von PicNick
    Registriert seit
    23.11.2004
    Ort
    Wien
    Beiträge
    6.836
    Na, dann noch ein's drauf: Es empfiehlt sich, das "Nibble löschen" gleich in die Nibble-Ausgabe zu verschieben, ein für allemal.
    void Nibbleausgabe (const uint8_t nibble)
    {
    xxx = nibble & 0x0F;
    .....
    }
    mfg robert
    Wer glaubt zu wissen, muß wissen, er glaubt.

  7. #7
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    06.05.2005
    Ort
    Berlin
    Beiträge
    212
    Super!
    Ich denk, damit komm ich klar und weiter!
    Bin halt ziemlich BASIC-versaut.
    Zeichen mit Zeigern ausm RAM lesen und
    Byte shiften gibts da halt nicht.
    Danke nochmal,
    tholan

  8. #8
    Erfahrener Benutzer Robotik Einstein Avatar von SprinterSB
    Registriert seit
    09.06.2005
    Ort
    An der Saar
    Beiträge
    2.801
    Zitat Zitat von ogni42
    dann noch:

    while (*tx)

    und man kann die if -abfrage sparen.
    Jo, damit spart man aber nur Quellcode, der erzeugte Code wird länger
    Disclaimer: none. Sue me.

  9. #9
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    06.05.2005
    Ort
    Berlin
    Beiträge
    212
    Könnt ihr euch nochmal angucken, was ich jetzt verbrochen habe?
    Code:
    void Textausgabe(void)
    {
    const uint8_t *tx;
    uint8_t nibble, zeichen;
    char text[]="Lieber blau, als grau.";
     while(1)
    	{
    		zeichen = *(tx++);
    		if ('\0' == zeichen)
    			break;
    		nibble = zeichen >> 4;
    		PORTC = nibble;		//Zeichen anlegen...
    		Dat_tog_E1();		//und Feuer!
    		nibble = zeichen & 0x0f; //muss maskiert sein, wg. E1 / E2 an PC4 / PC5
    		PORTC = nibble;
    		Dat_tog_E1();
    	}
    }
    Der Compiler läuft durch und meckert nur noch, daß *tx evtl. nicht initialisiert ist
    und das char text[] nicht benutzt wird (logisch).
    Wie lasse ich jetzt *tx auf den String zeigen?
    Der Cursor auf'm Display rutscht übrigens schon brav um eins weiter und malt
    mir davor 'ne Hieroglyphe.
    thx

  10. #10
    Super-Moderator Robotik Visionär Avatar von PicNick
    Registriert seit
    23.11.2004
    Ort
    Wien
    Beiträge
    6.836
    Kollege (*tadel*) tx is ja auch nicht initialisiert, das gibt stunk beim Ablauf

    Muttu machen:
    char text[]="Lieber blau, als grau.";
    const uint8_t *tx = (uint8_t)&text; // addresse von text reinschreiben

    Is ja wohl nur eine Testroutine ?
    Zeichen mit Zeigern ausm RAM lesen und Byte shiften gibts da halt nicht.
    Sag das nicht !
    mfg robert
    Wer glaubt zu wissen, muß wissen, er glaubt.

Seite 1 von 2 12 LetzteLetzte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •