MCU (ds30F6012A) defekt?

[Patrick B. (p51d)]

Hallo miteinander

Heute hatte ich eine neue, wirklich interessante Eigenschaft des MCUs 
entdekt:

static unsigned int16 NUM = 0;                           // Anzahl zu übertragenden Werte
static unsigned int1 num_teil = 0;                       // 16Bit Anzahl zusammensetzen
static int8 index_rxBuf_R = 0;                           // Index of last write RX-Buffer 
static int8 index_rxBuf_W = 0;                           // Index of last read RX-Buffer
static unsigned int8 rxBuf[rxBuf_max + 1];               // RX-Buffer

void usart_rx(void){                                     // read function (polling)
   if(input_state(RX) == 0){                             // if new data in the FTDI buffer 
      if(index_rxBuf_W == rxBuf_max){                    // ringbuffer
         index_rxBuf_W = 0;
      }
      else{
         index_rxBuf_W ++;
      }

// take datas and set it dynamic in the buffer
      DDR_in;
      output_low(RD);                                    // read data
      rxBuf[index_rxBuf_W] = DATA_in;                    // store data
      output_high(RD);                                   // read finished
      DDR_out;
   }
}

switch (num_teil){                                 // 2 8Bit Werte zu 16 Bit Wert zusammensetzen
   case 0:
      NUM = (rxBuf[index_rxBuf_R] << 8);
      num_teil = 1;
      break;
   
   case 1:
      NUM |= rxBuf[index_rxBuf_R];
      RS232_state = waitPAR;
      num_teil = 0;
printf(txBuf_Write,"%d\n",rxBuf[index_rxBuf_R]);
printf(txBuf_Write,"%d\n",NUM);
      break;
}
break;

Die erste Ausgabe des Printfs ist 126, der Wert (007E) den ich sende.
NUM ist im case0 auch noch 0, beim "betreten" des case1 immer noch 0 und 
bei der Ausgabe dann 9086.
Selbst wenn ich ie Oder-Verknüpfung so mache:

NUM = ((NUM & 0xFF00) | rxBuf[index_rxBuf_R]);

Der Ausgegebene Wert für NUM ist immer 9086 anstelle 126.
Habe ich irgendwo einen Fehler oder kann der MCU keine Solche 
Operationen mehr richtig machen. Bis jetzt ist das der einzige 
Problempunkt, der Rest des Kommunikations-Switches macht er normal (bis 
zu der NUM-Stelle)

besten Dank für die Hilfe
Patrick

[holger (Gast)]

>static unsigned int1 num_teil = 0;                       // 16Bit Anzahl

Was ist ein int1 ?

>      NUM = (rxBuf[index_rxBuf_R] << 8);

      NUM = ((unsigned int16)rxBuf[index_rxBuf_R] << 8);

>      NUM |= rxBuf[index_rxBuf_R];

Versuchs so
      NUM += rxBuf[index_rxBuf_R];

Die Compiler von Mchip haben immer irgendwo Macken;)

[Patrick B. (p51d)]

holger schrieb:
>>static unsigned int1 num_teil = 0;                       // 16Bit Anzahl
>
> Was ist ein int1 ?
ist eine Bool-Variable mit nur einem Bit


>>      NUM = (rxBuf[index_rxBuf_R] << 8);
>
>       NUM = ((unsigned int16)rxBuf[index_rxBuf_R] << 8);
>
>>      NUM |= rxBuf[index_rxBuf_R];
>
> Versuchs so
>       NUM += rxBuf[index_rxBuf_R];
>
> Die Compiler von Mchip haben immer irgendwo Macken;)
Da ist nicht Microchip schuld, sonder CCS. Das sind 2 Verschiedene 
Firmen..

Was ist der Unterschied in diesem Fall zwischen |= und +=? Bis anhin hat 
diese Zeile auch funktioniert.

MFG
Patrick

[Michael H. (morph1)]

Will ich wohl meinen, der aktuelle dsPIC Compiler von microchip ist ein 
GCC ;) Wer da den CCS nutzt, dem kann man nicht helfen :D

Ne im ernst, ist das echt der ganze Quelltext?

[Patrick B. (p51d)]

Michael H. schrieb:
> Will ich wohl meinen, der aktuelle dsPIC Compiler von microchip ist ein
> GCC ;) Wer da den CCS nutzt, dem kann man nicht helfen :D

?? Microchip hat einen GCC für die dsPIC?
Wie sieht bei dem die Code-Optimierung aus? generiert er aus einem 
Switch MIT defualt-cases und beliebigen Case eine Jump-Tabelle?

> Ne im ernst, ist das echt der ganze Quelltext?

Nein, ich hatte nur gerade die betreffende Stelle gepostet, da wie du 
sehen kannst, nur die RS232 Funktion recht gross ist.
Ich arbeite mit einem FT245 zur USB-Wandlung. Daher alles Parallel und 
mit maximaler Geschwindigkeit. Habe nirgends irgendwo mühsame Delays, 
aber beim CCS wird momentan der Switch mit if-else if interpretiert, was 
sehr viel wertvolle Zeit kostet: 660us für 126 Bytes @ 120MHz von 
benötigten <=450us.
Hier sind mal die Kommunikations-Funktionen:

#define  DDR_in               set_tris_b(0xFFFF)
#define  DDR_out              set_tris_b(0xF000)
#define  DATA_in              input_b()
#define  DATA_out(value)      output_b(value)

// ASCII control commands
#define  SOH                  0x01
#define  ENQ                  0x05                          // Enq
#define  ACK                  0x06                          // ACK
#define  NACK                 0x15                          // NACK
#define  BEL                  0x07                          // "Warnglocke"
#define  EOT                  0x04
#define  temp                 0xAA                          // Überhizung

// RS232 steps
#define  waitENQ              0
#define  waitSOH              1
#define  waitCMD              2
#define  waitNUM              3
#define  waitPAR              4
   #define  waitRED              0
   #define  waitGREEN            1
   #define  waitBLUE             2
   #define  waitAX1              3
   #define  waitAX2              4
   #define  waitAX3              5
#define  waitACK              5
#define  waitEOT              6

// Programm-defines
#define  STREAM               0x11
#define  STOP                 0x22
#define  Stream_buf_max       1000                          // Maximale Buffer-Grösse

unsigned int8 command = STOP;
unsigned int16 x_achse_buf[Stream_buf_max];                                       // X-Achsen Werte
unsigned int16 y_achse_buf[Stream_buf_max];                                       // Y-Achsen Werte
unsigned int8 red_buf[Stream_buf_max];                                      // RGB Werte
unsigned int8 green_buf[Stream_buf_max];
unsigned int8 blue_buf[Stream_buf_max];

//*****************************************************************************
// Definitionen
#define TXE                PIN_F6                        // Transmitt-enabmle pin
#define WR                 PIN_F4                        // Write pin (high peak)
#define RX                 PIN_D11                       // Receive data Pin
#define RD                 PIN_F3                        // Read pin (during read low)
#define PWREN              PIN_F5                        // configurations-status

#define rxBuf_max          50                            // buffer size
static int8 index_rxBuf_R = 0;                           // Index of last write RX-Buffer 
static int8 index_rxBuf_W = 0;                           // Index of last read RX-Buffer
static unsigned int8 rxBuf[rxBuf_max + 1];               // RX-Buffer
#define txBuf_max          50                            // buffer size
static int8 index_txBuf_R = 0;                           // Index to write TX-Buffer 
static int8 index_txBuf_W = 0;                           // Index to read TX-Buffer
static unsigned int8 txBuf[txBuf_max + 1];               // TX-Buffer
//*****************************************************************************
// Functions
//=========== INIT ====================================
void ft245_init(void){
   int8 i = 0;
   unsigned int8 blink_cnt = 0;
   
   output_high(RD);                                      // set control-pins
   output_low(WR);
   
   for(i=0;i<=txBuf_max;i++){                            // clear buffers
      txBuf[i] = 0;
   }
   i = 0;
   for(i=0;i<=rxBuf_max;i++){
      rxBuf[i] = 0;
   }
   
   while(input_state(PWREN) == 1){                       // wait until the USB FTDI-configuration
      if(blink_cnt >= 250){                              // Blaue LED mit 4Hz blinken
         output_toggle(LED_blue);
         blink_cnt = 0;
      }
      blink_cnt ++;
      delay_ms(1);
   }
}
//=========== TX ====================================
// if no new data, return / need to calls in the main
void usart_tx(void){                                     // send-function
   if(input_state(TXE) == 0){                            // if sending possible
   
      if(index_txBuf_R == index_txBuf_W){                // no new data => return
         return;
      }
      if(index_txBuf_R == txBuf_max){                    // ringbuffer
         index_txBuf_R = 0;
      }
      else{
         index_txBuf_R ++;
      }
    
      DATA_out(txBuf[index_txBuf_R]);                    // write datas to the ftdi
      output_high(WR);                                   // new data available
      output_low(WR);
   }
}
void txBuf_write(int8 parameter){                        // TX buffer handling
   if(index_txBuf_W == txBuf_max){                       // ringbuffer
      index_txBuf_W = 0;
   }
   else{
      index_txBuf_W ++;
   }
   txBuf[index_txBuf_W] = parameter;
}
//=========== RX ====================================
// need to calls in the main
void usart_rx(void){                                     // read function (polling)
   if(input_state(RX) == 0){                             // if new data in the FTDI buffer 
      if(index_rxBuf_W == rxBuf_max){                    // ringbuffer
         index_rxBuf_W = 0;
      }
      else{
         index_rxBuf_W ++;
      }

// take datas and set it dynamic in the buffer
      DDR_in;
      output_low(RD);                                    // read data
      rxBuf[index_rxBuf_W] = DATA_in;                    // store data
      output_high(RD);                                   // read finished
      DDR_out;
   }
}

void RS232(void){
   static unsigned int8 RS232_state = 0;                    // Protokollstatus
   static unsigned int16 index_par = 0;                     // Array-Variable für Parameters
   static unsigned int16 NUM = 0;                           // Anzahl zu übertragenden Werte
   static unsigned int1 num_teil = 0;                       // 16Bit Anzahl zusammensetzen
   static unsigned int16 k = 0;                             // Speichervariable für Steuerung
   static unsigned int8 PAR_state = 0;
   static unsigned int8 temp_cmd = 0;
unsigned int16 a,i;   
   usart_tx();                                              // Wenn Daten im TX-Buffer, senden       
   usart_rx();                                              // Wenn Daten im FTDI-Buffer, entgegennehmen

   if(index_rxBuf_W == index_rxBuf_R){                      // Buffer Error abgleichen
      return;                                               // Wenn keine neuen Daten => aus Funktion heraus springen
   }
   if(index_rxBuf_R == rxBuf_max){                          // Erhöhen
      index_rxBuf_R = 0;
   }
   else{
      index_rxBuf_R ++;
   }
   
   switch (RS232_state){       
      case waitENQ:
         switch (rxBuf[index_rxBuf_R]){
            case '?':                                       // Suche der LCU
               printf(txBuf_Write,"USB LCU");
               output_high(LED_green);
               break;
               
            case ENQ:
               RS232_state = waitSOH;                       // In nächsten State wechselnd
               txBuf_Write(ACK);
               break;
               
            default:
               txBuf_Write(rxBuf[index_rxBuf_R]);           // Unbekanter Befehl zurückgeben
               break;
         }
         break;
         
      case waitSOH:                                         // Header der Übertragung
         switch (rxBuf[index_rxBuf_R]){
            case SOH:
               RS232_state = waitCMD;
               break;
         
            default:
               RS232_state = waitENQ;
               txBuf_Write(NACK);
               break;
         }
         break;
         
      case waitCMD:                                         // Kommando
         switch (rxBuf[index_rxBuf_R]){
            case STREAM:                                    // Werte streamen
               RS232_state = waitNUM;
               temp_cmd = rxBuf[index_rxBuf_R];
               break;
               
            case STOP:                                      // Projektor aus
               command = rxBuf[index_rxBuf_R];
               txBuf_Write(ACK);
               RS232_state = waitACK;
               break;
               
            case 0x01:                                      // Show 1
               command = rxBuf[index_rxBuf_R];
               txBuf_Write(ACK);
               RS232_state = waitACK;
               break;
case 0x02:
   for(i=0;i<1000;i++){
      printf(txBuf_Write,"%d\n",x_achse_buf[i]);
      printf(txBuf_Write,"%d\n",y_achse_buf[i]);
      printf(txBuf_Write,"%d\n",red_buf[i]);
      printf(txBuf_Write,"%d\n",green_buf[i]);
      printf(txBuf_Write,"%d\n\n",blue_buf[i]);
      for(a=0;a<10;a++) usart_tx();
   }
   txBuf_Write(ACK);
   RS232_state = waitACK;
   break;
            default:
               RS232_state = waitENQ;
               txBuf_Write(NACK);
               command = 0;
               break;
         }
         break;
         
      case waitNUM:                                         // Anzahl zu empfangender Werte in 16 Bit
         switch (num_teil){                                 // 2 8Bit Werte zu 16 Bit Wert zusammensetzen
            case 0:
               NUM = (rxBuf[index_rxBuf_R] << 8);
               num_teil = 1;
               break;
            
            case 1:
               NUM |= rxBuf[index_rxBuf_R];
               RS232_state = waitPAR;
               num_teil = 0;
         printf(txBuf_Write,"%d\n",rxBuf[index_rxBuf_R]);
         printf(txBuf_Write,"%d\n",NUM);
               break;
         }
         break;

      case waitPAR:
         index_par ++;
         switch(PAR_state){                                 // Werte in Ausgabe-Arrays speichern
            case waitRED:
               red_buf[k] = rxBuf[index_rxBuf_R];
               PAR_state = waitGREEN;
output_high(LED_red);
               break;
               
            case waitGREEN:
               green_buf[k] = rxBuf[index_rxBuf_R];
               PAR_state = waitBLUE;
               break;
               
            case waitBLUE:
               blue_buf[k] = rxBuf[index_rxBuf_R];
               PAR_state = waitAX1;
               break;
               
            case waitAX1:
               x_achse_buf[k] = (rxBuf[index_rxBuf_R] << 4);
               PAR_state = waitAX2;
               break;
               
            case waitAX2:
               x_achse_buf[k] |= (rxBuf[index_rxBuf_R] >> 4);               
               y_achse_buf[k] = ((rxBuf[index_rxBuf_R] & 0x0F) << 8);
               PAR_state = waitAX3;
               break;
               
            case waitAX3:   
               y_achse_buf[k] |= rxBuf[index_rxBuf_R];
               if(k == (Stream_buf_max - 1))                // Ringbuffer Steuerung
                  k = 0;
               else
                  k ++;
               PAR_state = waitRED;             
               if(index_par == NUM){
                  RS232_state = waitACK;
                  txBuf_Write(ACK);
                  index_par = 0;
output_low(LED_red);
               }
               break;
         }
         break; 
         
      case waitACK:
         if(rxBuf[index_rxBuf_R] == ACK){                   // ACK empfangen, 
            RS232_state = waitEOT;
         }
         break; 
         
      case waitEOT:                                         // Übertragung beendet
         if(rxBuf[index_rxBuf_R] == EOT){
            RS232_state = waitENQ;
            if(temp_cmd == STREAM){
//              command = temp_cmd;
               temp_cmd = 0;
            }
         }
         break;
         
      default:                                              // Default
         RS232_state = waitENQ;
         txBuf_Write(NACK);
         break;
   }
}

Variablen-mix ist mir nicht aufgefallen, daher meine Verwirrniss.

MFG
P51D

[holger (Gast)]

>> Was ist ein int1 ?
>ist eine Bool-Variable mit nur einem Bit

Danke, man lernt nie aus;)

>Was ist der Unterschied in diesem Fall zwischen |= und +=? Bis anhin hat
>diese Zeile auch funktioniert.

Ein ODER macht nicht unbedingt das gleiche wie ein Plus.
Ist aber wohl nicht das Problem.

>NUM beim "betreten" des case1 immer noch 0 und
>bei der Ausgabe dann 9086.
>Selbst wenn ich ie Oder-Verknüpfung so mache:

>NUM = ((NUM & 0xFF00) | rxBuf[index_rxBuf_R]);

Das ODER ist das Problem.
9086 = 0x237E

Das Lowbyte stimmt also. Aber wo kommt die 0x23 her?
Da macht der CCS wohl den Fehler. Er betrachtet rxBuf[index_rxBuf_R]
an der Stelle wohl nicht als int8.

Einfach mal casten:

     NUM |= (int8)rxBuf[index_rxBuf_R];

vieleicht gehts ja dann?

[holger (Gast)]

>Einfach mal casten:

>     NUM |= (int8)rxBuf[index_rxBuf_R];

So natürlich:(

     NUM |= (unsigned int8)rxBuf[index_rxBuf_R];

[Patrick B. (p51d)]

holger schrieb:
> Da macht der CCS wohl den Fehler. Er betrachtet rxBuf[index_rxBuf_R]
> an der Stelle wohl nicht als int8.

Compiler verursacht einen Fehler? Das solls ja geben, aber kann ich mir 
irgendwie nicht vorstellen.

Ich werde morgen die neue Version mit dem Cast testen, da ich leider den 
Print nicht zuhause habe.

Gegen den MCU-Defekt spricht vor allem, dass sonst keine Fehler 
aufgetreten sind, oder kann so etwas nur teilweise vorkommen?

MFG
Patrick

[holger (Gast)]

>Compiler verursacht einen Fehler? Das solls ja geben, aber kann ich mir
>irgendwie nicht vorstellen.

Buhahaha!

[Patrick B. (p51d)]

holger schrieb:
>>Compiler verursacht einen Fehler? Das solls ja geben, aber kann ich mir
>>irgendwie nicht vorstellen.
>
> Buhahaha!

?? wie darf ich dieses belustigende lachen jetzt interpretieren? Wenn 
man nicht gleich alles mit Windows gleich setzt muss es nicht heissen, 
dass etwas, wofür man zahlt auch gleich schlecht und voller Fehler ist.

Ich kenne diese Compiler (für PIC):
- Microchip... C18, C32
- CCS Versionen (PCWHD...)
- HI-Tech Versionen
und seit heute auch die GCC Versionen.

Wie wäre es mit eine fachlichen Meinung über die Performance, die 
Codierung, das Handling und den Support dieser Compilers?

MFG
P51D

[holger (Gast)]

>>>Compiler verursacht einen Fehler? Das solls ja geben, aber kann ich mir
>>>irgendwie nicht vorstellen.
>>
>> Buhahaha!

>?? wie darf ich dieses belustigende lachen jetzt interpretieren?

Fehler liegen eher in der Software als in der Hardware.
Ausnahmen gibt es natürlich auch.

- Microchip... C18

Frühe Versionen vom C18 hatten ähnliche Fehler wie deinen.
Und auch mit GCC hat man schon mal ne Menge Spaß. Das Netz
ist voll von Compiler Fehlern.

[Michael H. (morph1)]

Aja um das von vorher zu beantworten:

C32 und C30 sind die GCC-Derivate. Ist für mich persönlich der beste 
Compiler, wenn man sich mit den Eigenheiten mal vertraut gemacht hat :)

[Patrick B. (p51d)]

Michael H. schrieb:
> Aja um das von vorher zu beantworten:
>
> C32 und C30 sind die GCC-Derivate. Ist für mich persönlich der beste
> Compiler, wenn man sich mit den Eigenheiten mal vertraut gemacht hat :)

Ich habe bis jetzt nur Erfahrungen mit dem AVR GCC Compiler, aber der 
Umstieg sollte daher nicht sehr schwer fallen.

holger schrieb:
> So natürlich:(
>
>      NUM |= (unsigned int8)rxBuf[index_rxBuf_R];

Hat keine Besserung gebracht....

Ich werde einmal versuchen mit dem GCC Compiler zu arbeiten und sehen, 
wie sich die Performance verhält:
Ein Switch muss zwingend eine Jump-Tabelle haben, sonst verliere ich wie 
gesagt benötigte Zeit.

Melde mich wieder sobald die ich die neuesten Ergebnisse habe.

MFG
P51D

[Patrick B. (p51d)]

Michael H. schrieb:
> C32 und C30 sind die GCC-Derivate. Ist für mich persönlich der beste
> Compiler, wenn man sich mit den Eigenheiten mal vertraut gemacht hat :)

Tja das "vertraut" machen ist etwas mühsehlig:
Praktisch keine Beispiele (im vergleich zum CCS sehr viele), praktisch 
alles ander von den definitionen her....

Gibts da eine interessante Seite mit nützlichen und brauchbaren 
Code-Beispielen damit das Einarbeiten etwas humaner vorangeht?

MFG
Patrick

[Andreas F. (aferber)]

Patrick B. schrieb:
> Ein Switch muss zwingend eine Jump-Tabelle haben, sonst verliere ich wie
> gesagt benötigte Zeit.

Wenn du unbedingt ganz bestimmten Code haben willst/musst, benutzt du 
mit C die falsche Sprache, das geht prinzipiell nur in Assembler.

Das gesagt: der GCC benutzt für switch() beide Varianten, je nach 
Optimierungseinstellungen und konkretem Code (bei einem switch() mit 
einem int und nur zwei cases plus default wird er z.B. mit ziemlicher 
Sicherheit zwei Vergleiche statt einer Sprungtabelle generieren).

Allerdings gibt es eine GCC-Extension, mit der man ohne viel Aufwand 
explizit die Benutzung einer Sprungtabelle als Code hinschreiben kann. 
Konkret kann der GCC die Adressen von Sprungmarken in Variablen 
speichern, und diese können dann für goto verwendet werden. Das sieht 
dann so aus:

static void *jumptable[] = { &&case1, &&case2, &&case3 };

goto *jumptable[i];

case1:
    /* ... */
    goto end_switch;

case2:
    /* ... */
    goto end_switch;

case3:
    /* ... */
    goto end_switch;

end_switch:

Und ja, es müssen doppelte '&&' sein.

Doku dazu: 
http://gcc.gnu.org/onlinedocs/gcc-4.5.0/gcc/Labels-as-Values.html

Andreas

[holger (Gast)]

>holger schrieb:
>> So natürlich:(
>>
>>      NUM |= (unsigned int8)rxBuf[index_rxBuf_R];

>Hat keine Besserung gebracht....

Und was ist mit:

     NUM += rxBuf[index_rxBuf_R];

??

[Patrick B. (p51d)]

holger schrieb:
> Und was ist mit:
>
>      NUM += rxBuf[index_rxBuf_R];

Das funktioniert wiederum interessanterweise.

Ich werde mir aber trotzdem die Mühe nehmen und das Programm auf den GCC 
umschreiben, damit ich eine Sprungtabelle habe.

MFG
Patrick

[Patrick B. (p51d)]

Andreas Ferber schrieb:
> Patrick B. schrieb:
>> Ein Switch muss zwingend eine Jump-Tabelle haben, sonst verliere ich wie
>> gesagt benötigte Zeit.
>
> Wenn du unbedingt ganz bestimmten Code haben willst/musst, benutzt du
> mit C die falsche Sprache, das geht prinzipiell nur in Assembler.

Wie würde so ein switch mit einer Sprungtablle in Assembler aussehen??

Ich habe hierzu leider nicht viel gefunden.

MFG
Patrick