pc<-RS232->Pic datenfluss kontrollieren

[Christoph H. (obbedair)]

hallo,
ein Pc sendet 12Byte zu einem Pic. Diese 12Byte sind ein Frame für den 
CanBus.
mein Problem: derPc sendet schneller als der Pic den kram verarbeiten 
kann. jetzt stellt sich für mich die frage wie ich das am besten in den 
griff bekomme. handshake? oder jedes empfangene byte zurückschicken, 
quasi als kontrolle und als zeichen das wieder geschickt werden kann???
was ist in diesem Fall die eleganteste Lösung???

Ps: es sind eigentlich nur 6Byte aber ich wollte jedes Byte noch einmal 
aufteilen und die ersten 4 Bit quasi zur numerierung nutzen.

[Frank K. (fchk)]

Die übliche Lösung heißt RTS-CTS Handshake. Die größeren PICs können das 
auch in Hardware machen.

fchk

[Max H. (hartl192)]

Ich sende in solchen Fällen nach jedem Byte ein ACK. Der PC wartet auf 
ACK bevor er das nächste byte sendet.

[A+B=B+A (Gast)]

Christoph Herzog schrieb:
> hallo,
> ein Pc sendet 12Byte zu einem Pic. Diese 12Byte sind ein Frame für den
> CanBus.

Welche Baudrate?


> mein Problem: derPc sendet schneller als der Pic den kram verarbeiten
> kann. jetzt stellt sich für mich die frage wie ich das am besten in den
> griff bekomme. handshake?

Braucht min 1 Leitung mehr

> oder jedes empfangene byte zurückschicken,

löst das Problem nicht

> quasi als kontrolle und als zeichen das wieder geschickt werden kann???
> was ist in diesem Fall die eleganteste Lösung???

Wenn der Pic einen UART hat (also kein Soft-Uart genutzt wird):

Jedes Byte einzeln senden und warten bis es zurück gesendet wird.

Dann das nächste.

Die Uart Hardware ist autonom und meldet wenn das Byte da ist.

Kannst auch Xon/Xoff Software handshake nehmen, das ist ein Standard.

>
> Ps: es sind eigentlich nur 6Byte aber ich wollte jedes Byte noch einmal
> aufteilen und die ersten 4 Bit quasi zur numerierung nutzen.

Das ist die Applikationsebene, hat mit sicherem senden/empfangen nichts 
zu tun.

[Christoph H. (obbedair)]

Baudrate bestimmt der PC... momentan 19200.
ich benutze einen PIC18F2480, dieser scheint kein Hardware-Handshake zu 
haben...
bedeutet ich muss doch einfach ein pin vom pic über den RS232-Treiber an 
den Stecker zum RS232 Kabel löten und kann dann bei Dateneingang sofort 
erstmal sagen "pic busy" und wenn fertig verarbeitet wurde dann "pic 
ready?

[TK (Gast)]

Bei einer Baudrate von 19200 ist nicht der PIC das Problem, sondern 
Deine Programmierung und das Abspeichern der Daten in einem Puffer!

TK

[spontan (Gast)]

>ich benutze einen PIC18F2480, dieser scheint kein Hardware-Handshake zu
>haben...

Was heißt scheint? Datenblatt gelesen? Handshake geht auch aus der 
Software raus.

Aber wie TK schon schrieb, bei der Baudrate langweilt sich ein PIC18. 
Alle Probleme sind in der Sofwtare zu suchen.

Zeig die doch mal.

[Christoph H. (obbedair)]

spontan schrieb:
>>ich benutze einen PIC18F2480, dieser scheint kein Hardware-Handshake zu
>>haben...
>
> Was heißt scheint? Datenblatt gelesen? Handshake geht auch aus der
> Software raus.

Datenblatt hab ich gelesen und nichts zum Handshake gefunden.

zum Code, ich denke das alles direkt im Interrupt zu verarbeiten ist 
eine sehr unglückliche Variante... mir ist aber noch nichts besseres 
eingefallen

void interrupt ISR ()
    {
    INTCONbits.GIE = 0; 
        if (PIR1bits.RCIF == 1)         // USART
        {
            Data = RCREG;    // Auslesesn des USART-Puffers
            Data_A = Data & 0xF0;       // Adress_Teil für                 
            Data_D = Data & 0x0F;       // Daten_Teil
            if (Data_A == 0x10)
            {
                SIDH = Data;            // obere 4 Bit des Standart-ID-High
                SIDH = SIDH << 4;
            }
            else if (Data_A == 0x20)      
            {
                SIDH = Data_D | SIDH ; // untere 4 Bit des StandartID-HIGH
            }
            else if (Data == 0x30)
            {
                SIDL = Data_D;     // obere 4 Bit des Standart-ID-LOW
                SIDL = SIDL << 4;
            }
            else if (Data == 0x40 )
            {
                SIDL = Data_D | SIDL;
            }
            else
            {
                Fehler = 1;             // LED für Fehlererkennung 
            }
            PIR1bits.RCIF = 0;          // Puffer-full-bit wieder löschen!
        }

        if (PIR3bits.IRXIF == 1);       // CAN BUS ERROR
        {
            PIR3bits.IRXIF = 0;
            Fehler = !Fehler;
        }
 
        if (PIR3bits.ERRIF == 1)            // CAN Module Error
        {
            PIR3bits.ERRIF = 0;
        }


        if (PIR3bits.RXB0IF == 1)           // CANBUS
        {
            PIR3bits.RXB0IF = 0;
            Gelb = 1;
            Message_received = 1;
        }

        INTCONbits.GIE = 1;
}

[Christoph H. (obbedair)]

Also... der Code sieht jetzt wie folgt aus... das ganze funktioniert 
auch bis einschließlich Case 7. Case 8 wird dann nicht mehr 
bearbeitet... kann das daran liegen weil ich alles im Interrupt mache 
und eh er dann bis Case 8 durchgefragt hat ist schon wieder das nächste 
Byte da und er verschluckt sich?

void interrupt ISR ()
    {
    INTCONbits.GIE = 0; 
        if (PIR1bits.RCIF == 1)         // USART
        {
            Data = RCREG;    // Auslesesn des USART-Puffers
            Data_A = Data & 0xF0;       //Adressteil der Nachricht
            Data_D = Data & 0x0F;       //Datenteil der Nachricht
            Data_A = Data_A >> 4;
            
            switch (Data_A)
            {
                case 1:
                    SIDH = Data;         // obere 4 Bit des StandartID-High
                    SIDH = SIDH << 4;
                    
                    break;
                case 2:
                    SIDH = Data_D | SIDH;// untere 4Bit des StandartID-HIGH
                    
                    break;
                case 3:
                    SIDL = Data_D;     // obere 4 Bit des Standart-ID-LOW
                    SIDL = SIDL << 4;
                    break;
                case 4:
                    SIDL = Data_D | SIDL;
                    break;
                case 5:
                    Data0 = Data_D;
                    Data0 = Data0 << 4;
                    break;
                case 6:
                    Data0 = Data_D | Data0;
                    break;
                case 7:
                    Data1 = Data_D;
                    Data1 = Data1 << 4;
                    break;
                case 8:
                    Data1 = Data_D | Data1;
                    Gelb = 1;
                    break;
                case 9:
                    Data2 = Data_D;
                    Data2 = Data2 << 4;
                    
                    break;
                case 10:
                    Data2 = Data_D | Data2;
                    break;
                case 11:
                    Data3 = Data_D;
                    Data3 = Data3 << 4;
                    break;
                case 12:
                    Data3 = Data_D | Data3;
                    Senden = 1;
                    break;
            }
            PIR1bits.RCIF = 0;          // Puffer-full-bit wieder löschen!
        }

        if (PIR3bits.IRXIF == 1);       // CAN BUS ERROR
        {
            PIR3bits.IRXIF = 0;
            Fehler = !Fehler;
            
        }
 
    if (PIR3bits.ERRIF == 1)            // CAN Module Error
        {
        PIR3bits.ERRIF = 0;
        }


    if (PIR3bits.RXB0IF == 1)           // CANBUS
        {
        PIR3bits.RXB0IF = 0;
        Gelb = 1;
        Message_received = 1;
        }

    INTCONbits.GIE = 1;
    }

[Max H. (hartl192)]

Du könntest die Daten in der ISR nur im RAM speichern und dann in der 
main verarbeiten, wenn du Zeit hast.

[Christoph H. (obbedair)]

ich werd es mal versuchen, Problem ist das momentan noch kein 
CAN-Bus-"Verkerh" ist... das wird später immer mehr...
aber in wie weit das den pic wirklich auslastet weiß ich noch nicht. 
Vielleicht ist es vorerst mit einer Fehlererkennung getan.
quasi wenn beim verarbeiten in der main ein fehler auftritt dann melde 
mir das und ich werde das nochmal genauer unter die Lupe nehmen.