Probleme beim Dateneinlesen

[XC866 (Gast)]

Hallo zusammen
Ich habe hier schon einmal geschrieben und war dankbar für die Hilfe.
Ich habe aber immernoch Probleme mit dem einlesen von Daten über den 
UART.
Ich benütze das StarterKit von Infineon mit dem XC866.
Das gemeine ist bei der Simulation funktioniert alles. Ich beschäftige 
mich jetzt mit diesem Problemm schon seit einer Woche, ich komme aber 
irgendwie nocht vom Fleck.
Ich poste hier einmal den Code. Vieleicht erkennt jemand auf anhieb 
einen Fehler.
Initialisiert habe ich das ganze mit DaVE.
Gruss
Matthias

Code:
//********************************************************************** 
**
//********************************************************************** 
**
//********************************Tariersystem************************** 
**
//********************************************************************** 
**
//********************************************************************** 
**


#include "MAIN.H"
#include <stdio.h>
#include <math.h>


void MAIN_vInit(void)
{

  ///  Initialization of module 'GPIO'
  IO_vInit();

  ///  Initialization of module 'UART (Serial Interface)'
  UART_vInit();

   ///  Initialization of module "ADC"
  ADC_vInit();

  //Timer 2 Initialisieren
  T2_vInit();

  //   Interrupt Priority

  IP            =  0x20;         // load Interrupt Priority Register  // 
Priorität von T2
  IPH           =  0x20;         // load Interrupt Priority High 
Register// höher als von UART
  IP1           =  0x00;         // load Interrupt Priority 1 Register
  IPH1          =  0x00;         // load Interrupt Priority 1 High 
Register

EA          =  1;              //Interupt einschalten
ET2      =  1;
ES      =  1;
}

//***********Variablen definieren**********************************

float winkel;
float winkel_print;
float x  ;
float y  ;
float esum ;
float Ausgabe_Stellgroesse ;
float e;
float Ta;
float w = 0;

unsigned int Reload_Wert;
unsigned int xx;


int result;
int Kp;
int Ki;
int Frequenz;
int Ua;
int Empfangen ;

char print_zaehler;
//****************Hauptprogramm***************************************** 
*

void main(void)
{


 MAIN_vInit();
    TR2 = 1;    //Timer2 einschalten
    TI = 1;     // Senden ermöglichen
//********AD-Wandler*********************************************
    while(1)
  {
  ADC_PAGE = 0x06;
  ADC_CRCR1 |= 0x40;  //  write channel information to be converted
  ADC_CRMR1 |= 0x40;   //  generate load event

  while(ADC_bBusy());  //  warten bis Wandlung komplett

  ADC_PAGE = 0x02;
    {
    result = ADC_RESR2H; //Das 8-Bit resultat wird gelesen
  }
  PORT_PAGE = 0x00;
  P3_DATA  = result ; //  Port3 als Visualisierungsausgang benützen
//************Winkelberechnen************************************

winkel = ((result/51.2 - 2.5)/4);
winkel = asin(winkel);
winkel *= 180;
x = winkel;
winkel_print = winkel;
winkel_print =winkel_print+50.0;


print_zaehler++;

if(print_zaehler >= 5)  {
printf (" %.2f ",winkel_print);
print_zaehler =0;
  }

//********************************************Motorendanschlag********** 
***********************
  /*
if (winkel ==0) {          // zaehler reseten
zaehler = 0;
  }

if ((zaehler >=1000)||(zaehler <=-1000))
  {TR2=0;}
else
  {TR2=1;}

  */
//****************Motoransteuerung*********************************


if (winkel>w)    //Motordrehrichtung festlegen
           {P04 = 0;}     //Gewicht nach rechts
  else      //Motordrehrichtung festlegen
           {P04 = 1;}    //Gewicht nach links



if ((winkel>(w-4))&& (winkel <(w+4))){   // Halbschrittmodus einschalten
  P03 = 1;
    }
  else {
  P03 = 0;}



if ((winkel >(w-0.4))&&(winkel<(w+0.4))){
P02=0;
  else {
P02=1;
  }

//printf (" %i\t",zaehler);

//*****************PI Regler***********************************
  w = Empfangen ;
//  w = 0.0 ;
  Kp = 20.0 ;
  Ki = 40.0 ;
  Ta = 0.01;

e = w - x;          // Vergleich   w = Sollwert        x = Istwert
esum = esum + e;      // Integration I - Anteil
if ( esum < -400) {esum = -400;}    // Begrenzung I - Anteil
if (esum > 400) {esum = 400;}
y = Kp * e + Ki  Ta  esum ;  // Reglergleichung
if (y < -280) {y = -280;}    // Begrenung Stellgrösse
if (y > 280) {y = 280;}

Ausgabe_Stellgroesse = y;    // Übergabe der Stellgrösse



//*************Reload Wert ermitteln*********************

Ausgabe_Stellgroesse= abs(Ausgabe_Stellgroesse);
xx=1668750 / (Ausgabe_Stellgroesse) ;
Reload_Wert = (65535 - xx)/(pow(2,8));  //Reload Wert High

//***************Empfangen******************************

while(RI == 1)          // Warten bis Zeichen im Interrupt anliegt
        {
scanf("%2i",&Empfangen);  // dann mit Nicht-Interrupt-Funktion klauen
//printf (" %1i ",Empfangen);
RI =0;

     }


  }
  }

[Ralph (Gast)]

Mit dem Code ist nicht alles erkennabr, poste bitte auch mal die anderen 
Files, und wenn es geht auch das DAVE File mit dem du den Code erzeugt 
hast.
Am besten vielleicht als ZIP File.

Andere Frage; Warum benutzt du FLOAT, der µC hat keine FPU.
Also wird in der LIB alles auf INT umgerechnet. Der Nachteil ist das du 
dann keinen Einfluß auf die Skalierungen hast, und die Genauigkeit der 
Berechnung nicht kennst.
Es wäre günstiger wenn du die Skalierung, mit der von dir benötigten 
Genauigkeit, auf INT selbst machst und die Berechnungen mit INT machen 
lässt.
Das hätte den Vorteil das du die Genauigkeit der Berechnung kennst, und 
das die Berechnungszeit kalkuierbar ist, du kennst ja die Befehle die 
ausgeführt werden.



Ralph

[XC866 (Gast)]

Hallo Raplph

Danke das du mir geantwortet hast.
In einem anderen Beispielprogramm habe ich es jetzt geschaft einen Wert 
einzulesen und dann wieder auszulesen.
Ich werde es jetzt dann auch mit diesem Programm versuchen.
Bis jetzt habe ich die Variable z.B. so definiert (char sagen).
Neu habe ich es so versucht: #define BUFFER 10
char sagen [BUFFER];
so hat es im Beispielprogramm funktioniert.

Ich bin nicht sicher, vieleicht haben sich verschiedene Werte 
überschrieben.

Gruss
Matthias

[Ralph (Gast)]

Hallo Matthias

Achte mal auf dem Rambedarf, du solltes bei diesem µC unter 115 Byte 
IDATA bleiben.
Wenn du mehr benötigst bekommst du Probleme mit dem Stack und den 
internen Registern. Verlagere dann mehr in das XDATA ram.

Gruß
Ralph