Hello. How can I measure the length of an indefinite length "uint8_t"? I used sizeof() but it didn't measure correctly

[ZKURT.1]

[Guillaume K]

In your function you are declaring an argument "uint8_t buffer". So that's normal sizeof(buffer) is 1.

Either you declare a pointer to uint8_t as parameter to your function. In that case it's not possible to know the size of the buffer.

Or you declare "uint8_t buffer[1000]" as parameter to your function. You can have correct value for sizeof(buffer). But it will be always 1000 bytes length.

[Andrew Neil]

@Guillaume K​ "declare "uint8_t buffer[1000]" as parameter to your function"

That would still only pass a pointer to the 1st byte of the array; not the size of the whole buffer, and certainly not the used size within the buffer.

[ZKURT.1]

I will enter the buffer information from the user. For example, it can enter 500 bytes of information. I need to know the length. Do you think there is a way to do this?

[Andrew Neil]

@ZAHİDE ZEYNEP KURT​ "I will enter the buffer information from the user."

Does that mean it's text entry?

If so, you could make it a string - and then use strlen()...

Or, presumably, you know when the user has finished entering data - so you have the length at that point? As others have said, pass this length to your function.

This is standard C stuff - not specific to STM32.

[Javier1]

the int buffer argment should be a pointer probably.

for the sizeof() add another argument to your function called size and when you call the function do (.....,sizeof(buffer))

[Tesla DeLorean]

The size​ information doesn't follow the pointer.

​

Y​ou need to use a pointer, not an individual byte, and you need to pass size information via a secondary parameter.

[ZKURT.1]

should i use the pointer as below?

uint8_t buffer[1000]={

6.4,0,7,7,1,7,6,5,3,1,3,3,0,6,2,4,9,1,9,2,2,5,1,1, 9.6,7,4,4,2,6,5,7,4,7,4,2,3,5,5,3,4,9,1,9,4,9,3,4,

9.6,9,8,3,5,2,0,3,1,2,7,7,4,5,0,6,3,2,6,2,3,9,5,7, 8,3,1,8,0,1,6,9,8,4,8,0,1,8,6,9,4,7,8,8,5,1,8,4,3,

8,5,8,6,1,5,6,0,7,8,9,1,1,2,9,4,9,4,9,5,4,5,9,5,0, 1,7,3,7,9,5,8,3,3,1,9,5,2,8,5,3,2,0,8,8,0.5,5,1,1,

1,2,5,4,0,6,9,8,7,4,7,1,5,8,5,2,3,8,6,3,0.5,0,7,1, 5,6,9,3,2,9,0,9,6,3,2,9,5,2,2,7,4,4,3,0,4,3,5,7,

6,6,8,9,6,6,4,8,9,5,0,4,4,5,2,4,4,5,2,3,1,6,1,7,3, 1,8,5,6,4,0,3,0,9,8,7,1,1,1,2,1,7,2,2,3,8,3,1,1,3,

6,2,2,2,9,8,9,3,4,2,3,3,8,0,3,0,8,1,3,5,3,3,6,2.7, 6,6,1,4,2,8,2,8,0,6,4,4,4,8,6,6,4,5,2,3,8,7,4,9,

3,0,3,5,8,9,0,7,2,9,6,2,9,0,4,9,1,5,6,0,4,4,0,7,7, 2,3,9,0,7,1,3,8,1,0,5,1,5,8,5,9,3,0,7,9,6,0,8,6,6,

7,0,1,7,2,4,2,7,1,2,1,8,8,3,9,9,8,7,9,7,9,0,8,7,9, 2,2,7,4,9,2,1,9,0,1,6,9,9,7,2,0.8,8,8,0,9,3,7,7,6,

6.5,7,2,7,3,3,3,0,0,1,0,5,3,3,6,7,8,8,1,2,2,0,2,3, 5,4,2,1,8,0,9,7,5,1,2,5,4,5,4,0.5,9,4,7,5,2,2,4,3,

5,2,5,8,4,9,0,7,7,1,1,6,7,0.5,5,6,0,1,3,6,0,4,8,3, 9,5,8,6,4,4,6,7,0,6,3,2,4,4,1,5,7,2,2,1,5,5,3,9,7,

5,3,6,9,7,8,1,7,9,7,7,8,4,6,1,7,4,0,6,4,9,5,5,1.4, 9.2,9,0,8,6,2,5,6,9,3,2,1,9,7,8,4,6,8,6,2,2,4,8.2,

8,3,9,7,2,2,4,1,3,7,5,6,5,7,0.5,6,0.5,7,4,9,0,2,6, 1.4,0,7,9,7,2,9,6,8,6.5,2,4,1,4,5,3,5,1,0,0.4,7,4,

8.2,1,6,6,3,7,0,4,8,4,4,0,3,1,3,9,8,9,0,0,0,8,8,9, 5,2,4,3,4,5,0,6,5,8,5,4,1,2,2,7,5,8,8,6,6,6,8,8,1,

1,6,4,2,7,1,7,1,4,7,9,9,2,4,4,4,2,9,2,8,2,3,0,8,6, 3,4,6,5,6,7,4,8,1,3,9,1,9,1,2,3,1,6,2,8,2,4,5,8,6,

1,7,8,6,6,4,5,8,3,5,9,1,2,4,5,6,6,5,2,9,4,7,6,5,4, 5,6,8,2,8,4,8,9,1,2,8,8,3,1,4,2,6,0,7,6,9,0,0,4.2,

2,4,2,1,9,0,2,2,6,7,1,0,5,6,2,6,3,2,1,1,1,1,0,0, 9.3,7,0.5,4,4,2,1,7,5,0,6,9,4,1,6,5,8,9,6,0,4,0,8,

0.7,1,9,8,4,0,3,8,5,0,9,6,2,4,5,5,4.4,4,3,6,2,9,8, 1,2,3,0,9,8,7,8,7,9,9,2,7,2,4,4,2,8,4,9,0,9,1,8,8,

8,4,5,8,0,1,5,6,1,6,6,0,9,7,9,1,9,1,3,3,8,7,5,4,9, 9.2,0,0.5,2,4,0,6,3,6,8,9,9,1,2,5,6,0,7,1,7,6,0,6,

0.5,8,8,6,1,1,6,4,6,7,1,0,9,4,0.5,0,7,7,5,4,1,0,0, 2,2,5,6,9,8,3,1,5,5,2,0,0,0.5,5,9,3,5,7,2,9,7,2,5,

7,1,6,3,6,2,6,9,5,6,1,8,8,2,6,7,0,4,2,8,2,5,2,4,8, 3.6,0,0,8,2,3,2,5,7,5,3,0,4,2,0,7,5,2,9,6,3,4,5,0,

};

char *bufferp = &buffer;

int length=sizeof(*bufferp);

printf("buffer total: %c\r\n",*bufferp);

printf("length: %d", length);

[Andrew Neil]

"uint8_t buffer[1000]={"

You have the size of the buffer right there!

Why not just do:

#define BUFFER_LENGTH 1000
uint8_t buffer[BUFFER_LENGTH ] = {

Then you have BUFFER_LENGTH available to be used wherever you need it!

[Javier1]

then you cannot use buffers that are not 1000 long in that foo() function.

[ZKURT.1]

#define ElemanSayisi 1000

uint8_t buffer[ElemanSayisi] =

{ 6, 4, 0, 7, 7, 1, 7, 6, 5, 3, 1, 3, 3, 0, 6, 2, 4, 9, 1, 9, 2, 2, 5,

1, 1, 9, 6, 7, 4, 4, 2, 6, 5, 7, 4, 7, 4, 2, 3, 5, 5, 3, 4, 9,

1, 9, 4, 9, 3, 4, 9, 6, 9, 8, 3, 5, 2, 0, 3, 1, 2, 7, 7, 4, 5,

0, 6, 3, 2, 6, 2, 3, 9, 5, 7, 8, 3, 1, 8, 0, 1, 6, 9, 8, 4, 8,

0, 1, 8, 6, 9, 4, 7, 8, 8, 5, 1, 8, 4, 3, 8, 5, 8, 6, 1, 5, 6,

0, 7, 8, 9, 1, 1, 2, 9, 4, 9, 4, 9, 5, 4, 5, 9, 5, 0, 1, 7, 3,

7, 9, 5, 8, 3, 3, 1, 9, 5, 2, 8, 5, 3, 2, 0, 8, 8, 0, 5, 5, 1,

1, 1, 2, 5, 4, 0, 6, 9, 8, 7, 4, 7, 1, 5, 8, 5, 2, 3, 8, 6, 3,

0, 5, 0, 7, 1, 5, 6, 9, 3, 2, 9, 0, 9, 6, 3, 2, 9, 5, 2, 2, 7,

4, 4, 3, 0, 4, 3, 5, 5, 7, 6, 6, 8, 9, 6, 6, 4, 8, 9, 5, 0, 4,

4, 5, 2, 4, 4, 5, 2, 3, 1, 6, 1, 7, 3, 1, 8, 5, 6, 4, 0, 3, 0,

9, 8, 7, 1, 1, 1, 2, 1, 7, 2, 2, 3, 8, 3, 1, 1, 3, 6, 2, 2, 2,

9, 8, 9, 3, 4, 2, 3, 3, 8, 0, 3, 0, 8, 1, 3, 5, 3, 3, 6, 2, 7,

6, 6, 1, 4, 2, 8, 2, 8, 0, 6, 4, 4, 4, 4, 8, 6, 6, 4, 5, 2, 3,

8, 7, 4, 9, 3, 0, 3, 5, 8, 9, 0, 7, 2, 9, 6, 2, 9, 0, 4, 9, 1,

5, 6, 0, 4, 4, 0, 7, 7, 2, 3, 9, 0, 7, 1, 3, 8, 1, 0, 5, 1, 5,

8, 5, 9, 3, 0, 7, 9, 6, 0, 8, 6, 6, 7, 0, 1, 7, 2, 4, 2, 7, 1,

2, 1, 8, 8, 3, 9, 9, 8, 7, 9, 7, 9, 0, 8, 7, 9, 2, 2, 7, 4, 9,

2, 1, 9, 0, 1, 6, 9, 9, 7, 2, 0, 8, 8, 8, 0, 9, 3, 7, 7, 6, 6,

5, 7, 2, 7, 3, 3, 3, 0, 0, 1, 0, 5, 3, 3, 6, 7, 8, 8, 1, 2, 2,

0, 2, 3, 5, 4, 2, 1, 8, 0, 9, 7, 5, 1, 2, 5, 4, 5, 4, 0, 5, 9,

4, 7, 5, 2, 2, 4, 3, 5, 2, 5, 8, 4, 9, 0, 7, 7, 1, 1, 6, 7, 0,

5, 5, 6, 0, 1, 3, 6, 0, 4, 8, 3, 9, 5, 8, 6, 4, 4, 6, 7, 0, 6,

3, 2, 4, 4, 1, 5, 7, 2, 2, 1, 5, 5, 3, 9, 7, 5, 3, 6, 9, 7, 8,

1, 7, 9, 7, 7, 8, 4, 6, 1, 7, 4, 0, 6, 4, 9, 5, 5, 1, 4, 9, 2,

9, 0, 8, 6, 2, 5, 6, 9, 3, 2, 1, 9, 7, 8, 4, 6, 8, 6, 2, 2, 4,

8, 2, 8, 3, 9, 7, 2, 2, 4, 1, 3, 7, 5, 6, 5, 7, 0, 5, 6, 0, 5,

7, 4, 9, 0, 2, 6, 1, 4, 0, 7, 9, 7, 2, 9, 6, 8, 6, 5, 2, 4, 1,

4, 5, 3, 5, 1, 0, 0, 4, 7, 4, 8, 2, 1, 6, 6, 3, 7, 0, 4, 8, 4,

4, 0, 3, 1, 3, 9, 8, 9, 0, 0, 0, 8, 8, 9, 5, 2, 4, 3, 4, 5, 0,

6, 5, 8, 5, 4, 1, 2, 2, 7, 5, 8, 8, 6, 6, 6, 8, 8, 1, 1, 6, 4,

2, 7, 1, 7, 1, 4, 7, 9, 9, 2, 4, 4, 4, 2, 9, 2, 8, 2, 3, 0, 8,

6, 3, 4, 6, 5, 6, 7, 4, 8, 1, 3, 9, 1, 9, 1, 2, 3, 1, 6, 2, 8,

2, 4, 5, 8, 6, 1, 7, 8, 6, 6, 4, 5, 8, 3, 5, 9, 1, 2, 4, 5, 6,

6, 5, 2, 9, 4, 7, 6, 5, 4, 5, 6, 8, 2, 8, 4, 8, 9, 1, 2, 8, 8,

3, 1, 4, 2, 6, 0, 7, 6, 9, 0, 0, 4, 2, 2, 4, 2, 1, 9, 0, 2, 2,

6, 7, 1, 0, 5, 5, 6, 2, 6, 3, 2, 1, 1, 1, 1, 1, 0, 9, 3, 7, 0,

5, 4, 4, 2, 1, 7, 5, 0, 6, 9, 4, 1, 6, 5, 8, 9, 6, 0, 4, 0, 8,

0, 7, 1, 9, 8, 4, 0, 3, 8, 5, 0, 9, 6, 2, 4, 5, 5, 4, 4, 4, 3,

6, 2, 9, 8, 1, 2, 3, 0, 9, 8, 7, 8, 7, 9, 9, 2, 7, 2, 4, 4, 2,

8, 4, 9, 0, 9, 1, 8, 8, 8, 4, 5, 8, 0, 1, 5, 6, 1, 6, 6, 0, 9,

7, 9, 1, 9, 1, 3, 3, 8, 7, 5, 4, 9, 9, 2, 0, 0, 5, 2, 4, 0, 6,

3, 6, 8, 9, 9, 1, 2, 5, 6, 0, 7, 1, 7, 6, 0, 6, 0, 5, 8, 8, 6,

1, 1, 6, 4, 6, 7, 1, 0, 9, 4, 0, 5, 0, 7, 7, 5, 4, 1, 0, 0, 2,

2, 5, 6, 9, 8, 3, 1, 5, 5, 2, 0, 0, 0, 5, 5, 9, 3, 5, 7, 2, 9,

7, 2, 5, 7, 1, 6, 3, 6, 2, 6, 9, 5, 6, 1, 8, 8, 2, 6, 7, 0, 4,

2, 8, 2, 5, 2, 4, 8, 3, 6, 0, 0, 8, 2, 3, 2, 5, 7, 5, 3, 0, 4,

2, 0, 7, 5, 2, 9, 6, 3, 4, 5, 0, };

uint8_t *arr = (uint8_t*) &buffer; 

int ***(uint8_t *arr, int x) {

}

It's done this way.

[Andrew Neil]

 

Note that it's conventional to use ALL UPPERCASE for #defined names - to distinguish them from variables (or functions).

uint8_t *arr = (uint8_t*) &buffer;

Your pointer arr is redundant here - why not just use buffer direct?

If your issue is now resolved, please mark the solution: