Wie bekommt man eine double Variable in ein char Array?

[Steffen H. (avrsteffen)]

Hallo,

Ich schon wieder. Wie oben schon beschrieben bekomme ich es nicht hin in 
ein char Array eine double/float Variable hineinzubringen.

Hier mal der Versuch:

static char spi_buf[32];

void sendDouble(double n )
{
   spi_buf[0] = n>>24;
   spi_buf[1] = n>>16;
   spi_buf[2] = n>>8;
   spi_buf[3] = n;
}

Was mach ich da falsch? Hat das was mit casten zu tun?

Steffen

[Andreas B. (andreasb)]

Steffen H. schrieb:

 static char spi_buf[32];
 
 void sendDouble(double n )
 {
    memcpy(spi_buf, &n, sizeof(double));
 }

So sollte es gehen...

Ansonsten dein n mal auf
char * ptr = (char*) &n;

casten, dann müsste auch
spi_buf[0] = ptr[3];

funktionieren, aber memcpy ist einfacher...


mfg Andreas

[Tom M. (tomm)]

Lass doch die libc die Arbeit machen:

#include <string.h>

...

memcpy(spi_buf, &n, sizeof(double));

Steffen H. schrieb:
> static char spi_buf[32];

Wozu 32 chars?

[Steffen H. (avrsteffen)]

Danke für die Anworten.

Mit memcpy funktioniert das auch, aber ich habe vorher noch eine 
Berechnung und will dann die berechneten double/Floats hintereinander in 
das spi_buf Array schreiben. Deswegen der gescheiterte Klimmzug über 
die Funktion sendDouble. Also ich versuchs konkreter zu erklären durch 
mehr code.

Variablen:

static char spi_buf[32];
typedef struct {
  int32_t position[3];  // Real-time machine position vector in steps.  
  uint8_t coord_select; // Active work coordinate system number.
  double coord_offset[3]; // G92 coordinate offset (work coordinates) 
} system_t;
extern system_t sys;

Hier sollen die 3 Positionsdaten in den spi_buf nacheinander gespeichert 
werden, damit sie dann per SPI (interrupted) verschickt werden können.

void send_status_report()
{
double stepper_position[3];
  memcpy(stepper_position,sys.position,sizeof(sys.position));

  sendDouble(stepper_position[X_AXIS])/(settings.steps_per_mm[X_AXIS]));
  sendDouble(stepper_position[Y_AXIS])/(settings.steps_per_mm[Y_AXIS]));
  sendDouble(stepper_position[Z_AXIS])/(settings.steps_per_mm[Z_AXIS]));
}

Hier muss dann natürlich noch der Zähler für die Position im Array mit 
der Funktion mitgeliefert und von der aufrufenden übergeben werden.

void sendDouble(double n )
{
   spi_buf[0] = n>>24;
   spi_buf[1] = n>>16;
   spi_buf[2] = n>>8;
   spi_buf[3] = n;
}

allerdings klappt es so nicht.

Tom M. schrieb:
> Wozu 32 chars?

Ist der maximal zu erwartende spi transfer.


Steffen

[Andreas B. (andreasb)]

Steffen H. schrieb:
> Ist der maximal zu erwartende spi transfer.
>
>
> Steffen

memcpy(spi_buf+pos*sizeof(double), &n, sizeof(double));

Wobei pos 0 ... sizeof(spi_buf) / sizeof(double).

Vergiss das Shiften, ist so einfacher, natürlich musst du pos 
entsprechend hochzählen bei jedem Senden.


mfg Andreas

[Steffen H. (avrsteffen)]

Andreas B. schrieb:
> Wobei pos 0 ... sizeof(spi_buf) / sizeof(double).
>
> Vergiss das Shiften, ist so einfacher, natürlich musst du pos
> entsprechend hochzählen bei jedem Senden.

Heißt das ich nach jedem Aufruf

sendDouble(stepper_position[X_AXIS])/(settings.steps_per_mm[X_AXIS]));

irgendwie Pos hochzählen muss? So etwa?

uint8_t pos=0;

sendDouble(stepper_position[X_AXIS])/(settings.steps_per_mm[X_AXIS]),pos);
pos += sizeof(double);
sendDouble(stepper_position[Y_AXIS])/(settings.steps_per_mm[X_AXIS]),pos);
..

Und in der Funktion sendDouble dann:

void sendDouble(double n, uint8_t pos)
{
memcpy(spi_buf+pos*sizeof(double), &n, sizeof(double));
}

Sollte es so gehen?

Gruß Steffen

[Karl H. (kbuchegg)]

Steffen H. schrieb:

sendDouble(stepper_position[Y_AXIS])/(settings.steps_per_mm[X_AXIS]),pos 
);
> ..
> [/c]
>
> Und in der Funktion sendDouble dann:
>

> void sendDouble(double n, uint8_t pos)
> {
> memcpy(spi_buf+pos*sizeof(double), &n, sizeof(double));
> }
>

> Sollte es so gehen?

Wenn du hier mit sizeof(double) multiplizierst, dann brauchst du pos 
aussen nicht mit sizeof(double) erhöhen. Du hast doch die Abstände schon 
in der Multiplikation berücksichtigt.

Wenn du jeweils 5 SChachteln in Folge (in einer Sequenz) aufstellst, wo 
steht dann die erste Schachtel der 6-ten Sequenz?
Die steht in der 6*5 = 30-ten Position,

sizeof liefert dir einfach nur die Größe des angegebenen in Bytes.

[Steffen H. (avrsteffen)]

Karl Heinz Buchegger schrieb:
> Wenn du hier mit sizeof(double) multiplizierst, dann brauchst du pos
> aussen nicht mit sizeof(double) erhöhen. Du hast doch die Abstände schon
> in der Multiplikation berücksichtigt.

Stimmt, so gehts natürlich auch. Hab ich ja voll übersehen. Aber pos 
muss ich außen ja trotzdem erhöhen. Dann allerdings nur um 1. (pos++;)
Würde mich jetzt mal interessieren, welche der beiden Varianten hier 
mehr Resourcen verbraucht.

Ich sehe gerade, ich hab es jetzt eh etwas anders gelöst. Aber es 
funktioniert.

void send_status_report()
{
uint8_t pos=0;
double stepper_position[3];
  memcpy(stepper_position,sys.position,sizeof(sys.position));

   sendDouble((stepper_position[X_AXIS]/(settings.steps_per_mm[X_AXIS])), pos);
   pos += sizeof(double);
   sendDouble((stepper_position[Y_AXIS]/(settings.steps_per_mm[Y_AXIS])), pos);
   pos += sizeof(double);
   sendDouble((stepper_position[Z_AXIS]/(settings.steps_per_mm[Z_AXIS])), pos);
   spi_write_data(spi_buf,11,CS_EXT);

}


void sendDouble(double n, uint8_t i )
{
char * ptr = (char*) &n;

   spi_buf[i++] = ptr[3];
   spi_buf[i++] = ptr[2];
   spi_buf[i++] = ptr[1];
   spi_buf[i++] = ptr[0];
}


// write one or multiple bytes to the Serial SPI memory
void spi_write_data(char* source, char wr_bytes, char cs_adr)
{
   spi_busy = true;
   nb_byte = wr_bytes;
   byte_cnt = 0; 
   data_ptr = source; 
   set_spi_cs(cs_adr); // Pull down the chip select line of the SPI device
   SPDR = *data_ptr;   // send the first byte        
}


// Interrupt Routine Master Mode (interrupt controlled)
ISR(SPI_STC_vect)
{
 data_ptr++;   // point to the next byte (even if it was the last) 
   
   if (byte_cnt == nb_byte )  // is the last byte sent?
    {
    PORTB &= ~(CS_MASK);
    PORTB |= CS_HI;    // Pull high the chip select line of the SPI device
    spi_busy = false;  // return to the idle state
    }
   else
    {      
     byte_cnt ++;
     SPDR = *data_ptr;
    }
}

Dank an all den freundlichen Helfern.

Gruß Steffen

[Karl H. (kbuchegg)]

Widersteh der Versuchung zu 'künsteln'. Die einfachste Variante ist die 
beste.

void send_status_report()
{
  double stepper_position[3];

  stepper_position[X_AXIS] = sys.position[X_AXIS] / settings.steps_per_mm[X_AXIS];
  stepper_position[Y_AXIS] = sys.position[Y_AXIS] / settings.steps_per_mm[Y_AXIS];
  stepper_position[Z_AXIS] = sys.position[Z_AXIS] / settings.steps_per_mm[Z_AXIS];

  memcpy( spi_buf, stepper_position, sizeof(stepper_position) );

  spi_write_data(spi_buf, 11, CS_EXT);
}

Bist du sicher, dass die 11 zum Schluss korrekt sind?
Wenn das eigentlich 12 sein sollten (wegen 3*sizeof(double) == 12), dann 
noch besser so

void send_status_report()
{
  double stepper_position[3];

  stepper_position[X_AXIS] = sys.position[X_AXIS] / settings.steps_per_mm[X_AXIS];
  stepper_position[Y_AXIS] = sys.position[Y_AXIS] / settings.steps_per_mm[Y_AXIS];
  stepper_position[Z_AXIS] = sys.position[Z_AXIS] / settings.steps_per_mm[Z_AXIS];

  spi_write_data( (unsigned char*)stepper_position, sizeof(stepper_position), CS_EXT);
}

[Steffen H. (avrsteffen)]

Karl Heinz Buchegger schrieb:
> Bist du sicher, dass die 11 zum Schluss korrekt sind?
> Wenn das eigentlich 12 sein sollten (wegen 3*sizeof(double) == 12
Ja, das ist schon richtig so. Denn in der spi_write_data wird ja schon 
1Byte an SPDR übergeben. Und somit fehlt eins zum countern in der ISR.

Danke für die Hilfe.

Steffen

[Karl H. (kbuchegg)]

Steffen H. schrieb:
> Karl Heinz Buchegger schrieb:
>> Bist du sicher, dass die 11 zum Schluss korrekt sind?
>> Wenn das eigentlich 12 sein sollten (wegen 3*sizeof(double) == 12
> Ja, das ist schon richtig so. Denn in der spi_write_data wird ja schon
> 1Byte an SPDR übergeben. Und somit fehlt eins zum countern in der ISR.

ui.
Solche Sachen sollte die spi_write_data selber regeln.
Du übergibst 12 Bytes an die Funktion. Die Funktion stellt eines in SPDR 
und 11 in einen Buffer.

Das ist das, was man erwarten würde: Ich habe 12 Bytes und das sage ich 
auch genau so der Funktion. Wie die Funktion das dann intern regelt, das 
ist Sache der Funktion - das geht mich als Aufrufer nichts an. Ich weiß 
nur, dass ich 12 Bytes auf die Reise bringen will, und das teile ich 
auch der Funktion so mit.

Sowas sind typische Stolpersteine über die du in ein paar Wochen mehr 
als einmal stolpern wirst. Gestalte Funktionalitäten nach Möglichkeit 
immer so, dass sie FÜR DEN AUFRUFER(!) logisch sind. Denn der muss damit 
klar kommen und je weniger Spezial- und Sonderfälle man beim Aufruf 
einer Funktion wissen bzw. unterscheiden muss, desto weniger läuft man 
Gefahr dabei einen Fehler zu machen. Und Fehler macht man als 
Programmierer - du genauso wie ich.

[Oliver S. (oliverso)]

Steffen H. schrieb:
> Was mach ich da falsch? Hat das was mit casten zu tun?

Um das auch noch mal aufzunehmen: Beantworte dir die Frage doch selber, 
zur Not auch mit Hilfe (d)eines C-Buches. Der Lerneffekt daraus wird 
dein Verständnis zu Datentypen in C erheblich erweitern.

Oliver

[Steffen H. (avrsteffen)]

Karl Heinz Buchegger schrieb:
> Solche Sachen sollte die spi_write_data selber regeln.
> Du übergibst 12 Bytes an die Funktion. Die Funktion stellt eines in SPDR
> und 11 in einen Buffer.

So hab ich es jetzt gemacht. War nur eine kleine Änderung in der 
spi_write_data .

  nb_byte = wr_bytes-1;

Steffen