View unanswered posts | View active topics It is currently Fri Jul 25, 2014 10:49 am






Reply to topic  [ 3 posts ] 
Programming Error or Compiler Bug? 
Author Message
Rookie

Joined: Wed Dec 12, 2007 3:32 pm
Posts: 8
Post Programming Error or Compiler Bug?
Hi,

Here my code in a testfile:

Code:
//*!!Sensor,    S1,                Farbe, sensorLightActive,      ,              !!*//
//*!!Sensor,    S2,                Touch, sensorTouch,      ,                    !!*//
//*!!                                                                            !!*//
//*!!Start automatically generated configuration code.                           !!*//
const tSensors Farbe                = (tSensors) S1;   //sensorLightActive  //*!!!!*//
const tSensors Touch                = (tSensors) S2;   //sensorTouch        //*!!!!*//
//*!!CLICK to edit 'wizard' created sensor & motor configuration.                !!*//

// Weg_speichern.c

const tMotor   Motor_links          = (tMotor) motorA; //tmotorNxtEncoderClosedLoop
const tMotor   Motor_rechts         = (tMotor) motorB; //tmotorNxtEncoderClosedLoop

#define STouch    SensorValue(Touch)
#define SFarbe    SensorValue(Farbe)

#define speedsehrlangsam   5
#define speedlangsam          15
#define speednormal          25
#define speedschnell         35

#define MotorStop            motor[Motor_links] = motor[Motor_rechts] = 0; wait1Msec(5)

// zusammenhaengende Werte herstellen, keine undefinierten Farben zulassen
#define Boden_Schwarz    SensorValue(Farbe) >=  0 && SensorValue(Farbe) <= 31
#define Boden_Bordeaux   SensorValue(Farbe) >= 32 && SensorValue(Farbe) <= 36
#define Boden_Grau          SensorValue(Farbe) >= 37 && SensorValue(Farbe) <= 51
#define Boden_Weiss       SensorValue(Farbe) >= 52 && SensorValue(Farbe) <= 99

// Die Richtungen beziehen sich aus der Sicht des 1. Kontaktes mit der Kreuzung
#define Norden   0
#define Sueden   1
#define Osten      2
#define Westen   3
// Globale Variablen ///////////////////////

//////////// Hilfsvariablen   ////////////////////////////
int itemp = 0, itemp1 = 0;                                          // Nicht in Mainprogramm uebernehemn

//Sonar
int iAbstand_empfangen_links = 255;
int iAbstand_empfangen_geradeaus = 255;
int iAbstand_empfangen_rechts = 255;
////////////////////////////////////////////////////////


const int iAnzahlKreuzungen = 5;
int iAktuelleKreuzung = -1;   // bei 1. Kreuzung auf 0 gesetzt

int iAktuellerWeg = Sueden;   // von Kreuzung aus gesehen

int iGespeicherterWeg[iAnzahlKreuzungen];   // Hier steht der richtige Weg

bool bWegbereitsbesucht[iAnzahlKreuzungen][4];   // Hier steht welcher Weg der Kreuzung schon befahren wurde

bool bGewendet = false;

//////////////////////////////////////////////


int f_iKonvertiereRichtung(int iWohin)
{
   switch(iAktuellerWeg)
   {
         case Norden:
               switch(iWohin)
               {
                  case 0      : return Sueden;
                  case 90      : return Osten;
                  case -90   : return Westen;
                  default      : return Norden;
               }
               break;

         case Sueden:
               switch(iWohin)
               {
                  case 0      : return Norden;
                  case 90      : return Westen;
                  case -90   : return Osten;
                  default      : return Sueden;
               }
               break;

         case Osten:
               switch(iWohin)
               {
                  case 0      : return Westen;
                  case 90      : return Sueden;
                  case -90   : return Norden;
                  default      : return Osten;
               }
               break;

         case Westen:
               switch(iWohin)
               {
                  case 0      : return Osten;
                  case 90      : return Norden;
                  case -90   : return Sueden;
                  default      : return Westen;
               }
               break;

         default: return -1;
   }
}


int f_iWegEvent(bool bWende = false, bool bLabyrinth = false)
{
   int iZufallszahl, ihelp_f_iWegEvent;

   // Hindernis vor Sonar
   if(bWende)
   {
               iZufallszahl = 180;   // drehe 180 Grad
               bGewendet = true;
   }

   // Kreuzung
   else
   {
               if( !bGewendet )   // Neue Kreuzung
               {
                        iAktuelleKreuzung++;
                        iAktuelleKreuzung%= 5;   // Temporaer als Buffer nachher im Hauptprogramm loeschen

                        iAktuellerWeg = Sueden;
                        bWegbereitsbesucht[iAktuelleKreuzung][Sueden] = true;   // Herkunftsweg bereits gefahren
               }

               bGewendet = false;

               // alle Wege der aktuellen Kreuzung bereits besucht -> zurueck
               if( bWegbereitsbesucht[iAktuelleKreuzung][0] && bWegbereitsbesucht[iAktuelleKreuzung][1] && bWegbereitsbesucht[iAktuelleKreuzung][2] && bWegbereitsbesucht[iAktuelleKreuzung][3] )
               {
                        switch( iAktuellerWeg )
                        {
                           case Norden   :   iZufallszahl = 0;    break;
                           case Osten   :   iZufallszahl = 90;    break;
                           case Westen   :   iZufallszahl = -90; break;
                           default         :   iZufallszahl = 180; break;
                        }

                        iAktuellerWeg = Sueden;

                        for( int i=0; i<4; i++)   // Kreuzung wieder zuruecksetzen
                        {
                           bWegbereitsbesucht[iAktuelleKreuzung][i] = false;
                        }

                        iAktuelleKreuzung--;      // Kreuzung zurueck, letzte ungueltig

                        iAktuellerWeg = iGespeicherterWeg[iAktuelleKreuzung];      // AktuellerWeg wieder aus Sicht der alten Kreuzung

                        bGewendet = true;            // sonst wird bei naechster Kreuzung sofort wieder iAktuelleKreuzung++
               }

               // noch nicht alle Wege der aktuellen Kreuzung besucht
               else
               {
                        if( bLabyrinth )   // Scanne nach Waenden und setze falls vorhanden bWegbereistbesucht auf true
                        {
                           if( iAbstand_empfangen_geradeaus < 30 )
                              bWegbereitsbesucht[iAktuelleKreuzung][Norden] = true;
                           if( iAbstand_empfangen_links   < 30 )
                              bWegbereitsbesucht[iAktuelleKreuzung][Westen] = true;
                           if( iAbstand_empfangen_rechts < 30 )
                              bWegbereitsbesucht[iAktuelleKreuzung][Osten] = true;
                        }
                        // in welche Richtung drehen?
                        while(true)
                        {
                                 iZufallszahl = random(2);

                                 switch(iZufallszahl)
                                 {
                                       case 0: iZufallszahl = 0;   // drehe 0 Grad
                                                   break;

                                       case 1: iZufallszahl = 90;   // drehe 90 Grad
                                                   break;

                                       case 2: iZufallszahl = -90;   // drehe -90 Grad
                                                   break;

                                       default:   iZufallszahl = -1;
                                                   break;
                                 }

                                 ihelp_f_iWegEvent = f_iKonvertiereRichtung(iZufallszahl);

                                 if( !bWegbereitsbesucht[iAktuelleKreuzung][ihelp_f_iWegEvent] )            // Noch nicht da?
                                 {
                                       bWegbereitsbesucht[iAktuelleKreuzung][ihelp_f_iWegEvent] = true;   // Ok, Weg jetzt besuchen
                                       iAktuellerWeg = ihelp_f_iWegEvent;
                                       iGespeicherterWeg[iAktuelleKreuzung] = ihelp_f_iWegEvent;
                                       break;                                                                                          // und Schleife jetzt Verlassen
                                 }
                        }
               }
   }

   switch(iZufallszahl)
   {
      case 90      :   nxtDisplayTextLine(2, "Links      ");   break;
      case -90   :   nxtDisplayTextLine(2, "Rechts     ");   break;
      case 0      :   nxtDisplayTextLine(2, "Geradeaus  ");   break;
      case 180   :   nxtDisplayTextLine(2, "Gewendet   ");   break;
      default      :   nxtDisplayTextLine(2, "Undefiniert");   break;
   }

   return iZufallszahl;
}

task ButtonTask()
{
  nSchedulePriority    = kHighPriority;

  switch (nNxtButtonPressed)
  {
     case kLeftButton:                                                      break;
      case kRightButton:                                                   break;
      case kEnterButton:   itemp1 = 1;                                 break;
      case kExitButton:     itemp1 = 2;                                 break;
   }

   return;
}

task main()
{
      nNxtButtonTask  = ButtonTask;

      nNxtExitClicks  = 3; // Triple clicking EXIT button will terminate program

      eraseDisplay();

      for( int i = 0; i< iAnzahlKreuzungen; i++)
      {
         iGespeicherterWeg[i]= -1;
         for( int j = 0; j< 4; j++)
         {
            bWegbereitsbesucht[i][j] = false;
         }
      }
      STouch = 0;
      while(true)
      {
         if(STouch)
            break;

         if (itemp1 == 1 )
         {
            itemp = f_iWegEvent();
            itemp1 = 0;
         }
         if (itemp1 == 2 )
         {
            itemp = f_iWegEvent(true);
            itemp1 = 0;
         }

         nxtDisplayTextLine(3, "Drehe: %d", itemp);
         nxtDisplayTextLine(4, "Kreuzung: %d",iAktuelleKreuzung);
      }
}


After I found a bug in my mainprogramm, I looked again at my testprogramm and I found there the same bug.

In Line 126 in f_iWegEvent(bool bWende = false, bool bLabyrinth = false)
bGewendet is never set to false and I don't find the problem. Am I blind and can't find the simple sollution or is there a compiler bug or something else?

It seems that in the testprogramm in line 111 bGewendet is also never set to true although in the main programm it is set as it should.

Here is also the disassembly view:
Code:
//*!!Sensor,    S1,                Farbe, sensorLightActive,      ,              !!*//
//*!!Sensor,    S2,                Touch, sensorTouch,      ,                    !!*//
//*!!                                                                            !!*//
//*!!Start automatically generated configuration code.                           !!*//
const tSensors Farbe                = (tSensors) S1;   //sensorLightActive  //*!!!!*//
const tSensors Touch                = (tSensors) S2;   //sensorTouch        //*!!!!*//
//*!!CLICK to edit 'wizard' created sensor & motor configuration.                !!*//

// Weg_speichern.c

const tMotor   Motor_links          = (tMotor) motorA; //tmotorNxtEncoderClosedLoop
const tMotor   Motor_rechts         = (tMotor) motorB; //tmotorNxtEncoderClosedLoop

#define STouch    SensorValue(Touch)
#define SFarbe    SensorValue(Farbe)

#define speedsehrlangsam   5
#define speedlangsam          15
#define speednormal          25
#define speedschnell         35

#define MotorStop            motor[Motor_links] = motor[Motor_rechts] = 0; wait1Msec(5)

// zusammenhaengende Werte herstellen, keine undefinierten Farben zulassen
#define Boden_Schwarz    SensorValue(Farbe) >=  0 && SensorValue(Farbe) <= 31
#define Boden_Bordeaux   SensorValue(Farbe) >= 32 && SensorValue(Farbe) <= 36
#define Boden_Grau          SensorValue(Farbe) >= 37 && SensorValue(Farbe) <= 51
#define Boden_Weiss       SensorValue(Farbe) >= 52 && SensorValue(Farbe) <= 99

// Die Richtungen beziehen sich aus der Sicht des 1. Kontaktes mit der Kreuzung
#define Norden   0
#define Sueden   1
#define Osten      2
#define Westen   3
// Globale Variablen ///////////////////////

//////////// Hilfsvariablen   ////////////////////////////
int itemp = 0, itemp1 = 0;                                          // Nicht in Mainprogramm uebernehemn

//Sonar
int iAbstand_empfangen_links = 255;
int iAbstand_empfangen_geradeaus = 255;
int iAbstand_empfangen_rechts = 255;
////////////////////////////////////////////////////////


const int iAnzahlKreuzungen = 5;
int iAktuelleKreuzung = -1;   // bei 1. Kreuzung auf 0 gesetzt

int iAktuellerWeg = Sueden;   // von Kreuzung aus gesehen

int iGespeicherterWeg[iAnzahlKreuzungen];   // Hier steht der richtige Weg

bool bWegbereitsbesucht[iAnzahlKreuzungen][4];   // Hier steht welcher Weg der Kreuzung schon befahren wurde

bool bGewendet = false;

//////////////////////////////////////////////


int f_iKonvertiereRichtung(int iWohin)
//
//Code segment: f_iKonvertiereRichtung(short iWohin); Procedure: 0
//
{
   switch(iAktuellerWeg)
0000: XX042B09000000051423     switch(iAktuellerWeg)             
    : 3255                                                       
   {
         case Norden:
               switch(iWohin)
000C: XX032B1A00005AA60042 L000C: switch(iWohin)                     
    : 003600430037                                               
               {
                  case 0      : return Sueden;
                  case 90      : return Osten;
                  case -90   : return Westen;
                  default      : return Norden;
               }
               break;

         case Sueden:
               switch(iWohin)
001C: XX032B1A00005AA6002D L001C: switch(iWohin)                     
    : 00350024002C                                               
               {
                  case 0      : return Norden;
                  case 90      : return Westen;
                  case -90   : return Osten;
                  default      : return Sueden;
               }
               break;

         case Osten:
               switch(iWohin)
002C: XX032B1A00005AA60027 L002C: switch(iWohin)                     
    : 002000190012                                               
               {
                  case 0      : return Westen;
                  case 90      : return Sueden;
                  case -90   : return Norden;
                  default      : return Osten;
               }
               break;

         case Westen:
               switch(iWohin)
003C: XX032B1A00005AA60008 L003C: switch(iWohin)                     
    : 000B000E0011                                               
               {
                  case 0      : return Osten;
004C: XX330002          L004C: fcnReturn = 2                     
0050: XX                       Return()                            // Replace 'bra'
                  case 90      : return Norden;
0051: XX330000          L0051: fcnReturn = 0                     
0055: XX                       Return()                            // Replace 'bra'
                  case -90   : return Sueden;
0056: XX330001          L0056: fcnReturn = 1                     
005A: XX                       Return()                            // Replace 'bra'
                  default      : return Westen;
005B: XX330003          L005B: fcnReturn = 3                     
005F: XX                       Return()                            // Replace 'bra'
               }
               break;

         default: return -1;
0060: XX330002FFFF      L0060: fcnReturn = -1                     
   }
}
0066: XX                       Return()                            // f_iKonvertiereRichtung(short iWohin)


int f_iWegEvent(bool bWende = false, bool bLabyrinth = false)
//
//Code segment: f_iWegEvent(bool bWende, bool bLabyrinth); Procedure: 1
//
{
   int iZufallszahl, ihelp_f_iWegEvent;

   // Hindernis vor Sonar
   if(bWende)
0000: XXC200002D36000800       TestAndBranchByteVarFar(0 == bWende, L000F)
   {
               iZufallszahl = 180;   // drehe 180 Grad
0009: XX1CB4                   iZufallszahl = 180                 
               bGewendet = true;
000C: XX5002                   BranchFar(L015D)                    // If end
   }

   // Kreuzung
   else
   {
               if( !bGewendet )   // Neue Kreuzung
000F: XX8200002D32001E00  L000F: TestAndBranchByteVarFar(0 != bGewendet, L0034)
               {
                        iAktuelleKreuzung++;
0018: XX080001                 iAktuelleKreuzung += 1             
                        iAktuelleKreuzung%= 5;   // Temporaer als Buffer nachher im Hauptprogramm loeschen
001C: XX080005                 iAktuelleKreuzung %= 5             

                        iAktuellerWeg = Sueden;
0020: XX0901                   iAktuellerWeg = 1                 
                        bWegbereitsbesucht[iAktuelleKreuzung][Sueden] = true;   // Herkunftsweg bereits gefahren
0023: XX2B1E002B0800020400     G30(short) = iAktuelleKreuzung * 4
002D: XX2E1E1F020100           GB31[G30] = 1                     
               }

               bGewendet = false;

               // alle Wege der aktuellen Kreuzung bereits besucht -> zurueck
               if( bWegbereitsbesucht[iAktuelleKreuzung][0] && bWegbereitsbesucht[iAktuelleKreuzung][1] && bWegbereitsbesucht[iAktuelleKreuzung][2] && bWegbereitsbesucht[iAktuelleKreuzung][3] )
0034: XX2B1E002B0800020400 L0034: G30(short) = iAktuelleKreuzung * 4
003E: XXC200002E1E1E6700       TestAndBranchByteVarFar(0 == GB30[G30], L00AC)
0047: XXC200002E1E1F5E00       TestAndBranchByteVarFar(0 == GB31[G30], L00AC)
0050: XXC200002E1E205500       TestAndBranchByteVarFar(0 == GB32[G30], L00AC)
0059: XXC200002E1E214C00       TestAndBranchByteVarFar(0 == GB33[G30], L00AC)
               {
                        switch( iAktuellerWeg )
0062: XX042B09000000051408     switch(iAktuellerWeg)             
    : 0C11                                                       
                        {
                           case Norden   :   iZufallszahl = 0;    break;
006E: XX1C00            L006E: iZufallszahl = 0                   
0071: XX0F                     BranchNear(L0081)                   // Goto break location (43)
                           case Osten   :   iZufallszahl = 90;    break;
0073: XX1C5A            L0073: iZufallszahl = 90                 
0076: XX0A                     BranchNear(L0081)                   // Goto break location (44)
                           case Westen   :   iZufallszahl = -90; break;
0078: XX1CFFA6          L0078: iZufallszahl = -90                 
007C: XX04                     BranchNear(L0081)                   // Goto break location (45)
                           default         :   iZufallszahl = 180; break;
007E: XX1CB4            L007E: iZufallszahl = 180                 
                        }

                        iAktuellerWeg = Sueden;
0081: XX0901            L0081: iAktuellerWeg = 1                 

                        for( int i=0; i<4; i++)   // Kreuzung wieder zuruecksetzen
0084: XX1E00                   i = 0                             
0087: XX1A                     BranchNear(L00A2)                   // Jump to test condition
                        {
                           bWegbereitsbesucht[iAktuelleKreuzung][i] = false;
0089: XX2B1F002B0800020400 L0089: G31(short) = iAktuelleKreuzung * 4
0093: XX1F2B1E                 G31(short) += i                   
0097: XX2E1F1E020000           GB30[G31] = 0                     
009E: XX1E0001                 i += 1                             
00A2: XX42032B1EE2FF    L00A2: TestAndBranchIntFar(3 >= i, L0089)
                        }

                        iAktuelleKreuzung--;      // Kreuzung zurueck, letzte ungueltig

                        iAktuellerWeg = iGespeicherterWeg[iAktuelleKreuzung];      // AktuellerWeg wieder aus Sicht der alten Kreuzung

                        bGewendet = true;            // sonst wird bei naechster Kreuzung sofort wieder iAktuelleKreuzung++
00A9: XX3301                   BranchFar(L015D)                    // If end
               }

               // noch nicht alle Wege der aktuellen Kreuzung besucht
               else
               {
                        if( bLabyrinth )   // Scanne nach Waenden und setze falls vorhanden bWegbereistbesucht auf true
00AC: XXC200002D37004A00  L00AC: TestAndBranchByteVarFar(0 == bLabyrinth, L00FD)
                        {
                           if( iAbstand_empfangen_geradeaus < 30 )
00B5: XX021E2B061300           TestAndBranchIntFar(30 <= iAbstand_empfangen_geradeaus, L00CD)
                              bWegbereitsbesucht[iAktuelleKreuzung][Norden] = true;
00BC: XX2B1E002B0800020400     G30(short) = iAktuelleKreuzung * 4
00C6: XX2E1E1E020100           GB30[G30] = 1                     
                           if( iAbstand_empfangen_links   < 30 )
00CD: XX021E2B051300    L00CD: TestAndBranchIntFar(30 <= iAbstand_empfangen_links, L00E5)
                              bWegbereitsbesucht[iAktuelleKreuzung][Westen] = true;
00D4: XX2B1E002B0800020400     G30(short) = iAktuelleKreuzung * 4
00DE: XX2E1E21020100           GB33[G30] = 1                     
                           if( iAbstand_empfangen_rechts < 30 )
00E5: XX021E2B071300    L00E5: TestAndBranchIntFar(30 <= iAbstand_empfangen_rechts, L00FD)
                              bWegbereitsbesucht[iAktuelleKreuzung][Osten] = true;
00EC: XX2B1E002B0800020400     G30(short) = iAktuelleKreuzung * 4
00F6: XX2E1E20020100           GB32[G30] = 1                     
                        }
                        // in welche Richtung drehen?
                        while(true)
                        {
                                 iZufallszahl = random(2);
00FD: XX1C0402          L00FD: iZufallszahl = Random(2)           

                                 switch(iZufallszahl)
0101: XX032B1C00000004080C     switch(iZufallszahl)               
    : 11                                                         
                                 {
                                       case 0: iZufallszahl = 0;   // drehe 0 Grad
010C: XX1C00            L010C: iZufallszahl = 0                   
                                                   break;
010F: XX10                     BranchNear(L0120)                   // Goto break location (47)

                                       case 1: iZufallszahl = 90;   // drehe 90 Grad
0111: XX1C5A            L0111: iZufallszahl = 90                 
                                                   break;
0114: XX0B                     BranchNear(L0120)                   // Goto break location (48)

                                       case 2: iZufallszahl = -90;   // drehe -90 Grad
0116: XX1CFFA6          L0116: iZufallszahl = -90                 
                                                   break;
011A: XX05                     BranchNear(L0120)                   // Goto break location (49)

                                       default:   iZufallszahl = -1;
011C: XX1CFFFF          L011C: iZufallszahl = -1                 
                                                   break;
                                 }

                                 ihelp_f_iWegEvent = f_iKonvertiereRichtung(iZufallszahl);
0120: XX1A2B1C          L0120: f_iKonvertiereRichtung::iWohin = iZufallszahl
0124: XX00                     callSub(f_iKonvertiereRichtung)   
0126: XX1D3300                 ihelp_f_iWegEvent = fcnReturn     

                                 if( !bWegbereitsbesucht[iAktuelleKreuzung][ihelp_f_iWegEvent] )            // Noch nicht da?
012A: XX2B1E002B0800020400     G30(short) = iAktuelleKreuzung * 4
0134: XX1E2B1D                 G30(short) += ihelp_f_iWegEvent   
0138: XX8200002E1E1EBEFF       TestAndBranchByteVarFar(0 != GB30[G30], L00FD)
                                 {
                                       bWegbereitsbesucht[iAktuelleKreuzung][ihelp_f_iWegEvent] = true;   // Ok, Weg jetzt besuchen
0141: XX2B1E002B0800020400     G30(short) = iAktuelleKreuzung * 4
014B: XX1E2B1D                 G30(short) += ihelp_f_iWegEvent   
014F: XX2E1E1E020100           GB30[G30] = 1                     
                                       iAktuellerWeg = ihelp_f_iWegEvent;
                                       iGespeicherterWeg[iAktuelleKreuzung] = ihelp_f_iWegEvent;
0156: XX2F080A2B1D00           G10[G08] = ihelp_f_iWegEvent       
                                       break;                                                                                          // und Schleife jetzt Verlassen
                                 }
                        }
               }
   }

   switch(iZufallszahl)
015D: XX042B1C00005AFFA600 L015D: switch(iZufallszahl)               
    : 0000B4000A0017002400                                       
    : 31003E                                                     
   {
      case 90      :   nxtDisplayTextLine(2, "Links      ");   break;
0174: XX11023200003200000F L0174: nxtDisplayTextLine(2, "Links      ", , )
    : 321400                                                     
0181: XX3B                     BranchNear(L01BD)                   // Goto break location (52)
      case -90   :   nxtDisplayTextLine(2, "Rechts     ");   break;
0183: XX11023200003200000F L0183: nxtDisplayTextLine(2, "Rechts     ", , )
    : 322800                                                     
0190: XX2C                     BranchNear(L01BD)                   // Goto break location (53)
      case 0      :   nxtDisplayTextLine(2, "Geradeaus  ");   break;
0192: XX11023200003200000F L0192: nxtDisplayTextLine(2, "Geradeaus  ", , )
    : 323C00                                                     
019F: XX1D                     BranchNear(L01BD)                   // Goto break location (54)
      case 180   :   nxtDisplayTextLine(2, "Gewendet   ");   break;
01A1: XX11023200003200000F L01A1: nxtDisplayTextLine(2, "Gewendet   ", , )
    : 325000                                                     
01AE: XX0E                     BranchNear(L01BD)                   // Goto break location (55)
      default      :   nxtDisplayTextLine(2, "Undefiniert");   break;
01B0: XX11023200003200000F L01B0: nxtDisplayTextLine(2, "Undefiniert", , )
    : 326400                                                     
   }

   return iZufallszahl;
01BD: XX33002B1C        L01BD: fcnReturn = iZufallszahl           
}
01C2: XX                       Return()                            // f_iWegEvent(bool bWende, bool bLabyrinth)

task ButtonTask()
//
//Code segment: ButtonTask(); Task: 1
//
{
  nSchedulePriority    = kHighPriority;
0000: XX181DFF                 nSchedulePriority = 255           

  switch (nNxtButtonPressed)
0004: XX04184A0000000B0503     switch(nNxtButtonPressed)         
    : 040A                                                       
  {
     case kLeftButton:                                                      break;
0010: XX                L0010: Return()                            // Replace 'bra'
      case kRightButton:                                                   break;
0011: XX                L0011: Return()                            // Replace 'bra'
      case kEnterButton:   itemp1 = 1;                                 break;
0012: XX0401            L0012: itemp1 = 1                         
0015: XX                       Return()                            // Replace 'bra'
      case kExitButton:     itemp1 = 2;                                 break;
0016: XX0402            L0016: itemp1 = 2                         
   }

   return;
0019: XX                L0019: Return()                            // ButtonTask()
}

task main()
//
//
// Constants Pool:
//
//0000: 00000000 F8241E78 00000000 11000000 00000000               string  ""
//0014: 4C696E6B 73202020 20202000 00000000 0D000500               string  "Links      "
//0028: 52656368 74732020 20202000 04000000 03000500               string  "Rechts     "
//003C: 47657261 64656175 73202000 04000000 03000500               string  "Geradeaus  "
//0050: 47657765 6E646574 20202000 04000000 03000500               string  "Gewendet   "
//0064: 556E6465 66696E69 65727400 68024C00 02000500               string  "Undefiniert"
//0078: 44726568 653A2025 64000400 BC006B03 0C000500               string  "Drehe: %d"
//008C: 4B726575 7A756E67 3A202564 004C696E 02000500               string  "Kreuzung: %d"
//00A0:
//
//Code segment: main(); Task: 0
//
0000: XX180E00                 bFloatDuringInactiveMotorPWM = 0   
0004: XX0005                   SetSensorType(0, 5)               
0007: XX0101                   SetSensorType(1, 1)               
000A: XX0300                   itemp = 0                         
000D: XX0400                   itemp1 = 0                         
0010: XX05FF                   iAbstand_empfangen_links = 255     
0013: XX06FF                   iAbstand_empfangen_geradeaus = 255
0016: XX07FF                   iAbstand_empfangen_rechts = 255   
0019: XX08FFFF                 iAktuelleKreuzung = -1             
001D: XX0901                   iAktuellerWeg = 1                 
0020: XX2D3200                 bGewendet = 0                     
{
      nNxtButtonTask  = ButtonTask;
0024: XX184801                 nNxtButtonTask = ButtonTask       

      nNxtExitClicks  = 3; // Triple clicking EXIT button will terminate program
0028: XX184903                 nNXTExitClicks = 3                 

      eraseDisplay();
002C: XX00                     eraseDisplay()                     

      for( int i = 0; i< iAnzahlKreuzungen; i++)
002E: XX2100                   i = 0                             
0031: XX31                     BranchNear(L0063)                   // Jump to test condition
      {
         iGespeicherterWeg[i]= -1;
0033: XX2F210A02FFFF    L0033: G10[G33] = -1                     
         for( int j = 0; j< 4; j++)
003A: XX2200                   j = 0                             
003D: XX1A                     BranchNear(L0058)                   // Jump to test condition
         {
            bWegbereitsbesucht[i][j] = false;
003F: XX2B23002B2100020400 L003F: G35(short) = i * 4                 
0049: XX232B22                 G35(short) += j                   
004D: XX2E231E020000           GB30[G35] = 0                     
0054: XX220001                 j += 1                             
0058: XX42032B22E2FF    L0058: TestAndBranchIntFar(3 >= j, L003F)
005F: XX210001                 i += 1                             
0063: XX42042B21CBFF    L0063: TestAndBranchIntFar(4 >= i, L0033)
         }
      }
      STouch = 0;
006A: XX01                     clearSensorValue(1, )             
      while(true)
      {
         if(STouch)
006C: XX820009014E00    L006C: TestAndBranchIntFar(0 != Sensor[01], L00BF)
            break;

         if (itemp1 == 1 )
0073: XX82012B041300           TestAndBranchIntFar(1 != itemp1, L008B)
         {
            itemp = f_iWegEvent();
007A: XX2D3600                 f_iWegEvent::bWende = 0           
007E: XX2D3700                 f_iWegEvent::bLabyrinth = 0       
0082: XX01                     callSub(f_iWegEvent)               
0084: XX033300                 itemp = fcnReturn                 
            itemp1 = 0;
0088: XX0400                   itemp1 = 0                         
         }
         if (itemp1 == 2 )
008B: XX82022B041300    L008B: TestAndBranchIntFar(2 != itemp1, L00A3)
         {
            itemp = f_iWegEvent(true);
0092: XX2D3601                 f_iWegEvent::bWende = 1           
0096: XX2D3700                 f_iWegEvent::bLabyrinth = 0       
009A: XX01                     callSub(f_iWegEvent)               
009C: XX033300                 itemp = fcnReturn                 
            itemp1 = 0;
00A0: XX0400                   itemp1 = 0                         
         }

         nxtDisplayTextLine(3, "Drehe: %d", itemp);
00A3: XX11032B030032000003 L00A3: nxtDisplayTextLine(3, "Drehe: %d", itemp, )
    : 327800                                                     
         nxtDisplayTextLine(4, "Kreuzung: %d",iAktuelleKreuzung);
00B0: XX11042B080032000003     nxtDisplayTextLine(4, "Kreuzung: %d", iAktuelleKreuzung, )
    : 328C00                                                     
00BD: XXD2                     BranchNear(L006C)                   // Jump to end Expression
      }
}
00BF: XX                L00BF: Return()                            // main()
0000: XX                       Return()                            // main()


Thank you for help


Wed Apr 02, 2008 6:29 am
Profile
Rookie

Joined: Wed Dec 12, 2007 3:32 pm
Posts: 8
Post 
I got it:

I changed under View -> Quick Setup Preferences "Release" into "Debug"

Now, in the disassembly view there is an assembler code under bGewendet who sets bGewendet 1 or 0. I think that's better :)

I testet it in my mainprogram and everything works correct now.


Wed Apr 02, 2008 7:27 am
Profile
Creator
Creator

Joined: Fri Feb 09, 2007 9:21 am
Posts: 614
Post 
CHW wrote:
I got it:

I changed under View -> Quick Setup Preferences "Release" into "Debug"

Now, in the disassembly view there is an assembler code under bGewendet who sets bGewendet 1 or 0. I think that's better :)

I testet it in my mainprogram and everything works correct now.

Yes. You're right. This is the "quick fix" / "workaround".

The compiler code optimizer (the main difference between Debug and Release is that no code optimizaiton in done in Debug) appears to be "too efficient" and looks like it incorrectly removed valid code.

The problem / bug is that the code optimizer was not working well when there is two constant assignments to a variable with an intervening "switch" statement between them. One of both of these statements may sometimes (there's a few other conditionas as well) be incorrectly optimized "away". This appears to be an undetected day one bug.

Code:
nValue = 0;      // This gets optimized out
switch (...)
{
case xx:
 ...
}
nValue = 1;

The fix will be available in the next pre-release version. (1.24).


Wed Apr 02, 2008 3:19 pm
Profile
Display posts from previous:  Sort by  
Reply to topic   [ 3 posts ] 

Who is online

Users browsing this forum: No registered users and 2 guests


You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot post attachments in this forum

Search for:
Jump to:  



Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group.
Designed by ST Software for PTF.