[Unzap] Abschaltcodes

[Stefan Uhl]

* Alexander Neumann <fd0 at lochraster.org> [081015 22:25]:
> * Stefan Uhl <s.uhl at gmx.net> wrote:
> > [...]
> > Alexander: Was meinst du? Ist bei sowas der Parser klein genug? 
> 
> Klingt ganz cool, aber das kann man meistens erst hinterher sagen.
> Implementierst dus? ;)

Wie wärs mit sowas:


parse_code(uint8_t *hptr){ /* hptr zeige auf den Anfang des Headers  */
        uint16_t *bptr;
        uint16_t w[4], seq[];
        uint8_t pattern[], a, b, head, hlen, plen, scount;

        hlen = *hptr++;
        scount = 0;

        /* Hier sollte man den Bodypointer setzen, aber dazu müßte ich 
         * erst rausfinden, wie man aus 8-Bit-Zeigern 16-Bit-Zeiger macht. 
         * Außerdem die Frequenzinformationen einlesen, die am Anfang des 
         * Bodys stehen */

        for (uint8_t i = 0; i < hlen; i++){
                head = *hptr++;
                plen = head >> 2;
                if (head & 0x02){       /* nicht raw */
                        for (uint8_t j = 0; j < 4; j++) w[i] = *bptr++;
                        for (uint8_t j = 0; j < (plen + 7)/8;j++){
                                pattern[i++] = HI8(*bptr);
                                pattern[i] = LO8(*bptr++);
                        }
                        if (! head & 0x01){ /* Manchestercode */
                                a = pattern[0] & 0x01;
                                if (a) seq[scount++] = w[a];
                                else if (scount) seq[scount-1] += w[a];
                                for (uint8_t j = 1; j <= plen; j++){
                                        b = (pattern[j>>3] >> j & 0x07) & 0x01;
                                        if (a | b){
                                                seq[scount++] = w[b];
                                                seq[scount++] = w[a];
                                        }
                                        else seq[scount++] = w[2 + b];
                                        a = b;
                                }
                                seq[scount++] = w[++a & 0x01];
                        }
                        else if (head & 0x02){ /* 2bit pro Puls/Pause */
                                for (uint8_t j = 0; j < plen; j + 2){
                                        a = (pattern[j>>3] >> j & 0x07) & 0x03;
                                        seq[scount++] = w[a];
                                }
                        }
                        else {  /* Puls/Pausenweitenmodulation */
                                for (uint8_t j = 0; j < plen; j++){
                                        a = (pattern[j>>3] >> j & 0x07) & 0x01;
                                        seq[scount++] = w[2 * a];
                                        seq[scount++] = w[2 * a + 1];
                                }
                        }
                }
                else for (uint8_t j = 0; j < plen; j++) seq[scount++] = *bptr++;
        }
        
        seq[scount] = 0x0000;

        /* nun hat man einen Vektor seq der Länge scount mit abwechselnd 
         * Puls- und Pausenzeiten. Den muß man nun nur noch senden.... */

}

Ich hoff, ich hab die die Punkt-vor-Strichrechenregeln für &, * , ++ und
so richtig hingekriegt... Es ist doch richtig, daß in C ein Wert
ungleich 0 Wahr ist oder? 

Seh ich das richtig, daß man zum Senden Puls und Puls+Pausezeit braucht?
Dann muß man beim Senden nochmal addieren. Anders würde ich die
Manchestercodes nicht richtig hinkriegen.

Die Manchestercodes sind jetzt mit Puls-Pause als 1 (umgekehrt wie rc5)
codiert. Will man's andersrum haben, muß man die richtigen a und b vertauschen.
Alle außer den Manchestercodes können auch ungerade Längen haben...

Hmm. C ist doch nicht so schwer...

Stefan

> _______________________________________________
> unzap mailing list
> unzap at lochraster.org
> http://lists.gnuzifer.de/mailman/listinfo/unzap