char Array erhält zufällige Werte

[Christian O. (chris_o)]

Hallo Leute,
ich bräuchte eure Hilfe!
Ich verwende MPLAB X IDE zum programmieren, da ich einen PIC 
Mikrocontroller verwende.
Ich hab mich jetzt schon länger eingearbeitet und möchte Daten von einem 
Mikrocontroller zum PC per Bluetooth schicken. Das ganze funktioniert 
soweit auch.
Mein Problem:
Ich möchte mein Programm jetzt in mehrere Source-files unterteilen. Dazu 
habe ich die einzelnen Source files und dazugehörige header-files 
angelegt.
Mein Programm arbeitet diese files auch wunderbar nacheinander ab. 
Leider hänge ich dabei noch etwas, wenn es darum geht ein char-Array zu 
übergeben.
In meiner Main baue ich mir ein char Array, dass 8 Zeichen lang ist => 
funktioniert wunderbar!
Anschließend rufe ich meine Funktion auf und möchte mein gebautes Array 
dort haben!
Ich habe mir gedacht, ich mache das folgendermaßen:
in meiner Main (die durch eine Schleife immer wieder neu abgearbeitet 
wird) rufe ich folgende Funktion auf und baue mir daraus mein Array:

int Bluetooth_send()
{
  static int laufvar = 0;
  static int sendezahl = 0;
  int Laenge = 8;
  char senden[8];
  static int sperren = 1;
 
  if (sperren == 1)        
  {
  //Byte-Array zum senden bauen
  senden[sendezahl] = 0x02;  //STX senden
  sendezahl++;
  if((data0 == 0x03) || (data0 == 0x16))  //Wenn ETX oder DLE in Nutzdaten vorkommt
  {
  senden [sendezahl] = 0x16;  //DLE einfügen
  sendezahl++;
  senden [sendezahl] = data0;
  sendezahl++;
  }
  else
  {
  senden[sendezahl] = data0;
  sendezahl++;
  }
 
  if((data1 == 0x03) || (data1 == 0x16))
  {
  senden [sendezahl] = 0x16;
  sendezahl++;
  senden [sendezahl] = data1;
  sendezahl++;
  }
  else
  {
  senden[sendezahl] = data1;
  sendezahl++;
  }
 
  if((data2 == 0x03) || (data2 == 0x16))
  {
  senden [sendezahl] = 0x16;
  sendezahl++;
  senden [sendezahl] = data2;
  sendezahl++;
  }
  else
  {
  senden[sendezahl] = data2;
  sendezahl++;
  }
 
  if((data3 == 0x03) || (data3 == 0x16))
  {
  senden [sendezahl] = 0x16;
  sendezahl++;
  senden [sendezahl] = data3;
  sendezahl++;
  }
  else
  {
  senden[sendezahl] = data3;
  sendezahl++;
  }
 
  if((din == 0x03) || (din == 0x16))
  {
  senden [sendezahl] = 0x16;
  sendezahl++;
  senden [sendezahl] = din;
  sendezahl++;
  }
  else
  {
  senden[sendezahl] = din;
  sendezahl++;
  }
 
 
  if ((laufvar == 0x03) || (laufvar == 0x16))
  {
  senden[sendezahl] = 0x16;
  sendezahl++;
  senden[sendezahl] = laufvar;  
  laufvar++;
  sendezahl++;
  }
  else
  {
  if (laufvar <=255)  //Laufvariable um Datenempfang beim Empfänger prüfen zu können
  {
  senden[sendezahl] = laufvar;  //Zählt von 0-255 und beginnt wieder bei 0
  laufvar++;
  sendezahl++;
  }
  else
  {
  senden[sendezahl] = 0;
  laufvar=1;
  sendezahl++;
  }  
  }
 
  senden[sendezahl] = 0x03;
  sendezahl = 0;
  }
  sperren = Bluetooth_Send(Laenge, senden);    // Hier wird Bluetooth_Send aufgerufen
 
  return 0;
}

Ich weiß, dass das ganze durch die DLE maskierung auch länger als 8 
werden kann (muss ich später noch ändern), aber das stört vorläufig 
nicht.

Mein Header sieht wie folgt aus:

#ifndef BLUETOOTH_H
#define   BLUETOOTH_H
 
int Bluetooth_Send(int Lang, char senden[]);
 
#endif   /* BLUETOOTH_H */

Und hier noch das Source-file:

#define FOSC (80000000ULL)
#define FCY (FOSC/2)
 
#include "C:\Program Files (x86)\Microchip\xc16\v1.25\include\lega-c\stdio.h"
#include "C:\Program Files (x86)\Microchip\xc16\v1.25\include\lega-c\stdlib.h"
#include "C:\Program Files (x86)\Microchip\xc16\v1.25\support\dsPIC33F\h\p33FJ16GS404.h"
#include "C:\Program Files (x86)\Microchip\xc16\v1.25\support\generic\h\xc.h"
#include "C:\Program Files (x86)\Microchip\xc16\v1.25\support\generic\h\libpic30.h"
#include "C:\Program Files (x86)\Microchip\xc16\v1.25\include\lega-c\time.h"
 
 
int Bluetooth_Send(int Lang,char senden[])
{
  static int i = 0;
  static int finish = 0;
 
  //Send data
  if (i <= Lang)
  {
  __delay_us(80);  //Verzögerung um Bluetoothmodul nicht zu überfordern (80µs)
  if(!IFS0bits.U1TXIF)  //Wenn Interrupt Flag nicht gesetzt
  {
  U1TXREG=senden[i];
  i++;
  }
  else
  {
  IFS0bits.U1TXIF = 0;  //Rücksetzen der Interruptflag
  }
  }
  if (i==Lang)
  {
  finish = 1;                    //erst wenn finish = 1, wird ein neues Array gebaut
  i=0;          
  }
  else
  {
  finish = 0;  
  }
 
  return (finish);
}

Mein Array sende ich über ein BLuetoothmodul, und empfange die Daten mit 
einem Terminalprogramm (Funktioniert wunderbar)
Die Daten sollen die Struktur wie folgt haben:
STX, 0x00, 0x00, 0x00, 0x00, 0x00, "Laufvariable von 0-255", ETX 
...ständig wiederholen (die Nullen werden später mit Sensordaten 
befüllt)

Mein Problem ist jetzt, dass ich am Terminalprogramm folgendes empfange:
{FF}{00}{00}{00}{88}{09}{00}{00}{FF}{00}{00}{00}{88}{09}{00}{00}...
und das ganze ständig!

Hab folgendes festgestellt:
nach dem ersten Durchlauf hab ich richtigerweise noch das STX im Array 
stehen. Im zweiten Durchlauf ist das bauen eines neuen Arrays 
gesperrt(da noch nicht alles gesendet ist). So bald ich nun wieder meine 
Funktion fürs Senden aufrufe, werden beliebige Werte in mein Array 
geschrieben. => Eben diese, die dann auch gesendet werden. Warum?
Bitte um Hilfe!

Gruß Chris

[Klaus (Gast)]

Das hat zwar mit deinem Problem nichts zu tun, deine #includes sehen mit 
den vollen Namen merkwürdig aus:

#define FCY 16000000UL
#include <xc.h>
#include <stdint.h>
#include <stdio.h>
.
.

so sieht das bei mir aus. Und p33FJ16GS404.h gehört da garnicht hin, das 
erledigt xc.h automatisch. Ich schreib auch die Config-Bits mit in den 
Source, dann kann man nichts falsch einstellen und weiß auch in paar 
Monaten noch, wie sie sein sollen.

#pragma config BWRP = OFF               // Boot Segment Write Protect (Disabled)
#pragma config BSS = OFF                // Boot segment Protect (No boot program flash segment)
.
.

MfG Klaus

[Frank M. (ukw) (Moderator)]

Christian O. schrieb:
> char senden[8];

Das ist eine sogenannte Auto-Variable. Die liegt auf dem Stack und das 
Array enthält erstmal nicht zwingend 0-Werte.

Ich verstehe Deine Logik nicht, aber ist immer gewährleistet, dass 
niemals mehr als 8 Daten da hinein gelangen? Wenn mehrere Bedingungen 
wahr sind, können die Variable sendezahl größer als 8 werden.

Beim Funktionsaufruf

        Bluetooth_Send(Laenge, senden);

gibst Du auch gar nicht "sendezahl" herunter. Sie erhält also keine 
Information, wieviele Zeichen Du mittlerweile in "senden" gesammelt hast 
und wieviele Du senden willst.

Willst Du das wirklich so? Und wenn sendezahl am Ende nur 6 ist, 
schickst Du dann noch 2 zufällige Werte aus dem Array hinterher?

[Mike B. (mike_b97)]

gibts in C/C++ nich auch sowas wie eine Case..of.. - Anweisung?
Dann kann man den ganzen if then-Block kürzen, blickt ja keiner durch da

[B. S. (bestucki)]

Hui, das sieht ja wirr aus. Ich fang einfach mal irgendwo an.

Du hast zwei Funktionen, die fast identisch heissen, das ist eher 
verwirrend (Bluetooth_send vs. Bluetooth_Send). Funktionen sollten das 
tun, was ihr Name verspricht, das ist bei mindestens einer der beiden 
nicht der Fall.

static int sendezahl = 0;

Das static kannst du dir sparen, du setzt die Variable am Ende der 
Funktion so oder so wieder auf Null.

char senden[8];

Der Inhalt des Arrays ist ersmal undefiniert. Es steht halt das drin, 
was gerade zufälligerweise dort im RAM steht. Benutze den Datentypen 
char nur, wenn du die Variable für Zeichen nutzen willst. Merke dir:
char != signed char
char != unsigned char

  senden[sendezahl] = 0x02;  //STX senden
  sendezahl++;
  if((data0 == 0x03) || (data0 == 0x16))  //Wenn ETX oder DLE in Nutzdaten vorkommt

Magic Numbers stiften eher Verwirrung. De Werte kannst du mit einem 
Makro oder einer const-Variable definieren. Benutzte aussagekräftige 
Namen.

  if (laufvar <=255)  //Laufvariable um Datenempfang beim Empfänger prüfen zu können
  {
  senden[sendezahl] = laufvar;  //Zählt von 0-255 und beginnt wieder bei 0
  laufvar++;
  sendezahl++;
  }
  else
  {
  senden[sendezahl] = 0;
  laufvar=1;
  sendezahl++;
  }
  }

Der Kommentar ist falsch. laufvar zählt von 1-256, wobei 256 abgefangen 
und die Null manuell zugewiesen wird. So wäre es übersichtlicher 
(funktioniert nur, wenn ein unsigned char 8 Bit hat):

static unsigned char laufvar = 0;
...
laufvar++; /* nutzt den Ueberlauf */
senden[sendezahl] = laufvar;
sendezahl++;

Versuche die Funktion Bluetooth_send besser zu strukturieren. Irgendwie 
werden Werte abhängig von globalen Variablen in ein Array geschrieben. 
Keiner weiss, wie viele Werte tatsätzlich geschrieben werden. Als 
Maximum habe ich 14 gezählt, dein Array hat aber die Länge 8.


Grundsätzlich habe ich deine Funktion so verstanden:
- Erzeuge ein Array aus den Werten data0, data1, data2, data3, din und 
laufvar.
- Der erste Wert im Array ist STX.
- Für alle Werte:
  - Ist der Wert gleich ETX oder DLF, schreibe DLF und anschliessend den 
Wert, ansonsten nur den Wert.
- Der letzte Wert im Array ist ETX.

Versuche identische Funktionalität in universelle Funktionen zu 
verpacken, z.B. das Schreiben der einzelnen Werte in das Array.



Was mir noch gerade aufgefallen ist:
Bluetooth_Send verarscht den Aufrufer so richtig. Es sendet nur das 
nächste Byte, nicht das gesamte Array. Das Array wird jedoch nach jedem 
Durchlauf neu berechnet, somit können wiederum andere Werte an gleicher 
Position stehen. Auch der Übergabeparameter Laenge ist immer 8, obwohl 
eine variable Anzahl an Werten ins Array geschrieben werden.


Bringe Struktur in dein Programm, so wird das nichts.


Nachtrag:
Normalerweise macht man das so:
Irgendwo werden die Daten erzeugt, die versendet werden müssen. Dann 
packt man diese in das geignete Prorotoll und schiebt diese in einen 
Sendebuffer (FIFO). Eine andere unabhängige Instanz prüft zyklisch, ob 
Daten im Buffer vorhanden sind und ob das Sendemodul verfügbar ist. 
Trifft beides zu, veranlasst die Instanz, dass das Sendemodul die Daten 
versendet.

[Christian O. (chris_o)]

Erstmal danke für eure Antworten!

Frank M. schrieb
>Ich verstehe Deine Logik nicht, aber ist immer gewährleistet, dass
>niemals mehr als 8 Daten da hinein gelangen? Wenn mehrere Bedingungen
>wahr sind, können die Variable sendezahl größer als 8 werden.

Ja es kann größer werden, dass weiß ich auch... für das Problem wollte 
ich mir eine Lösung überlegen, so bald meine Daten richtig übergeben 
werden bzw. gesendet werden => Das spielt im Moment erst mal keine Rolle 
für mein Problem

>gibst Du auch gar nicht "sendezahl" herunter. Sie erhält also keine
>Information, wieviele Zeichen Du mittlerweile in "senden" gesammelt hast
>und wieviele Du senden willst.

Ich wollte das erst mal statisch mit 8 Zeichen machen um zu überprüfen 
ob das Senden überhaupt funktioniert! Um die ganze Problematik wollte 
ich mich später kümmern!

be stucki schrieb:
>Hui, das sieht ja wirr aus. Ich fang einfach mal irgendwo an.

Ich weiß schäm! Ich werde versuchen das Programm etwas besser zu 
strukturieren und meine Namen der Funktionen anzupassen!

>Das static kannst du dir sparen, du setzt die Variable am Ende der
>Funktion so oder so wieder auf Null.

Verstanden!

>Der Inhalt des Arrays ist ersmal undefiniert. Es steht halt das drin,
>was gerade zufälligerweise dort im RAM steht. Benutze den Datentypen
>char nur, wenn du die Variable für Zeichen nutzen willst.

Das da erst mal undefiniert Dinge aus dem RAM stehen ist mir bewust. Was 
würdest du für einen Datentyp benutzen? STX DEL und ETX sind ja ASCII 
zeichen... und die hex-Werte zwischendrin kann man ja auch als Zeichen 
verstehen... ist also doch kein Problem oder?!

>Der Kommentar ist falsch. laufvar zählt von 1-256, wobei 256 abgefangen
>und die Null manuell zugewiesen wird. So wäre es übersichtlicher

Für mich war in dem Kommentar eher die Überlegung was ich am Ende raus 
bekomme... da wird der Wert von 0 auf 255 erhöht und wieder bei 0 
angefangen....gelöst ist das eben mit dem Zähler von 1-256... mal sehen 
ob ich das vllt noch anders mache! Werd mir deinen Vorschlag durch den 
Kopf gehen lassen.

>Versuche die Funktion Bluetooth_send besser zu strukturieren. Irgendwie
>werden Werte abhängig von globalen Variablen in ein Array geschrieben.
>Keiner weiss, wie viele Werte tatsätzlich geschrieben werden. Als
>Maximum habe ich 14 gezählt, dein Array hat aber die Länge 8.

Jop stimmt! Das Problem werd ich lösen, wenn meine Übergabe prinzipiell 
erst mal funktioniert! (Ob ich da eventuell ein paar Werte verliere, 
interessiert mich vorerst nicht...  ;-) )


>Grundsätzlich habe ich deine Funktion so verstanden:
>- Erzeuge ein Array aus den Werten data0, data1, data2, data3, din und
>laufvar.
>- Der erste Wert im Array ist STX.
>- Für alle Werte:
>  - Ist der Wert gleich ETX oder DLF, schreibe DLF und anschliessend den
>Wert, ansonsten nur den Wert.
>- Der letzte Wert im Array ist ETX.

Genau so soll es sein!

>Was mir noch gerade aufgefallen ist:
>Bluetooth_Send verarscht den Aufrufer so richtig. Es sendet nur das
>nächste Byte, nicht das gesamte Array. Das Array wird jedoch nach jedem
>Durchlauf neu berechnet, somit können wiederum andere Werte an gleicher
>Position stehen. Auch der Übergabeparameter Laenge ist immer 8, obwohl
>eine variable Anzahl an Werten ins Array geschrieben werden.

Ja er sendet nur das nächste Byte (ich wollte hier eine Schleife im 
Source-file vermeiden). Die Schleife habe ich in der Main, die immer 
wieder meine Sendefunktion aufruft! Das Array wird nicht nach jedem 
Aufruf neu berechnet, da ich erst wenn ich 8 Bytes gesendet habe, eine 
Freigabe zum neu berechnen erteile:
Vor dem Bauen des Arrays steht folgende Anweisung:

if (sperren == 1)

sperren schalte ich mit hilfe der Sendefunktion auf 0:

  if (i==Lang)
  {
  finish = 1;                    //erst wenn finish = 1, wird ein neues Array gebaut
  i=0;          
  }
  else
  {
  finish = 0;  
  }
 
  return (finish);

Mein Problem ist jetzt, dass beim zweiten Durchlauf (wo dann das Bauen 
des Arrays gespert ist) einfach beliebige Werte in das Array geschrieben 
werden, die dann gesendet werden....Ich verstehe nicht warum! Wenn ein 
Array einmal befüllt ist, behält er doch normalerweise die Werte oder 
nicht?

Könnte es sein, dass wegen meiner deklaration im Header das Array jedes 
mal beliebig befüllt wird bzw. einer anderen Adresse zugewiesen wird 
wenn ich die Funktion neu aufrufe?

>Normalerweise macht man das so:
>Irgendwo werden die Daten erzeugt, die versendet werden müssen. Dann
>packt man diese in das geignete Prorotoll und schiebt diese in einen
>Sendebuffer (FIFO). Eine andere unabhängige Instanz prüft zyklisch, ob
>Daten im Buffer vorhanden sind und ob das Sendemodul verfügbar ist.
>Trifft beides zu, veranlasst die Instanz, dass das Sendemodul die Daten
>versendet.

Daten erzeugen wird in einer separaten Funktion gemacht, die meine 
Eingänge auslesen. Diese werden dann in data0 etc. gespeichert. Aus 
diesen wird dann mein Array gebaut.

Das ganze möchte ich dann via UART an mein BLuetoothmodul schicken. 
Hierzu wird mein Byte durch das U1TXREG in den FIFO-Sendebuffer 
geschoben. (dieser ist maximal 4Byte lang, weshalb ich einfach jedes 
Byte extra rein packe.)

if(!IFS0bits.U1TXIF)  //Wenn Interrupt Flag nicht gesetzt

Durch diese Abfrage prüfe ich, ob das Sendemodul bereit ist, Daten zu 
senden. Die Interrupt Flag muss ich dann manuell wieder rücksetzen um 
senden zu können.

Das ist doch also in etwa das, was du gemeint hast oder?

Aber wie gesagt, mein Problem ist ja aktuell ein anderes!


"Mein Problem ist jetzt, dass beim zweiten Durchlauf (wo dann das Bauen 
des Arrays gespert ist) einfach beliebige Werte in das Array geschrieben 
werden, die dann gesendet werden....Ich verstehe nicht warum! Wenn ein 
Array einmal befüllt ist, behält er doch normalerweise die Werte oder 
nicht?

Könnte es sein, dass wegen meiner deklaration im Header das Array jedes 
mal beliebig befüllt wird bzw. einer anderen Adresse zugewiesen wird 
wenn ich die Funktion neu aufrufe?"

[B. S. (bestucki)]

Christian O. schrieb:
> Mein Problem ist jetzt, dass beim zweiten Durchlauf (wo dann das Bauen
> des Arrays gespert ist) einfach beliebige Werte in das Array geschrieben
> werden, die dann gesendet werden....Ich verstehe nicht warum! Wenn ein
> Array einmal befüllt ist, behält er doch normalerweise die Werte oder
> nicht?

Dann musst du das Array als static definieren, so wie du es bei anderen 
Variablen tust. Ansonsten wird das Array bei jedem Funktionsaufruf mit 
"zufälligen" Werten gefüllt.

[Frank M. (ukw) (Moderator)]

Christian O. schrieb:
> Könnte es sein, dass wegen meiner deklaration im Header das Array jedes
> mal beliebig befüllt wird bzw. einer anderen Adresse zugewiesen wird
> wenn ich die Funktion neu aufrufe?"

Ja, natürlich.

Entweder Du machst das Array static statt wie jetzt implizit auto, oder 
Du initialisierst es zunächst mit 8 Nullen.

[B. S. (bestucki)]

Christian O. schrieb:
> Was
> würdest du für einen Datentyp benutzen? STX DEL und ETX sind ja ASCII
> zeichen... und die hex-Werte zwischendrin kann man ja auch als Zeichen
> verstehen... ist also doch kein Problem oder?!

Wenns ASCII-Zeichen sind, ist char ok. Sonderzeichen würde ich jedoch 
zur besseren Lesbarkeit des Codes als Makro hinschreiben:

#define ASCII_STX 0x02
// usw...

Christian O. schrieb:
> Jop stimmt! Das Problem werd ich lösen, wenn meine Übergabe prinzipiell
> erst mal funktioniert! (Ob ich da eventuell ein paar Werte verliere,
> interessiert mich vorerst nicht...  ;-) )

Das macht man schon grundsätzlich so, wie du das gemacht hast: Übergabe 
eines Zeigers + Länge. Andererseits ist dein Array mit ETX terminiert 
(wie ein String mit '\0'), dann kannst du dir die Längenangabe sparen. 
Kann jedoch auch Verwirrung stiften, da ein char-Array normalerweise für 
Strings verwendet wird. Also evt. doch noch die '\0' am Schluss 
spenieren. Eigentlich ist es ja auch nichts anderes als ein String.

[Christian O. (chris_o)]

Ok, Danke für die hinweise...

Werd das morgen gleich mal ausprobieren...

[Christian O. (chris_o)]

Hi,

static hat geklappt! Danke