Problem mit Funktion: Pointer falsche Arraygröße

value ist nur ein Pointer (Adresszeiger) und auf einem AVR 2 Byte groß.

Beschreib mal genauer was du fabrizieren willst.
Das sind mir sehr nach Zeichenketten aus.
Allerdings musst du beim "Anhängen" von Zeichen sicherstellen, das der 
Speicherplatz nach dem String noch frei ist, sonst gibt es böse 
Laufzeitfehler.
:-)

2 Möglichkeiten:

1. die Länge des Feldes als PArameter mitübergeben

2. die übergebene Zeichenkette mit einem Nullbyte terminieren, um in der 
Funktion die Länge ermitteln zu können.

Was davon besser ist, darfst du entscheiden :-)

dann schreib doch auch

1

  kommando[0] = 'O'; 

2

  kommando[1] = 'v'; 

3

  kommando[2] = 's'; 

4

  kommando[3] = '('; 

5

  kommando[4] = objectnumber;

6

  kommando[5] = ')';

sizeof wird zu gern verwendet .. ist aber ein präprozessoraufruf ..
nachem kompilieren is das wech ..
bzw stehen da zahlen ..

anhand des pointers bekommst du die länge nicht raus ...

dynamischer speicherbereich ist schön .. auf einem AVR ist so ein 
aufwnad meist aber eher negaiv ..
warum nicht e8infach ein festes array ...
die 10 byte für das array auf dem stack machen den kohl nicht fetter

Die Ursache liegt in der Dir fehlenden Differenzierung zwischen Vektor 
und Zeiger. Ihr ist in K&R, ein ganzes Kapitel gewidmet, das Du mal 
lesen solltest, ebenso wie die Beschreibung von sizeof dort.

In main ist lengthvalue ein Vektor, was als Argument von sizeof eben die 
definierte Länge des Vektors ergibt. In der Funktion allerdings hast Du 
aus dem Vektor einen Zeiger auf char gemacht, dessen Grösse sizeof 
korrekt als Grösse des Zeigers angibt, nicht des Vektors. Die 
Information, ob und wieviele chars denn auf den ersten folgen, ist 
verlorengegangen.

sizeof, angewendet auf Vektoren, wertet zur Compile-Zeit, nur die 
definierten Längen dieser Vektoren aus, also die in der eckigen Klammer 
ausdrücklich angegebene Länge.

Es ist, nach oberflächlichem Studium, verführerisch, anzunehmen, das 
sizeof ein bequemer Ersatz für strlen ist, mit dem man zur Compile-Zeit 
sowohl Vektor- als auch String-Längen ermitteln kann, weil zwischen 
diesen kein wesentlicher Unterschied zu bestehen scheint. Dem ist aber 
nicht grundsätzlich so.
Das gilt auch, obwohl einige Unterschiede nur deswegen gültig zu sein 
scheinen, weil sie definiert worden sind, aber intuitiv kein 
funktionaler Grund zur Definition dieses Unterschieds vorzuliegen 
scheint.

So könnte man unterstellen, das der Compiler wissen müsste, das ein 
Zeiger auf einen Vektor auf einen Speicherbereich mit der Länge des 
ursprünglichen Vektors verweist. Aber dann bliebe die Frage, wie man mit 
sizeof die Länge eines Zeigers auf einen String ermittelt, bzw. eine 
Ungleicheit in der Behandlung von Zeigern auf Vektoren im Gegensatz zu 
andere Typen.
So aber, in dem man die einmal festgesetzte Unterscheidung zwischen 
Vektor und String-Array auch im Zusammenhang mit sizeof bzw. der 
Typumwandlung zwischen beiden, beibehält, bleibt man konsistent.

Es gibt andererseits gewisse syntaktische Übereinstimmungen in der 
Benutzung von Vektoren und Zeigern, die einen irreführen können.

Na, das hast Du jetzt ja hinter Dir. ;-)

..ich war mal so frei und hab Dein Programmstück etwas umgebaut - etwas 
kürzer und wesentlich leichter lesbar. Und weniger unnötiges rumkopiere 
:-) Funktioniert aber nur, wenn Du wirklich ∗Strings∗ verschicken willst 
(falls nicht musst Du einen expliziten Längenparameter mitziehen und die 
Schleifenbedingung in der while-Schleife adäquat anpassen). Ich hoffe 
ich habe die Semantik erhalten..

Der Einfachheit halber hab ich die transmit-Funktionen zu einer 
zusammengefasst.

1

$ cat main.c 

2

#include <stdio.h>

3

#include <string.h>

4

5

void transmit(char x)

6

{

7

        printf("%c", x);

8

}

9

10

void SIMKNX_wert_setzen(char objectnumber, char* value)

11

{

12

        char kommando[] = "ovs( )";

13

        kommando[4] = objectnumber;

14

        transmit('0' +strlen(kommando));

15

        transmit('\n');

16

17

        for (int i = 0; i < strlen(kommando); i++)

18

        {

19

                transmit(kommando[i]);

20

        }

21

22

        char* p = value;

23

        while (*p)

24

                transmit(*p++);

25

}

26

27

28

int main()

29

{

30

        SIMKNX_wert_setzen('1', "Hallo Welt!\n");

31

}

32

$ gcc -Wall -std=c99 -o main main.c

33

$ ./main 

34

6

35

ovs(1) Hallo Welt!

> lengthvalue[3] = (value%2);  //Nachkommastelle
[..]
> Aber in lengthvalue[3] steht 1 obwohl eigentlich 5 drinnen stehen
> sollte.

Modulo n (n>1) kann nur Werte 0..(n-1) ergeben. Für n=2 liegt 5 
definitiv nicht in jenem Bereich :-)

> 155 / 2 = 77,5 deswegen soll da 5 stehen

lengthvalue[3] = (value %2) *5;