C Verständnis Problem

[Alexander S. (amper)]

Hallo Zusammen ,

zuerst einmal ich verwende AVRStudio mit WINAVR.

Jetzt zu meinem Problem ,

ich gebe folgende Befehle ein :

//prototypen:

funktion1{...}
funktion2{...}
funktion3{...}
funktion4{...}
funktion5{...}

//hauptprogramm:

int main(void)
{
funktion1{...};
funktion2{...};
funktion3{...};
funktion4{...};
funktion5{...};
}

allerdings führt er in der simulation nur die erste und die letzte 
Funtion aus.

Gehe ich jetzt aber her und fasse die Funktionen 1 bis 4 zusammen zu 
FunktionX dann wird FunktionX und Funktion5 ausgeführt.
Also folgendermaßen:

//prototypen:

funktionX
{
funktion1{...};
funktion2{...};
funktion3{...};
funktion4{...};
}
funktion5{...};

//hauptprogramm:

int main(void)
{

funktionX{fn1,fn2,fn3,fn4};
funktion5{};
}

Woran liegt das , bitte versuht esso einfach wie möglich zu halten denn 
ich habe erst mit C angefangen und daher noch nicht all zu viel Ahnung.

Danke im vorraus

Alex

[Sven P. (Gast)]

Das ist kein C-Code! Hinter die Funktionen gehören allerhöchstens runde 
Klammern.

Mal davon abgesehen: Sind die Funktionen leer? Dann sind sie nämlich 
ganz schnell wegoptimiert.

[pcb (Gast)]

ich fürchte du das hast zu einfach gehalten.
Du sollst schon den originalCode lifern. Oder zumindest nicht so stark 
vereinfachten.

[Alexander S. (amper)]

hier also der funtionierende Code

/ Include Paths-------------------------------------------------
#include <stdio.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <math.h>

// Defines------------------------------------------------------
#define t_sample   16e-006
#define t_min_cyc   15.625e-009
#define t_max_cyc       32e-006
#define factor    1.15470054
#define PI          3.14159265
#define twoPI    6.28318531
#define PI_3    1.04719755

// Global Variables---------------------------------------------

short int Setpoint_Speed = 5100;
short int Cycles;
float a_speed;
float f_I;
float m ;
float Setpoint_Volt = 400.00;
float t_act = 0;
float t_sec;


//
FuctionPredefinitions--------------------------------------
void readout(void)
{
  f_I = (Setpoint_Speed/60);
  a_speed = (f_I*twoPI);
  t_sec = (PI_3/a_speed);
  Cycles = (short int)(t_sec/(t_sample*2));
  m = (Setpoint_Volt/690);
}

void vector(float a_speed, float t_sec)
{
    float ta = 0;
    float tb = 0;
    float t0 = 0;
    float t7 = 0;
    ta = factor*m*t_sample*(sin(PI_3-(a_speed*t_act)));
    tb = factor*m*t_sample*(sin(a_speed*t_act));
    t0 = t7 = (t_sample-(ta+tb))/4;

    OCR0RB = OCR1RB = OCR2RB = 1023;
    OCR0SA = 1023   - (short int)(t0/t_min_cyc);
    OCR0SB = OCR0SA + 40;
    OCR1SA = OCR0SA - (short int)(ta/t_min_cyc);
    OCR1SB = OCR1SA + 40;
    OCR2SA = OCR1SA - (short int)(tb/t_min_cyc);
    OCR2SB = OCR2SA + 40;
}


void ini_PSC(void)
{
...
}




// Main----------------------------------------------

int main(void)
{
  PLLCSR = (1<<PLLF)|(1<<PLLE)|(1<<PLOCK);
  ini_PSC();
  sei();
  readout();
  vector(a_speed, t_sec);
}

gehe ich jetz aber her und mache die Funktionen die in "readout" stehen 
als
einzel Funktionen dann funktioniert da ganze nicht.

Danke

Gruß Alex

[Karl H. (kbuchegg)]

Alexander S. wrote:

> gehe ich jetz aber her und mache die Funktionen die in "readout" stehen
> als
> einzel Funktionen dann funktioniert da ganze nicht.

Hmm. Ich sehe in readout keine Funktionsaufrufe. Da sind nur
ganz normale Anweisungen enthalten.

Daher die Gegenprobe: Kannst du den Code mal so umändern, dass
er nicht mehr funktioniert und das ebenfalls posten.

[Stefan E. (sternst)]

Bitte poste den Code, der nicht funktioniert. Wie sollen wir sonst 
herausfinden, was da schief läuft?

[Rufus Τ. F. (rufus)]

Welche "Funktionen" in Readout? Da sind keine. Poste doch mal Deine 
Version mit "Einzelfunktionen".

Zur besseren Lesbarkeit bitte den C-Quelltext zwischen
[С] und [/С] schreiben, dann wird aus


  [С]
  int funktion()
  {
    a = 1;
    return a;
  }
  [/С]

sowas:

int funktion()
{
  a = 1;
  return a;
}

[Alexander S. (amper)]

In dieser Form, überspringt er mir die Aufrüfe zwischen "sei" und 
"vector"

/ Include Paths-------------------------------------------------
#include <stdio.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <math.h>

// Defines------------------------------------------------------
#define t_sample   16e-006
#define t_min_cyc   15.625e-009
#define t_max_cyc       32e-006
#define factor    1.1547005#define PI          3.14159265
#define twoPI    6.28318531
#define PI_3    1.04719755

// Global Variables---------------------------------------------

short int Setpoint_Speed = 5100;
short int Cycles;
float a_speed;
float f_I;
float m ;
float Setpoint_Volt = 400.00;
float t_act = 0;
float t_sec;


//
FuctionPredefinitions--------------------------------------

void Current_freq(Short int Setpiont_Speed)
{
  f_I = (Setpoint_Speed/60);
{


void Angle_speed(float f_I)
{
  a_speed = (f_I*twoPI);
}


void Sectortime(float a_speed)
{
  t_sec = (PI_3/a_speed);
}


void Cycles(float t_sec)
{
  Cycles = (short int)(t_sec/(t_sample*2));
}


void Modulationindex(float Setpoint_Volt)
{
  m = (Setpoint_Volt/690);
}



void vector(float a_speed, float t_sec)
{
    float ta = 0;
    float tb = 0;
    float t0 = 0;
    float t7 = 0;
    ta = factor*m*t_sample*(sin(PI_3-(a_speed*t_act)));
    tb = factor*m*t_sample*(sin(a_speed*t_act));
    t0 = t7 = (t_sample-(ta+tb))/4;

    OCR0RB = OCR1RB = OCR2RB = 1023;
    OCR0SA = 1023   - (short int)(t0/t_min_cyc);
    OCR0SB = OCR0SA + 40;
    OCR1SA = OCR0SA - (short int)(ta/t_min_cyc);
    OCR1SB = OCR1SA + 40;
    OCR2SA = OCR1SA - (short int)(tb/t_min_cyc);
    OCR2SB = OCR2SA + 40;
}


void ini_PSC(void)
{
...
}




// Main----------------------------------------------

int main(void)
{
  PLLCSR = (1<<PLLF)|(1<<PLLE)|(1<<PLOCK);
  ini_PSC();
  sei();
  Current_freq(Setpiont_Speed);
  Angle_speed(f_I);
  Sectortime(a_speed);
  Cycles(t_sec);
  Modulationindex(Setpoint_Volt);
  vector(a_speed, t_sec);
}

[Stefan E. (sternst)]

Du hast vermutlich den Optimizer aktiviert, und der hat die Funktionen 
"geinlined".
Achte mal in der Simulation auf die globalen Variablen. Die 
entsprechenden Anweisungen werden sicher ausgeführt, aber eben nicht in 
einer separaten Funktion, sondern direkt dort, wo der Aufruf der 
Funktion steht.

[Alexander S. (amper)]

Wenn es so wäre würde er doch nicht dreimal 0000 in die OCRn-Register 
schreiben. Da er ja dann eine Berechnung durchführt, oder ist das ein 
irr glauben ?

Gruß Alex

[holger (Gast)]

float a_speed; // Globale Variable

void vector(float a_speed, ... // Parameter

Hmm, welche von den beiden nimmt der Compiler denn da ?

[Alexander S. (amper)]

Also verwendet der Complier den einfacher zu verarbeitenden wert der in 
meinem fall logischer weise di globale Variable ist !?

Gruß Alex

[Karl H. (kbuchegg)]

holger wrote:
> float a_speed; // Globale Variable
>
> void vector(float a_speed, ... // Parameter
>
> Hmm, welche von den beiden nimmt der Compiler denn da ?

Immer von innen nach aussen.
Wenn es im innersten Block keine Variable mit diesem Namen gibt,
dann wird der nächst äussere Blick untersucht, bis ganz
zum Schluß die globalen Variablen zu Zug kommen.

Allerdings ist es programmier-taktisch nicht sehr klug
funktionslokale Variablen den gleichen Namen wie globalen
Variablen zu geben. Das führt auf lange Sicht immer zu
Verwirrungen.

@Alexander:
Hast du dir die globalen Variablen schon mal angesehen?
Es gibt keinen Grund warum die Funktionen nicht aufgerufen
werden sollten, ausser der Optimizer hat sie geinlined, wie
Stefan schon angemerkt hat. Aber auch dann müssten die
globalen Variablen die richtigen Werte annehmen.


PS: Das

void Cycles(float t_sec)
{
  Cycles = (short int)(t_sec/(t_sample*2));
}

ist auch nicht sehr schlau. Gewöhn dir an, den Dingen eindeutige
Namen zu geben. Eine Funktion die Cycles heist und eine Variable
die Cycles heist ist nicht besonders schlau. Sowas führt praktisch
immer zu Misverständnissen und Verwirrungen im Laufe der Programmierung.

[Stefan E. (sternst)]

holger wrote:
> float a_speed; // Globale Variable
>
> void vector(float a_speed, ... // Parameter
>
> Hmm, welche von den beiden nimmt der Compiler denn da ?

Na, beide natürlich. ;-)

Nein, er nimmt in der Funktion natürlich den Parameter, aber der hat 
durch den Funktionsaufruf ja den Wert der globalen Variable.

[Stefan E. (sternst)]

Alexander S. wrote:
> Wenn es so wäre würde er doch nicht dreimal 0000 in die OCRn-Register
> schreiben. Da er ja dann eine Berechnung durchführt, oder ist das ein
> irr glauben ?

Wie jetzt, ist das eine theoretische Überlegung, oder werden die 
Register bei deinem Beispiel mit falschen Werten gefüllt?

[Alexander S. (amper)]

Nein, in der funktionierenden version stimmen die die Werte (bis auf 
Rundungsfehler), nur in der version die nicht funktioniert werden 0x0000 
in alle register geschrieben.
Ich bin halt davon ausgegangen, daß er die einzelfunktion nicht ausführt 
und deswegen die Nullwerte der Globalen Variablen zum multiplizieren 
verwendet.

Gruß Alex

[HildeK (Gast)]

Autor: Alexander S. (amper)
Datum: 25.04.2008 20:35
schrieb:

>void Current_freq(Short int Setpiont_Speed)
>{
>  f_I = (Setpoint_Speed/60);
>{

^^^
Eigentlich müsste das ja der Compiler schon mit Error belegen: Die 
letzte Klammer hat die falsche Richtung.
Kann es das nicht sein? Der Aufruf von Curren_freq ist der erste, der 
nicht mehr funktioniert.

Oder hast du hier nur falsch gepostet?

[Stefan E. (sternst)]

Und das ist ja wohl auch alles andere als koscher:

> #define factor    1.1547005#define PI          3.14159265

Bitte poste nochmal genau den Code, der zwar ohne Fehler compiliert, 
aber die Register falsch füllt.

[Alexander S. (amper)]

Guten morgen zusammen,

hier einmal zuesrt der code der soweit mal funktioniert.

[Alexander S. (amper)]

Sorry leute,

ich muß wohl gestern irgendwo eine fehl eingabe gemacht haben denn ich 
habe es gerade noch mal "falsch" geschrieben allerdings hat es 
funktioniert.