Bitweiser Vergleich funktioniert nicht

[Riebers (Gast)]

Moin Elite,

ich habe eine char Variable und möchte jeweils prüfen, ob die einzelnen 
Bits '1' oder '0' sind. Dabei soll für eine bestimmte Dauer ein Ausgang 
auf High oder Low geschaltet werden. Das ganze läuft innerhalb der ISR 
ab. Das Problem welches ich habe ist, dass der char irgendwie falsch 
herum ausgelesen wird, obwohl das eigentlich nicht sein kann. Hier mal 
mein Code.

 
static unsigned char TMR0_Overflow = 0; // Zählt die Überlaufe von TMR0
static unsigned char index = 128;       // Dient zur Ausgabe von Data
static unsigned char Data = 0xAA;              // 10101010
static unsigned char T = 100;         // Mid-Bit Time T (Period Time = 2*T)
// Der Abschnitt aus der ISR
TMR0_Overflow++;
if(TMR0_Overflow==T){
  if(Data & index) {
     LATC=0x01;
  }else{
     LATC=0x00;
  }

  index /=2;
  TMR0_Overflow=0;
  if(index==0){
    index=128;
  }
}

Alles was vor diesem Abschnitt ausgeführt werden soll passt soweit, blos 
hier wird nicht wie erwartet die 10101010 sondern komischer weise 
010101010 ausgegeben :(
Das habe ich mit einem Oszilloskop gemessen. Hat jemand nen Schimmer 
warum das so ist?

Beste Grüße

Riebers

[Rainer U. (r-u)]

Vielleicht hat die Leitung einen Pull up aktiviert, und/oder Du 
interpretierst den Anfang falsch? sende doch mal 01101111 und zum 
Vergleich 10010000 - wie sieht es da aus?

[Falk B. (falk)]

@Riebers (Gast)

>ich habe eine char Variable und möchte jeweils prüfen, ob die einzelnen
>Bits '1' oder '0' sind.

Siehe Bitmanipulation.

>static unsigned char index = 128;       // Dient zur Ausgabe von Data

Bei sowas schreibt man das besser binär (wenn es der Compiler kann, denn 
das ist kein Standard-C) oder in Hexadezimal. Das ist besser lesbar.

>  index /=2;

Hier macht man besser eine Schiebeoperation, auch wenn die meisten 
Compiler das automatisch machen.

>Alles was vor diesem Abschnitt ausgeführt werden soll passt soweit, blos
>hier wird nicht wie erwartet die 10101010 sondern komischer weise
>010101010 ausgegeben :(

Das ist doch das Gleiche, wenn es aneinandergereiht ist. Den Unterschied 
sieht man nur, wenn es einmalig ausgegeben wird.

[Lutz (Gast)]

Riebers schrieb:
> static unsigned char TMR0_Overflow = 0; // Zählt die Überlaufe von TMR0

Meckert der Compiler nicht, wenn du einen int einem char zuweisen 
willst?
=> '0' usw.

[Riebers (Gast)]

@Falk Brunner
Ich habe auch Versucht das als Schieberegister zu machen, hat aber auch 
nicht geklappt. Ich gebe vorher eine definierte Bitfolge aus. Das ganze 
dient zum Daten versenden. Es beginnt mit einem Startbit, dann eine 
Bitfolge für die Synchronisation des Empängers, dann eine kurze Pause 
damit der Empänger sich Synchronisieren kann. Dann sollen Nutzdaten 
geschickt werden. Jedoch, wie schon erwähnt, ist der ganze Byte um eins 
nach rechts Verschoben. Habe es schon mit 11111111 versucht. Es kommt 
aber nur 7 mal die '1' an. Dafür vor dem Byte noch eine '0'.
Ich Versuche nochmal das als Register zu programmieren TT .

Danke soweit

Riebers

[Riebers (Gast)]

Ich habe das mal für den Vergleich Bitweise geschoben. Ist aber immer 
noch der gleiche Fehler. Oder liegt das an was anderem?! Hier mal der 
Code falls jemanden was auffällt.

void TMR0_ISR(void)
{
    static unsigned char step_counter = 0;
    static unsigned int Data = 0xFF;        // 10101010
    static unsigned char T = 100;            // Mid-Bit Time T (Period Time = 2*T)
    static unsigned char StartBit = 0;
    static unsigned char TMR0_Overflow = 0;
    static unsigned int index = 0x80;
    // Clear the TMR0 interrupt flag
    INTCONbits.TMR0IF = 0;

    TMR0 = timer0ReloadVal;
    // Start of Data Transmission (5 ms high)
//    StartBit------------------------------------------------------------------
    switch(StartBit){
        case 0:
            LATC=0x01;
            TMR0_Overflow++;
            if(TMR0_Overflow==10) {
                LATC^=0x01;
                TMR0_Overflow=0;
                StartBit=1;
            }
            break;
        // Sync Bits T --- One low Impuls and one high Impuls ---> 2*T----------
        case 1:
            TMR0_Overflow++;
            if(TMR0_Overflow==T) {
                LATC^=0x01;
                TMR0_Overflow=0;
                step_counter+=1;
                if(step_counter==2){
                    step_counter=0;
                    StartBit=2;
                }
            }
            break;
        // Waittime ---> 2*T --- Receiver Calculates T--------------------------
        case 2:
            TMR0_Overflow++;
            if(TMR0_Overflow==2*T) {
                TMR0_Overflow=0;
                StartBit=3;
            }
            break;
        // Data Transmission----------------------------------------------------
        case 3:
            TMR0_Overflow++;
            if(TMR0_Overflow==T){
                if(Data & index) {
                    LATC=0x01;
                }else{
                    LATC=0x00;
                }

                index >>=1;
                TMR0_Overflow=0;
                if(index==0){
                    index=0x80;
                    StartBit=4;
                }
            }

            break;
        // Guard Time (2*T) -- Data Transmission complete-----------------------
        case 4:
            TMR0_Overflow++;
            LATC=0x00;
            if(TMR0_Overflow==2*T){
                StartBit=0;
                TMR0_Overflow=0;
            }
            break;
            
    }
}

@Lutz nee, kommt das Gleiche raus, egal ob ich int oder char nehme...
Die Waittime und Guardtime passen. Habe ich schon überprüft. Irgendwas 
passt bei der Datenübertragung nicht, ich komme aber nicht drauf.

Beste Grüße

[Reiner_Gast (Gast)]

Riebers schrieb:
> case 0:
>             if(TMR0_Overflow==10) {
>                 LATC^=0x01;
>                 TMR0_Overflow=0;
>                 StartBit=1;
>             }
>         case 1:
>             if(TMR0_Overflow==T) {
>                 LATC^=0x01;
>                 TMR0_Overflow=0;
>                 step_counter+=1;
>             }

In den beiden Case Blöcken für die Werte 0 und 1 wird LATC auf 0 
gesetzt, wenn TMR0_Overflow groß genug geworden ist... Ist das evtl. für 
die führende "0" Verantwortlich?

[Joe F. (easylife)]

Machs nicht zu kompliziert.

Riebers schrieb:
> Ich habe auch Versucht das als Schieberegister zu machen, hat aber auch
> nicht geklappt.

Sähe dann so aus:

static unsigned char TMR0_Overflow = 0; // Zählt die Überlaufe von TMR0
static unsigned char Data = 0xAA;              // 10101010
static unsigned char T = 100;         // Mid-Bit Time T (Period Time = 2*T)

// Der Abschnitt aus der ISR
TMR0_Overflow++;
if(TMR0_Overflow==T) {
  LATC = (Data & 0x80) ? 0x01 : 0x00;
  Data <<= 1;
  TMR0_Overflow=0;
}

Zu beachten ist halt, dass Data durch die Schiebeoperationen während der 
Ausgabe verändert wird und hinterher 0x00 ist.

[Theor (Gast)]

Ich schlage vor, dass Du, falls Du ein Zwei-Kanal-Oszilloskop hast, 
während des ersten Bits der Daten eine 1 ausgibst. Dann siehst Du 
eindeutig die Zuordnung.

[Theor (Gast)]

Theor schrieb:
Sorry. Sollte besser heissen:

Ich schlage vor, dass Du, falls Du ein Zwei-Kanal-Oszilloskop hast,
während des ersten Bits der Daten auf einem zusätzlichen Portpin eine 
1 ausgibst. Dann siehst Du eindeutig die zeitliche Zuordnung.

[Apollo M. (Firma: @home) (majortom)]

hallo,
das gelaber hier erscheint mir nutzlos, wenn der to es nicht schaft den 
uc zu benennen und die port config transparent zu machen. weil, einige 
uc kennen port invertierung oder toggle mode oder ...


mt

[Rolf M. (rmagnus)]

Falk B. schrieb:
>>static unsigned char index = 128;       // Dient zur Ausgabe von Data
>
> Bei sowas schreibt man das besser binär (wenn es der Compiler kann, denn
> das ist kein Standard-C) oder in Hexadezimal. Das ist besser lesbar.

Noch besser finde ich:

static unsigned char index = 1 << 7;

>>  index /=2;
>
> Hier macht man besser eine Schiebeoperation, auch wenn die meisten
> Compiler das automatisch machen.

Was er draus macht, sollte man dem Compiler überlassen. Wesentlich ist, 
welche Aktion man beabsichtigt. Aus Gründen besserer Lesbarkeit sollte 
man die dann auch hinschreiben. Also ist der Inhalt der Variablen eher 
eine Zahl, die ich durch zwei dividieren will, oder eine Reihe von Bits, 
die ich um ein Bit nach rechts schieben will? Hier ist es ganz 
offensichtlich letzteres.

[easy (Gast)]

Rolf M. schrieb:
> Noch besser finde ich:static unsigned char index = 1 << 7;

Noch besser finde ich

static unsigned char index = BIT_7;

[Riebers (Gast)]

nochmal für mt.
Nutze einen PICLF1509 und den RC0 Port als Ausgang. Hier initialisiere 
ich die Pins.

void PIN_MANAGER_Initialize(void)
{
    /**
    LATx registers
    */   
    LATA = 0x00;    
    LATB = 0x00;    
    LATC = 0x00;    

    /**
    TRISx registers
    */    
    TRISA = 0x3F;
    TRISB = 0xF0;
    TRISC = 0xFE;

    /**
    ANSELx registers
    */   
    ANSELC = 0xCF;
    ANSELB = 0x30;
    ANSELA = 0x17;

    /**
    WPUx registers
    */ 
    WPUB = 0x00;
    WPUA = 0x00;
    OPTION_REGbits.nWPUEN = 1;

    
    /**
    APFCONx registers
    */
    APFCON = 0x00;


   
    
}

Hier nochmal die PIC Config.

// CONFIG1
#pragma config FOSC = INTOSC    // Oscillator Selection Bits->INTOSC oscillator: I/O function on CLKIN pin
#pragma config WDTE = OFF    // Watchdog Timer Enable->WDT disabled
#pragma config PWRTE = OFF    // Power-up Timer Enable->PWRT disabled
#pragma config MCLRE = ON    // MCLR Pin Function Select->MCLR/VPP pin function is MCLR
#pragma config CP = OFF    // Flash Program Memory Code Protection->Program memory code protection is disabled
#pragma config BOREN = ON    // Brown-out Reset Enable->Brown-out Reset enabled
#pragma config CLKOUTEN = OFF    // Clock Out Enable->CLKOUT function is disabled. I/O or oscillator function on the CLKOUT pin
#pragma config IESO = ON    // Internal/External Switchover Mode->Internal/External Switchover Mode is enabled
#pragma config FCMEN = ON    // Fail-Safe Clock Monitor Enable->Fail-Safe Clock Monitor is enabled

// CONFIG2
#pragma config WRT = OFF    // Flash Memory Self-Write Protection->Write protection off
#pragma config STVREN = ON    // Stack Overflow/Underflow Reset Enable->Stack Overflow or Underflow will cause a Reset
#pragma config BORV = LO    // Brown-out Reset Voltage Selection->Brown-out Reset Voltage (Vbor), low trip point selected.
#pragma config LPBOR = OFF    // Low-Power Brown Out Reset->Low-Power BOR is disabled
#pragma config LVP = OFF    // Low-Voltage Programming Enable->High-voltage on MCLR/VPP must be used for programming

Beste Grüße

Riebers