Programm zusammenfügen - DEBUG Messages Fehler

[Dan M. (luizaranha)]

Hallo Kollegen,

wir haben in der Uni ein Projekt für eine Vorschubregelung einer Turbine 
gemacht. Die Regelung funktioniert auch wunderbar.
Als Zusatz haben wir nun eine Verbindung zu Matlab hergestellt, dass wir 
bis jetzt in einem Extra-Programm implementiert haben. Auch das 
funktioniert wunderbar, wir senden einen Befehl, dann wird der 
Ventilator manuell mit einem gewissen Dutycyle angesteuert. Für die 
manuelle Steuerung setzen wir eine globale auf eins, dass gleiche machen 
wir für die Regelung.

Nun zum Problem: Jetzt wollten wir "nur" noch den Code für den PID 
Regler in das andere Programm einsetzen, so dass das die globale 
Variable für die Regelung entscheidet, ob geregelt wird.
Nach 3h vergeblichen Versuchen konnte wir die Ursache auf Debug Messages 
verkleinern, aber sind nicht sicher obs die wirklich sind....

Die Funktion RS232 liest die Kommandos aus und setzt je nach Kommando 
die globalen Variablen flagPWM und flagCTRL.

Und wie gesagt, der PID Regler an sich funktioniert auch, allerdings nur 
wenn diese Debug Messages mit drin sind........


hier der Code

// Predefined compiler symbols:
#define LEDgreen 24
#define LEDred 25
#define LEDyellow 26

#define RS232 0
#define CR 0x0D

#define PERIOD 492

// Declaration of global variables:
// 100 bytes send + 100 bytes receive RS232Buffer + 6 bytes int.FIFO management
byte RS232Buffer[206];         // TxD/RxD buffer RS232
byte Linebuffer[101];          // hier wird das gelesene Zeug reingeschrieben
byte RxCount;                  // Number of received characters


// Linebuffer will be decoded into this command elements:
byte CMD[20];                  // Raw command
byte PAR1[20];                 // Command line paramter 1
byte PAR2[20];                 // Command line paramter 2
byte PAR3[20];                 // Command line paramter 3

// Test-Message:
char rmsg1[5];                 // Message Command


//Globals for Pulse Width Modulation (PWM)
byte    flagPWM;               //Schalter für PWM ein oder aus
byte    flagCTRL;              //Schalter für Regelung ein oder aus
float   RS232output;           //Verhältnis ein zu ausschaltzeit von RS232 vorgeben oder von PID ctrl
//float   PIDoutput;             //Verhältnis ein zu ausschaltzeit von PID controller
float   PWMwidth;


int period;        //period of the PWM

float PID_output,pwm_output;
word ADC_Value;
word ang_ref;
float ang_msurd,err,err_prev,err_acc,err_diff;
float Kp;
float Ki;
float Kd;

// Function of PWM previous version

void pwm(float PID_output){  //function pwm //////////////////////
//help variables///////////////////////////7

int PWM_Counter_A;  //pulswidth of the PWM in a promille scale
//////////////////
period=492;
PWM_Counter_A=period*PID_output;

Timer_T1PWM(period,PWM_Counter_A,PS_1);
}

//////////////////////////////////////////////////////////////////
float adc2angel(word ADC_Value)
{
    float ang_tmp;
    if(ADC_Value>425)
    {
        ang_tmp=-0.008*ADC_Value-4.6;
    }
    if(ADC_Value<=425 && ADC_Value>300)
    {
        ang_tmp=-0.016*ADC_Value-1.2;
    }
    if(ADC_Value<=300 && ADC_Value>222)
    {
        ang_tmp=-0.025*ADC_Value+1.692;
    }
    if(ADC_Value<=222 && ADC_Value>170)
    {
        ang_tmp=-0.038*ADC_Value+4.538;
    }
    if(ADC_Value<=170 && ADC_Value>130)
    {
        ang_tmp=-0.05*ADC_Value+6.5;
    }
    if(ADC_Value<=130 && ADC_Value>105)
    {
        ang_tmp=-0.08*ADC_Value+10.4;
    }
    if(ADC_Value<=105 && ADC_Value>86)
    {
        ang_tmp=-0.105*ADC_Value+13.05;
    }
    if(ADC_Value<=86 && ADC_Value>73)
    {
        ang_tmp=-0.153*ADC_Value+17.23;
    }
    if(ADC_Value<=73 && ADC_Value>59)
    {
        ang_tmp=-0.142*ADC_Value+16.42;
    }
    if(ADC_Value<=59 && ADC_Value>52)
    {
        ang_tmp=-0.285*ADC_Value+24.85;
    }
    if(ADC_Value<=52 && ADC_Value>46)
    {
        ang_tmp=-0.333*ADC_Value+27.33;
    }
    if(ADC_Value<=46 && ADC_Value>42)
    {
        ang_tmp=-0.5*ADC_Value+35;
    }
    if(ADC_Value<=42)
    {
        ang_tmp=-1.0*ADC_Value+56;
    }
     return ang_tmp;


}

/////////////main//////////////////////////////
void main(void)
{
//****************************
//Declaration of variables
    int i,PWMwidth;

//*****************************
//Dafault settings of variables
    i=0;
    PWMwidth=1;
    RS232output=1;
    flagPWM=0;
    flagCTRL=0;

//************
//Initializing
    Port_DataDirBit(16,1);    //Define PortD.0 as output
    Port_DataDirBit(17,1);      //Define PortD.1 as output
    Port_DataDirBit(LEDyellow,1);   //Define PortD.2 as output
    Timer_T1PWM(PERIOD,1,PS_1);     //Define PWM with duration of 1 (0 not allowed!!)
    Serial_Init_IRQ(RS232,RS232Buffer,100,100,SR_8BIT|SR_1STOP|SR_NO_PAR,SR_BD19200);
    // Initialize RS232: 19200 bps, 8 Bit, 1 Stop, NP
    // 100 bytes receive RS232Buffer - 100 bytes send RS232Buffer

//***************************
//Send Test-Message to MATLAB
    rmsg1="C-Control PRO ready for receiving\r\n";

    for(i=0;i<2;i++)
        Serial_WriteText(RS232,rmsg1);   // Serielle Schnittstelle Test senden


//*********************************************************************************************

    PID_output=0.0;
    ang_ref=0.0;
    err_acc=0;
    err_prev=0.0;
    ADC_Set(ADC_VREF_VCC, ADC0);
    //Kp=0.01;
    //Ki=0.005;
    //Kd=0.5;
    //Zigler Nicolas method
    /*Kp=0.0360;
    Ki=0.0411;
    Kd=0.0079;*/
    Kp=0.01;
    Ki=0.005;
    Kd=0.5;

    while (1)
    {
    ////////// PID regler///////////////////////////////////////////////
        ADC_Value=ADC_Read();
        ang_msurd=adc2angel(ADC_Value);
        if(ang_msurd>15) ang_msurd=15;
        if(ang_msurd<-10) ang_msurd=-10;
        //Msg_WriteHex(ADC_Value);
        err=ang_ref+ang_msurd;
        err_acc=err_acc+err;
        err_diff=err-err_prev;
        if(err_acc>20) err_acc= 20.0;
        if(err_acc<-20) err_acc= -20.0;
        PID_output=Kp*err+Ki*err_acc+Kd*err_diff;
        pwm_output=(PID_output+0.5);
        //Msg_WriteChar(CR);                    // HIER FEHLER WAHRSCHEINLICH
        //Msg_WriteFloat(err_acc);              // HIER FEHLER WAHRSCHEINLICH
        if(pwm_output<0.05) pwm_output=0.05;
        if(pwm_output>0.95) pwm_output=0.95;

        //Msg_WriteInt(100);
        PWMwidth=PERIOD*pwm_output;   // PWMwidth = hole periode*PIDoutput[0.00-1.00]
        //Timer_T1PWA(PWMwidth);       // PWM with value PIDoutput
        Timer_T1PWM(PERIOD,PWMwidth,PS_1);

  //      pwm(pwm_output);            // Previous version
        err_prev=err;
  //      AbsDelay(10);               // Previous version


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

        readRS232();                     // Read out RS232

        if(flagPWM & !flagCTRL)                      // PWM switch on/off
        {   PWMwidth=RS232output*PERIOD*0.01;
            Timer_T1PWA(PWMwidth);     // PWM with value PWMwidth
            Port_WriteBit(16,1);
        }
        else
            Port_WriteBit(16,0);

        if(flagCTRL)                     // Control switch on/off
        {   PWMwidth=PERIOD*pwm_output;   // PWMwidth = hole periode*PIDoutput[0.00-1.00]
            Timer_T1PWA(PWMwidth);       // PWM with value PIDoutput
            Port_WriteBit(17,1);
        }
        else
            Port_WriteBit(17,0);

        if(!flagCTRL & !flagPWM)         // PWM value --> zero
        {
            Timer_T1PWA(1);              // (0 not allowed!)
        }

         AbsDelay(10);
    }
}

Sollte jemand die Lösung finden, würd ich vor Freude in die Luft 
springen!!!!!


gruss Daniel

[Klaus W. (mfgkw)]

Schwer zu sagen, da ich das Programm etwas, naja, unübersichtlich finde.
Insofern kann es gut sein, daß ich jetzt falsche spekuliere, weil ich
es einfach auch nach 15 min lesen nicht so ganz verstehe.

---

Zumindest ein mittleres Problem sehe ich darin, daß in main()
wohl die PID-Regelung gemacht wird; die ist zeitabhängig:
ob ich die Schleife alle 10 msec oder alle 10 min durchlaufe, ist
relevant für das Zeitverhalten. Insbesondere der I-Anteil
muß ja die Abweichung mit der verstrichenen Zeit multiplizieren.
Ich kann aber kein festes Zeitraster erkennen, in dem die
Schleife durchlaufen wird.

Mehr oder weniger Debugausgaben können also die Regelung
beeinflussen.

Zudem wird ja auch die Regelung angehalten, bis etwas über RS232 kommt.
Soll das so sein?

---

Daniel Mayr schrieb:
> Für die
> manuelle Steuerung setzen wir eine globale auf eins, dass gleiche machen
> wir für die Regelung.

flagPWM und flagCTRL?
Das Programm wäre lesbarer, wenn man am Namen erkennen würde,
welcher Wert welche Bedeutung hat.
Daß das eine irgendwas mit PWM zu tun hat, sieht man, aber wie
wirkt sich welcher Wert aus?
Und was flagCTRL bewirkt, kann ich am Namen auch nicht erkennen.
Das if-Gewurschtel am Ende ist auch nicht gerade durchsichtig.

---

In adc2angel() wird wohl ein ADC-Wert in einen Engel verwandelt;
mit ein paar else könnte man das entlasten - es wird ja immer nur
einer der Zweige genutzt.

---

Daniel Mayr schrieb:
> Die Funktion RS232 liest die Kommandos aus

RS232 ist zu 0 #definiert.

---

Daniel Mayr schrieb:
> Nach 3h vergeblichen Versuchen...

Dann wären 10 min für eine vernünftige Beschreibung und sinnvolle
Kommentare auch noch drin gewesen...

:-)

---

Ich sehe nicht, wo pwm() aufgerufen wird.

---

Was machen Funktionen wie Timer_T1PWA, Timer_T1PWM ?

---

Solche Kommentare sind zwecklos:
    Port_DataDirBit(16,1);    //Define PortD.0 as output
    Port_DataDirBit(17,1);      //Define PortD.1 as output
Interessant wäre ein dürrer Satz dazu, was D.0 und D.1 bewirken
sollen.
Oder rauswerfen, wenn man es hier nicht braucht.

---

0 scheint nicht zu gehen, warum auch immer:

    Timer_T1PWM(PERIOD,1,PS_1);     //Define PWM with duration of 1 (0 not allowed!!)

Ist sicher, daß hier dann auch keine 0 gesetzt wird?

        PWMwidth=PERIOD*pwm_output;   // PWMwidth = hole periode*PIDoutput[0.00-1.00]
        //Timer_T1PWA(PWMwidth);       // PWM with value PIDoutput
        Timer_T1PWM(PERIOD,PWMwidth,PS_1);

---

Daniel Mayr schrieb:
> Und wie gesagt, der PID Regler an sich funktioniert auch, allerdings nur
> wenn diese Debug Messages mit drin sind........

"funktionieren" und "nicht funktionieren" heißt für Nichthellseher
wie mich was?

-------------

Das ist das, was mir beim Lesen so auffiel.
Aber wie gesagt finde ich es nicht besonders deutlich programmiert.
Es werden also schon noch ein paar Böcke drin sein.

[Dan M. (luizaranha)]

Hi Klaus,

danke für den "Anschiss". Wir haben leider nicht so viel Erfahrung mit 
Microcontroller geschichten und sind von unserer Uni iwie ins kalte 
Wasser geschmissen worden.
Mein syrischer Kollege hat den PID-Regler gemacht, und wir haben jetzt 
das Programm nochmal kommentiert und unwichtige Stellen draußen 
gelassen.

Das Problem ist immer noch mit den Debug messages:

//////////////////////////////////////////////////////////////////
        Msg_WriteChar(CR);                //Carry return message
        Msg_WriteFloat(err_acc);            //Display of err_acc //
// OHNE DIESE DEBUG MESSAGES FUNKTIONIERTS NICHT!!!!
///////////////////////////////////////////////////////////////////

Beschreibung im Manual siehe Anhang....

Hier noch der PID-Regler als C-code:

#define CR 0x0D

int period;        //period of the PWM

float PID_output,pwm_output;            //output value of controller
word ADC_Value;                    //ADC value
word ang_ref;                    //Reference Angel value
float ang_msurd,err,ang_msurd_prev,err_acc,err_diff;    //Controller variables
float Kp;                      //Propotional Coefficient
float Ki;                      //Integrater Coefficient
float Kd;                      //Diffirential Coefficient
void pwm(float PID_output){  //function pwm //////////////////////
//help variables///////////////////////////7
int PWM_Counter_A;  //pulswidth of the PWM in a promille scale
//////////////////
period=492;
PWM_Counter_A=period*PID_output;

Timer_T1PWM(period,PWM_Counter_A,PS_1);
}
//////////////////////////////////////////////////////////////////
float adc2angle(word ADC_Value)
{
    float ang_tmp;
    if(ADC_Value>425)
    {
        ang_tmp=-0.008*ADC_Value-4.6;        //1st interval equation
    }
    if(ADC_Value<=425 && ADC_Value>300)
    {
        ang_tmp=-0.016*ADC_Value-1.2;        //2nd interval equation
    }
    if(ADC_Value<=300 && ADC_Value>222)
    {
        ang_tmp=-0.025*ADC_Value+1.692;        //3rd interval equation
    }
    if(ADC_Value<=222 && ADC_Value>170)
    {
        ang_tmp=-0.038*ADC_Value+4.538;        //4th interval equation
    }
    if(ADC_Value<=170 && ADC_Value>130)
    {
        ang_tmp=-0.05*ADC_Value+6.5;        //5th interval equation
    }
    if(ADC_Value<=130 && ADC_Value>105)
    {
        ang_tmp=-0.08*ADC_Value+10.4;        //6th interval equation
    }
    if(ADC_Value<=105 && ADC_Value>86)
    {
        ang_tmp=-0.105*ADC_Value+13.05;        //7th interval equation
    }
    if(ADC_Value<=86 && ADC_Value>73)
    {
        ang_tmp=-0.153*ADC_Value+17.23;        //8th interval equation
    }
    if(ADC_Value<=73 && ADC_Value>59)
    {
        ang_tmp=-0.142*ADC_Value+16.42;        //9th interval equation
    }
    if(ADC_Value<=59 && ADC_Value>52)
    {
        ang_tmp=-0.285*ADC_Value+24.85;        //10th interval equation
    }
    if(ADC_Value<=52 && ADC_Value>46)
    {
        ang_tmp=-0.333*ADC_Value+27.33;        //11th interval equation
    }
    if(ADC_Value<=46 && ADC_Value>42)
    {
        ang_tmp=-0.5*ADC_Value+35;          //12th interval equation
    }
    if(ADC_Value<=42)
    {
        ang_tmp=-1.0*ADC_Value+56;          //13th interval equation
    }
     return ang_tmp;


}

/////////////main//////////////////////////////
void main(void)
{
    PID_output=0.0;              //Initialization
    ang_ref=0.0;              //Assigning Reference angel value
    err_acc=0;                //Initialization of error value
    ang_msurd_prev=ang_ref;              //Initialization of previous error value
    ADC_Set(ADC_VREF_VCC, ADC0);      //Setting ADC Configurations
    //Kp=0.01;
    //Ki=0.005;
    //Kd=0.5;
    //Zigler Nicolas method
    /*Kp=0.0360;
    Ki=0.0411;
    Kd=0.0079;*/
    Kp=0.01;                //Propotional Coefficient value
    Ki=0.005;                //Integrater Coefficient value
    Kd=0.5;                  ////Diffirential Coefficient value

    while (1)
    {
        ADC_Value=ADC_Read();        //Reading ADC value
        ang_msurd=adc2angle(ADC_Value);    //Calculating Angel value
        if(ang_msurd>15) ang_msurd=15;    //Limiting Angel value
        if(ang_msurd<-10) ang_msurd=-10;
        //Msg_WriteHex(ADC_Value);
        err=ang_ref+ang_msurd;        //Computing the error
        err_acc=err_acc+err;        //Accumlating the error
        err_diff=ang_msurd-ang_msurd_prev;        //computing the diffirential error
        if(err_acc>20) err_acc= 20.0;          //Limitting Accumulation error
        if(err_acc<-20) err_acc= -20.0;
        PID_output=Kp*err+Ki*err_acc+Kd*err_diff;    //PID equation
        pwm_output=(PID_output+0.5);          //Nolmalizing PID Output
        //////////////////////////////////////////////////////////////////
        Msg_WriteChar(CR);                //Carry return message
        Msg_WriteFloat(err_acc);            //Display of err_acc
        //// OHNE DIESE DEBUG MESSAGES FUNKTIONIERTS NICHT!!!!
        ///////////////////////////////////////////////////////////////////
        if(pwm_output<0.05) pwm_output=0.05;      //Limitting PWM Output
        if(pwm_output>0.95) pwm_output=0.95;

        pwm(pwm_output);                //Transfering PWM to Motor
        ang_msurd_prev=ang_msurd;            //Assigning current angle value to the previous angel value
        AbsDelay(10);                  //10 ms Interval Time
    }
}

Zur Beschreibung des Problems:
Wenn wir den Regler aus dem Compiler starten, dann funktioniert er, aber 
nur wenn die Debug messages drin sind.

Wenn wir nun die REset Taste drücken, dann funktioniert der Regler nicht 
(was ich komisch finde, da bei REset das Programm doch wieder bei void 
main (void) beginnt.

Danke schon im Vorraus für eure Hilfe!!

Gruss Luiz

[Karl H. (kbuchegg)]

Klingt für mich alles noch dem Problem, welches Klaus schon angesprochen 
hat: Ihr habt im Regler keinen definierten Zeittakt. Die Durchlaufzeit 
durch 1 Regelschleife ist mehr oder weniger von irgendwelchen 
Umgebungsbedingungen abhängig. Und wenn ihr die Umgebung entsprechend 
langsam genug macht, dann kommen die Regelparameter in einen Bereich in 
dem der Regler dann auch tatsächlich regelt. Lässt ihr aber alles mit 
'Full-Speed' laufen, funktionieren diese Parameter nicht mehr.


Den ganzen PID Regler in eine Timer ISR verschieben und so für einen 
regelmässigen immer gleichen Zeittakt sorgen. Die Regelparameter müssen 
dann natürlich wieder neu abgeglichen werden.

[Dan M. (luizaranha)]

Hallo Karl Heinz,

danke für den Tip. Haben den Regler jetzt in eine ISR geschoben und 
jetzt funktioniert die Sache (fast) perfekt.

Unser Projekt ist zwar jetzt schon abgegeben, aber eine weitere Frage zu 
unserer ISR:

1. Wir haben die Zeitdauer dieser ISR gemessen, und kommen auf knappe 
2ms.
  (Einen Ausgang auf High geschaltet, wenn die ISR läuft )
   ist das nicht ein bisschen lang?

Wir haben zwei Programme, eins, in dem nur der PID regler läuft ohne 
Schnick Schnack. Der Sollwert wird fast perfekt erreicht und gehalten.

Das andere Programm beinhaltet eine interrupt getriebene Auslesung der 
seriellen Schnittstelle, um zwischen Regelbetrieb und Manueller 
Ansteuerung zu unterscheiden. In jedem Durchlauf der while schleife wird 
die serielle SS gelesen... wenn keine Bytes im Puffer sind, kehrt die 
Funktion direkt wieder aus dem interrupt zurück.

Hier jedoch mussten wir für den Sollwert 5 Grad mehr einstellen, um auf 
0 Grad sollwert zu regeln.

Liegt das an mehr Rechenaufwand wg. der seriellen SS?

Wahrscheinlich könnt ihr das ohne programm nicht sagen, das programm ist 
glaub ich zu groß, ums hier reinzustellen. Hab auch keine Ahnung, was 
jetzt wirklich diesen kleinen Schönheitsfehler ausmacht, deswegen müsst 
ich alles reinstellen

Gruss und danke für die super tipps!

daniel

[Läubi .. (laeubi)]

Der Interrupt darf auch 10 Sekunden dauern wenn dieser nur alle 10 
Minuten auftritt und keine andere Funktionalität eine Unterbrechnung von 
10 Sek nicht Tolerieren kann.

Wegen Serielle Schnittstelle: Die würde ich nicht im Interrupt auslesen, 
sondern in der Hauptschleife, weil sonst je nachdem (Daten da/nicht da) 
das Zeitverhalten möglicherweise negativ beeinflusst wird.

@auszug_manual.jpg  Sowas nächstmal besser als PNG jpeg eignet sich 
nicht wirklich für Text.

[Dan M. (luizaranha)]

Hi Läubi,

danke für deinen Antwort.
Ich glaube jedoch, dass ich den interrupt Betrieb brauch, da ich in 
Matlab eine GUI geschrieben habe, und ich ja nicht beeinflussen kann, 
wann welcher Schalter gedrückt wird... Deswegen muss ich immer lesen, 
wenn nix da is, kehr ich wieder zurück.
im anhängsel noch der auszug aus dem Manual......für entweder interrupt 
betrieb oder ohne.

Aber das auslesen oder besser gesagt hören auf die serielle SS kann doch 
nicht so zeitkritisch sein, dass mein Regler im Interruptbetrieb ( 
Schleife alle 10 ms beeinflusst wird).


Gruss daniel

[Karl H. (kbuchegg)]

Für die Serielle selbst wieder einen Interrupt Betrieb zu benutzen ist 
schon ok.

Was gemeint ist:
Du sollst zb nicht eine Serielle AUsgabe aus einer ISR heraus machen.
Deine Berechnung des PID Reglers in der ISR soll tatsächlich nur das 
machen: einen Durchgang durch die Reglergleichungen und den Ausgang 
ansteuern. Mehr nicht.

Dann dauert deine ISR auch keine 2ms mehr.

Grundsätzlich: In einer ISR willst du
  * nicht warten
  * nichts machen, was länger dauert
  * nur das Allernotwendigste durchführen

Das heißt jetzt nicht, das man in einer ISR gar nichts tun darf, sondern 
dass man ein wenig überlegen soll, was man alles in eine ISR steckt und 
was nicht.

Grundsätzlich hätte man gerne, dass man aus einer ISR möglichst schnell 
seine Arbeit erledigt und wieder aus der ISR rauskommt. Eine Ausgabe 
über eine serielle Schnittstelle ist da kontraproduktiv.

[Vlad T. (vlad_tepesch)]

Das ist böse:

Daniel Mayr schrieb:
> // Test-Message:
> char rmsg1[5];                 // Message Command
>
> ...
>
>     rmsg1="C-Control PRO ready for receiving\r\n";
>
>     for(i=0;i<2;i++)
>         Serial_WriteText(RS232,rmsg1);   // Serielle Schnittstelle Test senden
>
>
>

[Dan M. (luizaranha)]

Vlad Tepesch schrieb:
> Das ist böse:
>
> Daniel Mayr schrieb:
>> // Test-Message:
>> char rmsg1[5];                 // Message Command
>>
>> ...
>>
>>     rmsg1="C-Control PRO ready for receiving\r\n";
>>
>>     for(i=0;i<2;i++)
>>         Serial_WriteText(RS232,rmsg1);   // Serielle Schnittstelle Test senden
>>
>>
>>

Ja, dass ist schon länger behoben..... unser feld hat ist jetzt char 
rmsg1[50].

Aber das Programm ging trotzdem!!!,

[Klaus W. (mfgkw)]

Daniel Mayr schrieb:
> unser feld hat ist jetzt char rmsg1[50].
> Aber das Programm ging trotzdem!!!,

Rubrik "spekulatives Programmieren", soweit es nur um die Feldlänge 
geht.

So wie es da steht, ist es aber nicht mal kompilierbar.

[Karl H. (kbuchegg)]

Daniel Mayr schrieb:

> Aber das Programm ging trotzdem!!!,

Falsch.
Es sah nur so aus als ob.

Nur weil ein Fehler nicht unmittelbar Unheil anrichtet, heißt das noch 
lange nicht, dass es in Ordnung ist.

[Dan M. (luizaranha)]

aha,

und warum ist das nicht kompilierbar??
mein Compiler meckert nicht bei

char rmsg1[50];         // Message Command

[Klaus W. (mfgkw)]

aber dann hoffentlich bei:

  rmsg1="C-Control PRO ready for receiving\r\n";

Grund: ein Feld ist ein konstanter Zeiger auf die Elemente, und
kann durch eine Zuweisung nicht mehr geändert werden.
Einen String ins Feld bekommt man entweder durch Initialisierung,
oder strcpy().

[Dan M. (luizaranha)]

Hallo Klaus,

Ich möcht hier nicht mein Kopf aus der Schlinge ziehn, jedoch ein paar 
Anmerkungen.
Meine Unerfahrenheit at mich ins Manual schauen lassen und den 
angehängten Ausschnitt hab ich  somit angewendet.

Die Sache mit String copy steht schon drin.... aber auch das meine 
Deklaration nicht falsch ist.
DIe Programmiersprache CompactC hat vllt etwas damit zu tun?!.

Gruss

p.s. der verwendete string ist constant wird nicht geändert, und nur 
einmal verwendet.

[Klaus W. (mfgkw)]

Daniel Mayr schrieb:
> Meine Unerfahrenheit at mich ins Manual schauen lassen und den
> angehängten Ausschnitt hab ich  somit angewendet.
>
> Die Sache mit String copy steht schon drin.... aber auch das meine
> Deklaration nicht falsch ist.
> DIe Programmiersprache CompactC hat vllt etwas damit zu tun?!.

Wenn deine Anleitung stimmt, dann ist das kein Standard-C.
Weder nach C89 noch nach C99 noch nach irgendwelchen C++ ist das
erlaubt.

Da du den String ja nur einmal setzen willst, gibt es eine kleine
Änderung, die wieder standardkonform ist, nämlich eine saubere
Initialisierung:

char rmsg1[50]="C-Control PRO ready for receiving\r\n"; // Message Command

So ist es mit jedem Compiler richtig.

[Dan M. (luizaranha)]

>
> Wenn deine Anleitung stimmt, dann ist das kein Standard-C.
> Weder nach C89 noch nach C99 noch nach irgendwelchen C++ ist das
> erlaubt.

wie gesagt CompactC ( siehe Projectboard MEGA32 von Conrad)
>

> Da du den String ja nur einmal setzen willst, gibt es eine kleine
> Änderung, die wieder standardkonform ist, nämlich eine saubere
> Initialisierung:
>

> char rmsg1[50]="C-Control PRO ready for receiving\r\n"; // Message 
>

> So ist es mit jedem Compiler richtig.

Und genau das unterstützt der Compiler nicht.......habs gerade 
durchlaufen lassen... es geht wirklich nur der eine Weg...
>

> char rmsg1[50];
rmsg="C-Control PRO ready for receiving\r\n"; // Message

>

Der Compiler übrigens heisst "C Control Pro IDE".

Das hat mit C wohl schon noch Ähnlichkeit, aber nicht mehr 100%....
Was an dem Compiler auch komisch ist, dass ich im Ausgabefenster nur 
globale Variablen anschauen kann...