Daten richtig an Funktion übergeben

[Rena (Gast)]

Hallo,
ich habe ein problem bei der übergabe von einem Array. Den möchte mir in 
der Funktion send_data zunächst ausgeben lassen und dort bekomme ich 
schon eine Ausgabe, wo ich nicht weiter komme und hoffe hier auf einen 
Tip.

int main(int argc, char *argv[]){

  if(FAIL != init_uart()){
      send_data(*&argv[1], argc-1)
    }
  }
  return 0;
}

static int send_data(uint8_t buffer[], int count){
  printf("Datas to send:");
  for(uint8_t x=0; x<count; x++){
    printf(" 0x%X", strtol(buffer[x], NULL, 16));
  }
  printf("\n");
...

Wenn ich das mit gcc compilieren möchte, bekommeihc die Warnung:
passing argument 1 of 'strtol' makes pointer from integer without a cast

eingabe ist char, übergabe soll uint8_t sein. Ich möchte gerne die 
Funktion mit parametern aufrufen z.B.

./send 1A 80 90 FF

wobei 1A 80 90 FF als HEX-Werte interpretiert werden sollen.

Hat einer einen Tip wie ich das hinbekommen kann?

[Stefan F. (Gast)]

Rena schrieb:
> *&argv[1]

Was soll das denn bedeuten? Ist das überhaupt gültiges C?

Das Programm wird mit einem Array von Zeigern auf c-Strings aufgerufen. 
Die kannst du nicht einfach in 8bit Integer umwandeln, denn erstens sind 
Zeiger größer als 8bit und zweitens willst du auf die Strings zugreifen, 
nicht auf das erste Byte der Zeiger.

Eigentlich wollte ich dir einen konkreten Korrekturvorschlag machen, 
aber das ist mir nicht gelungen weil mir gar nicht klar ist, was du 
machen willst.

Du startest das Programm mit einer Reihe von zweistelligen 
Hexadezimal-zahlen (als Zeichenketten). Diese willst mit printf() 
ausgeben. Was ich nicht verstehe ist, wozu du dann noch die Umwandlung 
in Bytes und wieder zurück zu Hexadezimal machst. Das ergibt so keinen 
Sinn.

[Rena (Gast)]

Stefanus F. schrieb:
> Du startest das Programm mit einer Reihe von zweistelligen
> Hexadezimal-zahlen (als Zeichenketten). Diese willst mit printf()
> ausgeben. Was ich nicht verstehe ist, wozu du dann noch die Umwandlung
> in Bytes und wieder zurück zu Hexadezimal machst. Das ergibt so keinen
> Sinn.

Nun ja, ich möchte die Werte beim Aufrufen mit übergeben. Diese sollen 
dann als HEX-Werte interpretiert werden und in der funktion send_data 
gesendet werden.
Das printf mache ich nur, damit ich sehe, ob z.B. 1A wirklich als 0x1A 
interpretiert wird.

[Stefan F. (Gast)]

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>

void send_data(uint8_t buffer[], int count)
{
    // Print the data. TODO: Replace this code by real sending
    printf("Data to send:");
    for(uint8_t i=0; i<count; i++)
    {
      printf(" 0x%X", buffer[i]);
    }
    printf("\n");
}

int main(int argc, char *argv[])
{
    uint8_t buffer[100]; // To collect bytes from command-line arguments
    int byte_count = 0;  // Number of bytes in buffer

    // Iterate over all command-line arguments.
    // start with 1 because argument 0 is the program name.
    for (int i=1; i<argc; i++)
    {
        char* current_argument = argv[i];

        // convert string to integer
        long number = strtol(current_argument, NULL, 16);

        // Append to the buffer, assuming that the number is never > 8bit
        buffer[byte_count] = (number & 0xFF);
        byte_count++;
    }

    // Send the data
    send_data(buffer, byte_count);
    return 0;
}

Bitteschön.

[zitter_ned_aso (Gast)]

oder irgendwie so

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>

void send_data(char** buffer, int count){

    printf("Datas to send:\n");

    for(uint8_t x=0; x<count; x++){
        printf("%#lX\n", strtol(buffer[x], NULL, 16));
    }

    printf("\n");
}

int main(int argc, char* argv[]){

    send_data(argv+1, argc-1);

    return 0;
}

./program 1 20 FF
Datas to send:
0X1
0X20
0XFF

[Ralf G. (ralg)]

Rena schrieb:
> passing argument 1 of 'strtol' makes pointer from integer without a cast

long int strtol (const char* str, char** endptr, int base);

... du übergibst aber nur ein einzelnes Zeichen, welches in eine Adresse 
umgewandelt wird. Da das nur gaaanz selten so gedacht ist, gibt's die 
Warnung.