wiefviel programm verträgt der asuro?

[harry3]

ich schaus mir dann heute etwas später an und meld mich dann.

[harry3]

Habs gerade kompiliert mit dem AVR GCC im AVR Studio, die Größe wird dabei mit 3,3k angegeben, das sind sowas um die 55 Pages zum Flashen.
Ich sehe da also kein Problem mit der Größe.

Ich hab gesehen dass du jetzt so ziemlich alles auf char geändert hast, das ist aber auch nicht gut. Ändere nur dort auf char, wo du weißt, dass niemals ein größerer Wertebereich als -128 bis+127 gebraucht wird, bzw. 0 bis 255.
Du hast z.B. in einer for Schleife eine char Variable gegen den Wert 200 geprüft: b<DURCHLAUF. Das ist eine sinnlose Schleife da b niemals den Wert 200 erreichen kann, siehe Wertebereiche.
Schau dir also nochmal genau an wo du wirklich char verwenden darfst, und wo du dann doch lieber bei int bleibst!

Die Compilerwarnung beim Aufruf von SerWrite bekommst du weg wenn du den String auf (unsigned char*) castest!

Präprozessorkonstanten sind groß zu schreiben, also DURCHLAUF und nicht durchlauf, da könnte man meinen es handelt sich um eine Variable.

Vor dem return 0; im main Block gehört noch ein while(1); hin da Asuro kein Betriebssystem besitzt, somit wäre das Verhalten nach return 0; undefiniert, während die Endlosschleife ein definiertes Verhalten an den Tag legt.

Hier mal der Code, viel hab ich nicht verändert bis auf die oben angeführten Details:

#include "asuro.h"

#define TRIGGERLEVEL 640
#define HYSTERESIS 5
#define LOW 0
#define HIGH 1
#define DURCHLAUF 200

void linien_verfolgen ( int *wert3,int z);
int main(void)
{
    unsigned int data[2];
    signed int status[2]={0,0};
    signed char difference=0;
   
   unsigned int data2[2];
   int hell;
   
   unsigned char wert1[5];
   unsigned char wert[200];
   unsigned char d,e,f,g,i,t,h;
   unsigned char a=0;
   int b=1;
   unsigned char resultat=0;
   int count1=0;
   unsigned char count2=0;
   char zeichen1[16]={'H','V','F','Ü','L','Ä','P','J','B','X','C','Y','Z','Q','Ö','\0'};
   char zeichen2[9]={'S','U','R','W','D','K','G','O','\0'};
   char zeichen3[6]={'I','A','N','M','\0'};
   char zeichen4[4]={'T','E','\0'};
   char w;
   


   int wert2[10];
   unsigned char count3=0;
   
   unsigned char eingabe[] = "0123";
   
   Init();
   
    MotorDir(FWD, FWD);
   
   while(PollSwitch()==0)                                       //start helligkeitswert einstellung
   {
   }
   SerWrite ((unsigned char*)" hellgkeitswert speichern ",26);                      //speichert den Wert für weisse Fläche
   FrontLED(ON);                                               //schaltet das Licht für Lichtsensoren ein
   LineData(data2);                                            //Ausführ befehl für einlesen von Lichtsensoren
   SerWrite ((unsigned char*)"\n",2);
   
   hell = data2[0]-14;                                        //stellt tolleranz für den weiss abgleich her
   PrintInt(hell);
   
      for (i = 0; i < 100; i++)                                  //Pause
          Sleep (255);
         
      FrontLED(OFF);                                            //schaltet das Licht für Lichtsensoren aus
      SerWrite ((unsigned char*)" hellgkeitswert gespeichern ",28);   
   
       for (i = 0; i < 100; i++)
         Sleep (72);

      SerRead (eingabe, 3, 0);

      for (i = 0; i < 100; i++)
         Sleep (72);

      SerWrite ((unsigned char*)" Los gehts! ",12);
      FrontLED(ON);                                          //schaltet das Licht für Lichtsensoren ein
    
      for (i = 1; i < DURCHLAUF; i++)
      {
      OdometrieData(data);                                    // Helligkeitswerte der Lichtschranken auslesen
       
        if ((status[0]==0) && (data[0]>TRIGGERLEVEL+HYSTERESIS))
      {                                                    // Wechsel linker Sensor von niedrig auf hoch?
            status[0]=1;
            difference++;
        }
        if ((status[0]==1) && (data[0]<TRIGGERLEVEL-HYSTERESIS))
      {                                                    // Wechsel linker Sensor von hoch auf niedrig?
            status[0]=0;
            difference++;
        }
      if ((status[1]==0) && (data[1]>TRIGGERLEVEL+HYSTERESIS))
      {                                                   // Wechsel rechter Sensor von niedrig auf hoch?
            status[1]=1;
            difference--;
        }
        if ((status[1]==1) && (data[1]<TRIGGERLEVEL-HYSTERESIS))
      {                                                   // Wechsel rechter Sensor von hoch auf niedrig?
            status[1]=0;
            difference--;
        }
       
        if (difference>0) MotorSpeed(155-difference,155);               // Zähldifferenz passend auf die Motoren verteilen
        else MotorSpeed(155,155+difference);
      
      LineData(data2);                                        //Ausführ befehl für einlesen von Lichtsensoren
      wert[i] = data2[0];                                       // Helligkeitswerte der Lichtschranken in ein array speichern
      PrintInt(data2[0]);
   }
   MotorDir(BREAK,BREAK);                                       //Haalt!
   FrontLED(OFF);                                             //schaltet das Licht für Lichtsensoren aus
   BackLED(ON,ON);   
   
   while(PollSwitch()==0)                                       //start auswertung
   {
   }
   SerWrite((unsigned char*)" Auswerten ",11);

   for (i=1;i<DURCHLAUF;i++)                                    //schleife für das auswerten der hell dunkel unterschiede
   {
      if (wert[i]<hell)                                       //wenn wert im Arry kleiner als der Hell Wert array neu mit 1 belegen
         {
         wert[i]=1;
         PrintInt(wert[i]);
         SerWrite((unsigned char*)"\n",2);
         }
      else if(wert[i]>=hell)
         {
         wert[i]=0;                                          //wenn wert im Arry grösser als der Hell Wert array neu mit 0 belegen
         PrintInt(wert[i]);
         SerWrite((unsigned char*)"\n",2);
         }
         }

   SerWrite((unsigned char*)" Auswertung:\n ",15);

   
for(h=0,e=0;e<12;e++,h++)
   {
   for (;b<DURCHLAUF;b++,h++)                                    //schleife für vereinfachung der Lichtsensor daten in eins und null
      {
      if ( wert[a] == 0 )                                       
         {
         for ( ; a<DURCHLAUF;a++)                              //0 auswertung
            {
            if (wert[a]==0)                                    //die nullen in Alphabet Array speichern
               count1++;                                    
            else if (count1>9&&b>1)                              //wert für buchstaben wechsel
                  {
                  b=DURCHLAUF;
                  count1=0;
                  wert2[h]=2;
                  count3++;
                  break;
                  }
            else if (count1>9 && b==1)                           //wert für anfangs toleranz
                  {
                  b--;
                  count1=0;
                  break;
                  }
            else if (count1<=7 && count1>2)                        //wert für zeichen wechsel
                  {
                  b--;
                  count1=0;
                  break;
                  }
            }
         }
      else
         {
         for ( ;a<DURCHLAUF;a++)                                 // 1 auswertung
            {
            if (wert[a] == 1)
               count1++;
            else if (count1>=5)                                 //wert für strich
                  {
                  wert1[b]=1;
                  count2++;
                  count1=0;
                  wert2[h]=1;
                  count3++;
                  break;
                  }
            else if (count1<5 && count1>=1)                        //wert für punkt
                  {
                  wert1[b]=0;
                  count2++;
                  count1=0;
                  wert2[h]=0;
                  count3++;
                  break;
                  }
            }
         }
      }
         t=count2;                     //count für anzahl punkt und strich
         t--;                        //für auswertung wichtig count zahl minus eins
 
      for (d=t,g=2;d>0;d--,g*=g)            //schleife für die beschränkung der anzahl von zeichen in einem buchstaben
            {
            f=d+1;                     //wird der wert des letzten zeichens ermittelt von letzter stelle des arrays gerechnet wird
            wert1[d]*=g;               //array wird bei drei zeichen von rechts nach links gerechnet mal 1 mal 2 mal 4 mal 8
            wert1[d]+=wert1[f];            //zusammen ergibt sich für die zeichen einen wert den man dan bei buchstaben array abfragen kann
            resultat=wert1[d];            //speichern des arry wertes in eine variabel
            }
            if       ( count2==4){         //den buchstaben für das zeichen die vierten array reihe ausgeben
                  w=zeichen1[resultat];
                  SerWrite ((unsigned char*)" ",1);
                  SerWrite ((unsigned char*)&w,1);
                  count2=0;
                  b=1;
                  }
            else if ( count2==3){         //den buchstaben für das zeichen die dritte array reihe ausgeben
                  w=zeichen2[resultat];
                  SerWrite ((unsigned char*)" ",1);
                  SerWrite ((unsigned char*)&w,1);
                  count2=0;
                  b=1;
                  }
            else if ( count2==2){         //den buchstaben für das zeichen die zweite array reihe ausgeben
                  w=zeichen3[resultat];
                  SerWrite ((unsigned char*)" ",1);
                  SerWrite ((unsigned char*)&w,1);
                  count2=0;
                  b=1;
                  }
            else if( count2==1){         //den buchstaben für das zeichen die erste array reihe ausgeben
                  w=zeichen4[resultat];
                  SerWrite ((unsigned char*)" ",1);
                  SerWrite ((unsigned char*)&w,1);            
                  count2=0;            //um für das nächste zeichen weiter zu rechnen müssen diese variablen zurückgestellt werden
                  b=1;
                  }
            else
                  b=1;
                  
   }
    linien_verfolgen(wert2,count3);
   
   
while(1); 
return 0;
}
void linien_verfolgen ( int *wert3,int z)
      {
         unsigned int data4[2];
         unsigned int i;

      Init();
         SerWrite ((unsigned char*)" Ready? ",8);
         while(PollSwitch()==0)                                       
   {
   }
      
      SerWrite ((unsigned char*)" Los gehts! ",12);
      FrontLED(ON);
      MotorDir(FWD,FWD);
      
         while(1)
         {

         
             LineData(data4);
            for (i=0;i<z;i++)
            {
               if (wert3[i] == 2)
                  {
                  StatusLED(OFF);
                  for (i = 0; i < 100; i++)
                     Sleep (200);
                  }
               if (wert3[i] == 0);
                  {
                  StatusLED(RED);
                  for (i = 0; i < 100; i++)
                     Sleep (75);
                  StatusLED(OFF);
                  }
               if (wert3[i] == 1);
                  {
                  StatusLED(RED);
                  for (i = 0; i < 100; i++)
                     Sleep (200);
                     StatusLED(OFF);
                  }

                  }
            if(data4[0]>data4[1])
            {
               MotorSpeed(160,0);
               BackLED(ON,OFF);
            }
            else if (data4 [0] < data4 [1] )
            {
               MotorSpeed(0,160);
               BackLED(OFF,ON);
            }
            else
               {
               MotorSpeed(160,160);
               BackLED(ON,ON);
            }
            }
                


}

[damaltor]

langsam langsam.
1. die variablengrößen (char/int/...) beeinflussen die nutzung des arbeitsspeichers (sram) aber nicht die größe des hex-files.
2. das flash tool meldet wenn der speicher voll ist.
3. hex-files enthalten noch daten wie zeilennummern und prüfsummen. sie sind NICHT genauso groß wie der verbrauchte speicher im prozessor. sie sind DEUTLICH größer.
4. der compiler gibt am ende des kompiliervorgangs aus wie groß das eigentliche programm ist.
5. flash mal den selbsttest - er hat mehr als 60 seiten und passt gut rein. ich glaube etwa 120 pages sind möglich, evtl auch 140.

[harry3]

>>1. die variablengrößen (char/int/...) beeinflussen die nutzung des arbeitsspeichers (sram) aber nicht die größe des hex-files. <<

Ich bezog mich in meinem ersten Beitrag auf initialisierte Felder, denn diese Werte müssen auch im hex File gespeichert werden.