Paar Probleme in C



  • Hey
    Ich hab ein paar Probleme in C. 😕
    Und zwar soll ich im folgenden Quelltext alle mit //TODO gekennzeichneten Aufgaben erledigen.
    Leider kann ich so gut wie gar kein C, ich habe auch keine Erfahrung mit ähnlichen Sprachen. 😞
    Kann mir einer helfen? 😕

    //------------------------------------------------------------------------------------------------
    //
    // Copyright (C) 2012-2013, Intel Corporation
    //
    // All rights reserved.
    //
    // Redistribution and use in source and binary forms, with or without modification, are permitted
    // provided that the following conditions are met:
    //
    // * Redistributions of source code must retain the above copyright notice, this list of conditions
    //   and the following disclaimer.
    // * Redistributions in binary form must reproduce the above copyright notice, this list of
    //   conditions and the following disclaimer in the documentation and/or other materials provided
    //   with the distribution.
    // * Neither the name of Intel Corporation nor the names of its contributors may be used to endorse
    //   or promote products derived from this software without specific prior written permission.
    //
    // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
    // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
    // FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
    // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
    // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
    // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    // POSSIBILITY OF SUCH DAMAGE.
    //
    // ------------------------------------------------------------------------------------------------
    
    #include <libilc.h>
    
    /** Globale Definitionen fuer Aufgabe 2 **/
    
    // Variablen
    msg_states current_state = IDLE;
    bool debug = false;
    char send_buffer[BUFFER_SIZE];//Sendedaten
    volatile double supply_voltage = 0.0; // Versorgungsspannungswert [mV] (wird spaeter korrekt gesetzt)
    
    // Sende-Macros
    #define str_send_msg(type, fmt, args...) {sprintf(send_buffer, fmt, ## args); ilc_send_msg(type, send_buffer);} 
    #define int_send_msg(type, x) {sprintf(send_buffer, "%d", x); ilc_send_msg(type, send_buffer);}
    #define int32_send_msg(type, x) {sprintf(send_buffer, "%ld", x); ilc_send_msg(type, send_buffer);}
    #define double_send_msg(type, x) {sprintf(send_buffer, "%5.3f", x); ilc_send_msg(type, send_buffer);}
    
    // Debug-Macros
    #define str_DEBUG(fmt, args...) {if(debug) {sprintf(send_buffer, fmt, ## args); ilc_send_msg(DBG, send_buffer);}}
    #define int_DEBUG(x) {if(debug) {sprintf(send_buffer, "%d", x); ilc_send_msg(DBG, send_buffer);}}
    #define int32_DEBUG(x) {if(debug) {sprintf(send_buffer, "%ld", x); ilc_send_msg(DBG, send_buffer);}}
    #define double_DEBUG(x) {if(debug) {sprintf(send_buffer, "%5.3f", x); ilc_send_msg(DBG, send_buffer);}}
    #define hex_DEBUG(x) {if(debug) {sprintf(send_buffer, "%x", x); ilc_send_msg(DBG, send_buffer);}}
    
    // Funktionen
    void adc0handler(adc_result_t result);
    void adc1handler(adc_result_t result);
    void adcvcchandler(adc_result_t result);
    
    // Zusaetzliche Funktionen
    void extint_rain_init(void);
    void inc_rain_count();
    void calculate_rain_mm();
    void humidity_timer_init();
    void humidity_counter_init();
    void humidity_counting_done();
    void calculate_rel_humidity();
    double calc_hpa_const(uint16_t data, uint8_t integer_bits);
    void init_hpa_sensor();
    void hpa_read_pressure();
    void wind_counting_done();
    
    //////////////////////////////////////////////////////////////////////////
    // Aufgabe 2
    //////////////////////////////////////////////////////////////////////////
    
    /** Aufgabe 2.3.6
     *  Implementiert die oben beschriebene Zustandsmaschine an den markierten Stellen 
    	im gegebenen Quelltext. Denkt dabei an eine Fehlerbehandlung beim Kopieren 
    	der Nutzdaten. Beweist die Funktion eures Programms durch ein kleines Video.
    
    	Vervollstaendigt dazu die folgende Funktion an den markierten Stellen.
    */
    int main (void){
    	// Initialisierung
    	ilc_init();		
    
    	// uC sagt "Hallo"
    	ioport_set_pin_level(D2, false);
    	ioport_set_pin_level(D3, false);
    	delay_s(2);
    	ioport_set_pin_level(D2, true);
    	ioport_set_pin_level(D3, true);
    
    	//Nutzdaten; maximal 16 byte Empfangsnachricht
    	char message[16];
    	char* msg_pointer = message;
    	// es sind keine Nutzdaten im Buffer
    	bool data_available = false;
    
    	//Main-Loop
    	while (true) {		
    		// If statt while damit andere tasks auch abgearbeitet werden koennen
    		if (udi_cdc_is_rx_ready() && !data_available){
    
    			// wir lesen ein byte aus dem empfangsbuffer
    			//TODO: Lese ein Byte. 
    			char byte = 
    
    			switch(current_state){
    				case IDLE:		if (byte == DLE){
    									// TODO: Sprung zum nachsten Zustand
    									current_state = 
    									str_DEBUG("-I- Neuer Zustand: PRE_START");
    								} 
    								//sonst bleiben wir bei IDLE und initialisieren Buffer und Zeiger
    								msg_pointer = message;
    								break;
    				case PRE_START:	if (byte == STX){
    									// TODO: Sprung zum nachsten Zustand
    									current_state = 
    									str_DEBUG( "-I- Neuer Zustand: ");
    								} else {
    									// das DLE war ein Fehler, es wird weiter gewartet
    									// TODO: Sprung zum nachsten Zustand
    									current_state = 
    									str_DEBUG( "-I- Neuer Zustand: ");
    								}
    								break;
    				// TODO: Welcher Zustand?
    				case 			if (byte == DLE){
    									// TODO: Sprung zum nachsten Zustand
    									current_state = 
    									str_DEBUG( "-I- Neuer Zustand: DLE_IN_MSG");
    								} else {
    									if(((msg_pointer - message) >= 16) && debug) {
    										ilc_send_msg(DBG, "-E- Zuviele Bytes empfangen");
    									}
    									// TODO: Byte kopieren. 
    									*msg_pointer = 
    									++msg_pointer;								
    								}
    								break;
    				case DLE_IN_MSG: if(byte == ETX){
    									// jetzt ist Schluss
    									// TODO: Sprung zum nachsten Zustand
    									current_state = ;
    									str_DEBUG("-I- Neuer Zustand: FINISHED");
    								} else {
    									current_state = RUNNING;
    									if (debug) {
    										ilc_send_msg(DBG, "-I- Neuer Zustand: RUNNING");
    										if(((msg_pointer - message) >= 16) && debug) {
    											ilc_send_msg(DBG, "-E- Zuviele Bytes empfangen");
    										}
    									}
    									// TODO: Byte kopieren. 
    									*msg_pointer = 
    									msg_pointer++;
    									break; 
    								}
    				case FINISHED:	// Die Nachricht liegt vollständig im Buffer
    								// Wir aktivieren die Auswertung der Daten im main-loop und gehen zurück in den Zustand IDLE 
    								current_state = IDLE;
    								str_DEBUG("-I- Neuer Zustand: IDLE");
    								// TODO: Daten sind vorhanden
    								data_available = 
    								break;
    				default: 		break;
    			}
    		}
    		/** Der folgende Code muss zur Aufgabe 2.3.6 nicht angepasst werden **/
    		if (data_available) {
    			//das erste byte entscheide über die Art der Daten
    			switch(message[0]){			
    				case COMMAND:
    							// Wir unterscheiden verschiedene Kommandos
    							switch(message[1]){
    								case DEBUG_ON:		debug = true;
    													ilc_send_msg(DBG, "-I- DEBUG on");
    													break;
    								case DEBUG_OFF:		debug = false;
    													ilc_send_msg(DBG, "-I- DEBUG off");
    													break;
    								case LED_D2_ON:		ioport_set_pin_level(D2, false);
    													str_DEBUG("-I- LED D2 an");
    													break;
    								case LED_D2_OFF:	ioport_set_pin_level(D2, true);
    													str_DEBUG("-I- LED D2 aus");
    													break;
    								case LED_D3_ON:		ioport_set_pin_level(D3, false);
    													str_DEBUG("-I- LED D3 an");
    													break;
    								case LED_D3_OFF:	ioport_set_pin_level(D3, true);
    													str_DEBUG("-I- LED D3 aus");
    													break;
    								default: 			str_DEBUG("-E- Unbekanntes KOMMANDO");
    													break;
    							}
    							break;
    				case TEMP:	str_DEBUG("-I- Dies fordert einen Temperatur-Wert an.");
    							break;
    				case LICHT:	str_DEBUG("-I- Dies fordert einen Licht-Wert an.");
    							break;
    				case WIND:	str_DEBUG("-I- Dies fordert einen Wind-Wert an.");
    							break;
    				case REGEN:	str_DEBUG("-I- Dies fordert einen Regen-Wert an.");
    							break;
    				case FEUCHT:str_DEBUG("-I- Dies fordert einen Feuchtigkeits-Wert an.");
    							break;
    				case DRUCK:	str_DEBUG("-I- Dies fordert einen Druck-Wert an.");
    							break;
    				case DBG:	str_DEBUG("-E- Kein KOMMANDO wurde kopiert. Nachrichten vom Typ DBG können nicht empfangen werden.");
    							break;
    				default: 	str_DEBUG("-E- Unbekannte Nachricht");
    							break; 			
    			}
    			//Nach dem abarbeiten der Daten duerfen neue Daten empfangen werden
    			data_available = false;
    			//DBG == 0x7F; kein erlaubter Wert
    			memset(message, DBG, 16);
    		}
    	}
    }
    
    /** Aufgabe 2.4.6 - kann auch hier gecodet werden; Der Aufruf kann aus dem Grundgeruest der Aufgabe 2.4.6 genommen werden. 
     *  Vervollstaendigt die folgenden Funktionen an den markierten Stellen. 
     */ 
    // Funktion    : adc0handler, extern to libilc
    // Beschreibung: Callback Funktion fuer ADU pin PA2 / Temperatur
    void adc0handler(adc_result_t result){
    	// Lokale Variablen
    	double pre_resistor = 18000.0;
    	double temp_voltage;
    	double ntc_resitor;
    	double r_0;
    	double t_0;
    	double r_1;
    	double t_1;
    	double temperature;
    
    	// Konvertierung des ADC-Resultats zum Eingangsspannungswert [mV]
    	temp_voltage = (supply_voltage/1.6) * (((double) result)/2048.0);
    	str_DEBUG("-I- Spannung am Temperatursensor: %5.3f mV", temp_voltage);
    
    	// Konvertierung des Eingangsspannungswerts zum Widerstandswert des Heissleiters
    	if (temp_voltage == supply_voltage) {
    		// Fehlerfall unendlicher Widerstand des Heissleiters
    		ntc_resitor = 99999999.9;
    	}
    	else {
    		// TODO: Berechnet den Widerstand des Heissleiters. 
    		ntc_resitor = 0.0; //Zuweisung auf 0.0 zum Kompilieren
    	}
    	str_DEBUG("-I- Widerstand des Heissleiters: %5.3f Ohm\n", ntc_resitor);
    
    	// Bestimme geeignete Werte-Paare zwecks linearer Interpolation anhand des Datenblatts
    	if      (ntc_resitor > 337290.0) {r_0 = 453130.0; t_0 = -55.0; r_1 = 337290.0; t_1 = -50.0;}
    	else if (ntc_resitor > 253330.0) {r_0 = 337290.0; t_0 = -50.0; r_1 = 253330.0; t_1 = -45.0;}
    	else if (ntc_resitor > 191910.0) {r_0 = 253330.0; t_0 = -45.0; r_1 = 191910.0; t_1 = -40.0;}
    	else if (ntc_resitor > 146590.0) {r_0 = 191910.0; t_0 = -40.0; r_1 = 146590.0; t_1 = -35.0;}
    	else if (ntc_resitor > 112880.0) {r_0 = 146590.0; t_0 = -35.0; r_1 = 112880.0; t_1 = -30.0;}
    	else if (ntc_resitor >  87588.0) {r_0 = 112880.0; t_0 = -30.0; r_1 =  87588.0; t_1 = -25.0;}
    	else if (ntc_resitor >  68471.0) {r_0 =  87588.0; t_0 = -25.0; r_1 =  68471.0; t_1 = -20.0;}
    	else if (ntc_resitor >  53910.0) {r_0 =  68471.0; t_0 = -20.0; r_1 =  53910.0; t_1 = -15.0;}
    	else if (ntc_resitor >  42739.0) {r_0 =  53910.0; t_0 = -15.0; r_1 =  42739.0; t_1 = -10.0;}
    	else if (ntc_resitor >  34109.0) {r_0 =  42739.0; t_0 = -10.0; r_1 =  34109.0; t_1 =  -5.0;}
    	else if (ntc_resitor >  27396.0) {r_0 =  34109.0; t_0 =  -5.0; r_1 =  27396.0; t_1 =   0.0;}
    	else if (ntc_resitor >  22140.0) {r_0 =  27396.0; t_0 =   0.0; r_1 =  22140.0; t_1 =   5.0;}
    	else if (ntc_resitor >  17999.0) {r_0 =  22140.0; t_0 =   5.0; r_1 =  17999.0; t_1 =  10.0;}
    	else if (ntc_resitor >  14716.0) {r_0 =  17999.0; t_0 =  10.0; r_1 =  14716.0; t_1 =  15.0;}
    	else if (ntc_resitor >  12099.0) {r_0 =  14716.0; t_0 =  15.0; r_1 =  12099.0; t_1 =  20.0;}
    	else if (ntc_resitor >  10000.0) {r_0 =  12099.0; t_0 =  20.0; r_1 =  10000.0; t_1 =  25.0;}
    	else if (ntc_resitor >   8308.0) {r_0 =  10000.0; t_0 =  25.0; r_1 =   8308.0; t_1 =  30.0;}
    	else if (ntc_resitor >   6936.0) {r_0 =   8308.0; t_0 =  30.0; r_1 =   6936.0; t_1 =  35.0;}
    	else if (ntc_resitor >   5819.0) {r_0 =   6936.0; t_0 =  35.0; r_1 =   5819.0; t_1 =  40.0;}
    	else if (ntc_resitor >   4904.0) {r_0 =   5819.0; t_0 =  40.0; r_1 =   4904.0; t_1 =  45.0;}
    	else if (ntc_resitor >   4151.0) {r_0 =   4904.0; t_0 =  45.0; r_1 =   4151.0; t_1 =  50.0;}
    	else if (ntc_resitor >   3529.0) {r_0 =   4151.0; t_0 =  50.0; r_1 =   3529.0; t_1 =  55.0;}
    	else if (ntc_resitor >   3012.0) {r_0 =   3529.0; t_0 =  55.0; r_1 =   3012.0; t_1 =  60.0;}
    	else if (ntc_resitor >   2582.0) {r_0 =   3012.0; t_0 =  60.0; r_1 =   2582.0; t_1 =  65.0;}
    	else if (ntc_resitor >   2221.0) {r_0 =   2582.0; t_0 =  65.0; r_1 =   2221.0; t_1 =  70.0;}
    	else if (ntc_resitor >   1918.0) {r_0 =   2221.0; t_0 =  70.0; r_1 =   1918.0; t_1 =  75.0;}
    	else if (ntc_resitor >   1663.0) {r_0 =   1918.0; t_0 =  75.0; r_1 =   1663.0; t_1 =  80.0;}
    	else if (ntc_resitor >   1446.0) {r_0 =   1663.0; t_0 =  80.0; r_1 =   1446.0; t_1 =  85.0;}
    	else                             {r_0 =   1446.0; t_0 =  85.0; r_1 =   1262.0; t_1 =  90.0;}
    
    	// Linear Interpolation der Temperatur
    	// TODO: Berechnung der Temperatur in Grad Celsius
    	temperature = 0.0; //Zuweisung auf 0.0 zum Kompilieren
    
    	if(debug) {
    		str_send_msg(DBG, "-I- Temperatur: %5.3f Grad Celsius", temperature);
    	}
    	else{
    		double_send_msg(TEMP, temperature);
    	}
    }
    
    // Funktion    : adc1handler, extern to libilc
    // Beschreibung: Callback Funktion fuer ADU pin PA3 / Licht
    void adc1handler(adc_result_t result){
    	// Lokale Variablen
    	double r_1 = 470.0;
    	double light_voltage;
    	double light_current;
    	double light_intensity;
    
    	// Konvertierung des ADC-Resultats zum Eingangsspannungswert [mV]
    	// TODO: Berechnet die Spannung des ADC-Eingangs fuer den Lichtsensor
    	light_voltage = 0.0; //Zuweisung auf 0.0 zum Kompilieren
    	str_DEBUG("-I- Spannung am Beleuchtungsstärkesensor: %5.3f mV", light_voltage);
    
    	// Berechnung der Stromstärke des Beleuchtungsstärkesensors [µA]
    	// TODO: Berechnet die Stromstärke am Ausgang des Lichtsensors ueber r_1
    	light_current = 0.0; //Zuweisung auf 0.0 zum Kompilieren
    	str_DEBUG("-I- Stromstärke des Beleuchtungsstärkesensors: %5.3f microA\n", light_current);
    
    	// Berechnung der Beleuchtungsstärke [Lux]
    	// TODO: Rechnet die Stromstaerke in die Beleuchtungsstaerke um. (basierend auf einem nominellen Sensor)
    	light_intensity = 0.0; //Zuweisung auf 0.0 zum Kompilieren
    
    	if(debug) {
    		str_send_msg(DBG, "-I- Beleuchtungsstärke: %5.3f Lux", light_intensity);
    	}
    	else{
    		double_send_msg(LICHT, light_intensity);
    	}
    }
    
    // Funktion    : adcvcchandler, extern to libilc
    // Beschreibung: Callback Funktion fuer ADU sampling VCC scaled by 10
    void adcvcchandler(adc_result_t result){
    	// Konvertierung des ADC-Resultats zum Versorgungsspannungswert [mV]
    	// Interne Referenz auf Bandgap gestellt (1.0V = 1.1V*10/11); Vin = Vcc/10
    	supply_voltage = 10 * 1000.0 * (((double) result)/2048.0);  
    	str_DEBUG("-I- Versorgungsspannung: %5.3f mV", supply_voltage);
    }
    
    /** Der folgende Code kann fuer die Bearbeitung der Aufgabe 2.3 und 2.4 ignoriert werden. 
        Der Code wird in den folgenden Aufgaben vervollstaendigt.
    	**/
    //////////////////////////////////////////////////////////////////////////
    // Aufgabe 3 + 4
    //////////////////////////////////////////////////////////////////////////
    
    // Function    : ilc_extint_rain_init()
    // Description : Init external interrupt for rain rocker (Port E Pin 0) Interrupt 1
    void extint_rain_init(void) {
    }
    
    // Funktion    : inc_rain_count
    // Beschreibung: Interruppt callback. Erhoeht die Anzahl der Regen-ticks und setzt den Interrupt neu auf. 
    void inc_rain_count(){
    }
    
    // Funktion    : calculate_rain_mm
    // Beschreibung: Bestimmt die Regenfallmenge in mm
    void calculate_rain_mm(){
    }
    
    // Funktion    : humidity_timer_init
    // Beschreibung: Initialisiert den Timer zur Feuchtigkeitsmessung
    void humidity_timer_init(){
    }
    
    // Funktion    : humidity_counter_init
    // Beschreibung: Initialisiert den benoetigten Counter
    void humidity_counter_init(){
    }
    
    // Funktion    : humidity_counting_done
    // Beschreibung: Wenn counting abgeschlossen ist, wird der Wert ausgelesen und in einer globalen Variable gespeichert. 
    void humidity_counting_done(){
    }
    
    // Funktion    : calculate_rel_humidity
    // Beschreibung: Bestimmt die relative Luftfeutchtigkeit aus dem gezaehlten Wert und sendet das Ergbnis an den PC. 
    void calculate_rel_humidity(){
    }
    
    // Funktion    : calc_hpa_const
    // Beschreibung: Bestimmt die Konstanten des HPA aus den gelesenen Parametern
    double calc_hpa_const(uint16_t data, uint8_t integer_bits) {
    	return 0.0;
    }
    
    // Funktion    : init_hpa_sensor
    // Beschreibung: Initialisiert den Drucksensor
    void init_hpa_sensor() {	
    }
    
    // Funktion    : hpa_read_pressure
    // Beschreibung: Liesst einen Druckwert
     void hpa_read_pressure() {	
    }
    
    // Funktion    : wind_counting_done
    // Beschreibung: Callback wenn wind counting abgeschlossen ist
    void wind_counting_done(){
    }
    
    //////////////////////////////////////////////////////////////////////////
    // Zusaetzliche Callbacks
    //////////////////////////////////////////////////////////////////////////
    
    // Funktion    : extint_sw2
    // Beschreibung: Callback function for external interrupt on SW2
    void extint_sw2(){
    }
    
    // Funktion    : extint_sw3
    // Beschreibung: Callback function for external interrupt on SW3
    void extint_sw3(){
    }
    
    // Funktion    : extint_pa4
    // Beschreibung: Callback function for external interrupt on pin PA4
    void extint_pa4(){
    }
    
    // Funktion    : extint_pa5
    // Beschreibung: Callback function for external interrupt on pin PA5
    void extint_pa5(){
    }
    
    // Funktion    : uart_rx_notify
    // Beschreibung: Callback Funktion fuer den uart interrupt
    void uart_rx_notify(){
    }
    

    Ich fänds super, wenn ihr helft 🙂

    Danke schonmal im Vorraus, der Pro


  • Mod

    Pro schrieb:

    Hey
    Ich hab ein paar Probleme in C. 😕
    Und zwar soll ich im folgenden Quelltext alle mit //TODO gekennzeichneten Aufgaben erledigen.
    Leider kann ich so gut wie gar kein C, ich habe auch keine Erfahrung mit ähnlichen Sprachen. 😞
    Kann mir einer helfen? 😕

    Ist der Zweck der Aufgabe nicht, dass du C lernst, anstatt dich weiter durchzumogeln?

    Es ist so gut wie ausgeschlossen, dass du mit dieser Aufgabe und deiner Einstellung hier Hilfe finden wirst. Zumindest keine Hilfe zur Aufgabe. Vermutlich viele Ratschläge in die Richtung, dass du wohl besser die vorherigen Hausaufgaben gemacht hättest oder bei der Anmeldung für den fortgeschrittenen C-Kurs nicht deine Kenntnisse hättest übertreiben sollen.

    Ansonsten ist die Aufgabe auch noch unvollständig und selbst für einen motivierten Helfer wäre es daher unmöglich dir zu helfen. Was ist das? Ein Praktikumsversuch? Ich kann mir nicht vorstellen, dass ihr da völlig ohne Anleitung an solch einen Code geschickt werdet. Diese Anleitung ist sicher auch so ausgelegt, dass man ohne Kenntnisse, aber dafür mit etwas Motivation, die Aufgabe lösen kann. Falls es dennoch nicht ausreicht, frag deinen Betreuer um Hilfe.



  • // Copyright (C) 2012-2013, Intel Corporation
    

    Danach hab ich aufgehört zu lesen... ich schaus mir bestimmt morgen noch mal an.



  • Es wäre nicht so, dass ich gar kein C kann.
    Ich hab den ganzen gestrigen Tag lang YoutubeTutorials geschaut, um etwas vom Quelltext zu verstehen. Nur das was ich jetzt kann, bringt mich nicht weiter.

    Vielleicht ist es auch nur so, dass mich die Aufgabenformulierungen verwirren und ich die Aufgaben, wenn sie anders formuliert wären, lösen könnte.
    Ich weiß zum Beispiel nicht, was mit "Sprung zum nächsten Zustand" gemeint ist.
    Soll ich da in das nächste case springen?

    switch(current_state){
                    case IDLE:      if (byte == DLE){
                                        // TODO: Sprung zum nachsten Zustand
                                        current_state =
                                        str_DEBUG("-I- Neuer Zustand: PRE_START");
                                    }
                                    //sonst bleiben wir bei IDLE und initialisieren Buffer und Zeiger
                                    msg_pointer = message;
                                    break;
                    case PRE_START: if (byte == STX){
                                        // TODO: Sprung zum nachsten Zustand
                                        current_state =
                                        str_DEBUG( "-I- Neuer Zustand: ");
                                    } else {
                                        // das DLE war ein Fehler, es wird weiter gewartet
                                        // TODO: Sprung zum nachsten Zustand
                                        current_state =
                                        str_DEBUG( "-I- Neuer Zustand: ");
                                    }
                                    break;
                    // TODO: Welcher Zustand?
                    case            if (byte == DLE){
                                        // TODO: Sprung zum nachsten Zustand
                                        current_state =
                                        str_DEBUG( "-I- Neuer Zustand: DLE_IN_MSG");
                                    } else {
                                        if(((msg_pointer - message) >= 16) && debug) {
                                            ilc_send_msg(DBG, "-E- Zuviele Bytes empfangen");
                                        }
                                        // TODO: Byte kopieren.
                                        *msg_pointer =
                                        ++msg_pointer;                             
                                    }
                                    break;
                    case DLE_IN_MSG: if(byte == ETX){
                                        // jetzt ist Schluss
                                        // TODO: Sprung zum nachsten Zustand
                                        current_state = ;
                                        str_DEBUG("-I- Neuer Zustand: FINISHED");
                                    } else {
                                        current_state = RUNNING;
                                        if (debug) {
                                            ilc_send_msg(DBG, "-I- Neuer Zustand: RUNNING");
                                            if(((msg_pointer - message) >= 16) && debug) {
                                                ilc_send_msg(DBG, "-E- Zuviele Bytes empfangen");
                                            }
                                        }
                                        // TODO: Byte kopieren.
                                        *msg_pointer =
                                        msg_pointer++;
                                        break;
                                    }
                    case FINISHED:  // Die Nachricht liegt vollständig im Buffer
                                    // Wir aktivieren die Auswertung der Daten im main-loop und gehen zurück in den Zustand IDLE
                                    current_state = IDLE;
                                    str_DEBUG("-I- Neuer Zustand: IDLE");
                                    // TODO: Daten sind vorhanden
                                    data_available =
                                    break;
                    default:        break;
                }
    

    Dann würde es ja so aussehen:

    switch(current_state){
    				case IDLE:		if (byte == DLE){
    									// TODO: Sprung zum nachsten Zustand
    									current_state = PRE_START
    									str_DEBUG("-I- Neuer Zustand: PRE_START");
    								} 
    								//sonst bleiben wir bei IDLE und initialisieren Buffer und Zeiger
    								msg_pointer = message;
    								break;
    				case PRE_START:	if (byte == STX){
    									// TODO: Sprung zum nachsten Zustand
    									current_state = //Ich kenne den Zustand nicht
    									str_DEBUG( "-I- Neuer Zustand: "); //Ich kenne den Zustand nicht
    								} else {
    									// das DLE war ein Fehler, es wird weiter gewartet
    									// TODO: Sprung zum nachsten Zustand
    									current_state = //Ich kenne den Zustand nicht
    									str_DEBUG( "-I- Neuer Zustand: "); //Ich kenne den Zustand nicht
    								}
    								break;
    				// TODO: Welcher Zustand?
    				case 			if (byte == DLE){ //Ich kenne den Zustand nicht
    									// TODO: Sprung zum nachsten Zustand
    									current_state = DLE_IN_MSG
    									str_DEBUG( "-I- Neuer Zustand: DLE_IN_MSG");
    								} else {
    									if(((msg_pointer - message) >= 16) && debug) {
    										ilc_send_msg(DBG, "-E- Zuviele Bytes empfangen");
    									}
    									// TODO: Byte kopieren. 
    									// Weiß ich nicht, wie das geht
    									*msg_pointer = 
    									++msg_pointer;								
    								}
    								break;
    				case DLE_IN_MSG: if(byte == ETX){
    									// jetzt ist Schluss
    									// TODO: Sprung zum nachsten Zustand
    									current_state = FINISHED ;
    									str_DEBUG("-I- Neuer Zustand: FINISHED");
    								} else {
    									current_state = RUNNING;
    									if (debug) {
    										ilc_send_msg(DBG, "-I- Neuer Zustand: RUNNING");
    										if(((msg_pointer - message) >= 16) && debug) {
    											ilc_send_msg(DBG, "-E- Zuviele Bytes empfangen");
    										}
    									}
    									// TODO: Byte kopieren. 
    									// weiß ich nicht, wie das geht
    									*msg_pointer = 
    									msg_pointer++;
    									break; 
    								}
    				case FINISHED:	// Die Nachricht liegt vollständig im Buffer
    								// Wir aktivieren die Auswertung der Daten im main-loop und gehen zurück in den Zustand IDLE 
    								current_state = IDLE;
    								str_DEBUG("-I- Neuer Zustand: IDLE");
    								// TODO: Daten sind vorhanden
    								data_available = true
    								break;
    				default: 		break;
    			}
    

    Dann weiß ich aber nicht, wie der dritte Zustand/case heißt, also kann ich da nicht alles richtig bearbeiten.

    Was ich auch nicht weiß, ist, wie man man ein Byte kopiert 😕

    Ich hoffe ihr könnt mir helfen,
    Pro



  • Pro schrieb:

    Ich hab den ganzen gestrigen Tag lang YoutubeTutorials geschaut, um etwas vom Quelltext zu verstehen. Nur das was ich jetzt kann, bringt mich nicht weiter.

    Erinnert sich noch jemand an die Zeit, als Anfänger sich mit Büchern eine Programmiersprache beigebracht haben?

    Videotutorials sind die Pest. Kaufe Dir ein gutes Buch und arbeite Dich durch. Alles andere bringt nichts.



  • AlterSack schrieb:

    Pro schrieb:

    Ich hab den ganzen gestrigen Tag lang YoutubeTutorials geschaut, um etwas vom Quelltext zu verstehen. Nur das was ich jetzt kann, bringt mich nicht weiter.

    Erinnert sich noch jemand an die Zeit, als Anfänger sich mit Büchern eine Programmiersprache beigebracht haben?

    Videotutorials sind die Pest. Kaufe Dir ein gutes Buch und arbeite Dich durch. Alles andere bringt nichts.

    Das denke ich mir auch sehr oft, daher +1 👍



  • Was ich auch nicht weiß, ist, wie man man ein Byte kopiert 😕

    // TODO: Byte kopieren.
    *msg_pointer = byte;
    

    So kopiert man glaube ich das gewünschte byte.

    Und sonst: da du nicht erzählt hast, wozu der code gut sein soll, kann ich dir leider nicht sagen, was der nächste zustand sein soll.

    http://www.c-plusplus.net/forum/136013



  • Ok, danke danke danke für den Tipp.
    Die Zustände hab ich mittlerweile rausgekriegt, da brauch ich keine Hilfe mehr.

    Den Rest muss ich jetzt weiter suchen, wie es geht.


Log in to reply