#define PORT 5000
#define MAXLINE 1000
typedef struct {
int64_t t_imu_gps1980_system_ns; // GPS seconds in the GPS epoch
bool gyro_valid; // Gyro validity flag
double x;
double y;
double z;
} CntlOutput;
int sendUDPbytes(uint8_t* ptr, uint64_t size)
{
char buffer[100];
// char *message = "Hello Server";
// char message[sizeof(CntlOutput)];
CntlOutput message, messageBuffer;
memcpy(&messageBuffer, ptr, size);
message.t_imu_gps1980_system_ns = messageBuffer.t_imu_gps1980_system_ns;
message.gyro_valid = messageBuffer.gyro_valid;
message.x = messageBuffer.x;
message.y = messageBuffer.y;
message.z = messageBuffer.z;
char testMessage[size];
memcpy(&testMessage, ptr, size);
printf("\r\n");
for( int i = 0; i < size; i++)
{
printf("0x%X",testMessage[i]);
}
printf("\r\n");
// printf("%ld %i %lf %lf %lf\r\n",
printf("%ld %lf %lf %lf\r\n",
messageBuffer.t_imu_gps1980_system_ns,
messageBuffer.gyro_valid,
messageBuffer.x,
messageBuffer.y,
messageBuffer.z
);
int sockfd, n;
struct sockaddr_in servaddr;
(void)n;
// clear servaddr
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
servaddr.sin_port = htons(PORT);
servaddr.sin_family = AF_INET;
// create datagram socket
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
// connect to server
if(connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
{
printf("\n Error : Connect Failed \n");
exit(0);
}
// request to send datagram
// no need to specify server address in sendto
// connect stores the peers IP and port
sendto(sockfd, &message, MAXLINE, 0, (struct sockaddr*)NULL, sizeof(servaddr));
// waiting for response
recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)NULL, NULL);
puts(buffer);
// close the descriptor
close(sockfd);
return 0;
}
```
If I don’t reinterpret it it gives me:
> ERROR: LoadError: MethodError: no method matching unsafe\_convert(::Type{Ptr{UInt8}}, ::CntlOutput)
Closest candidates are:
unsafe\_convert(::Type{Ptr{UInt8}}, ::String)
@ Base pointer.jl:59
unsafe\_convert(::Type{Ptr{UInt8}}, ::Symbol)
@ Base pointer.jl:57
unsafe\_convert(::Type{Ptr{R}}, ::SubString{String}) where R\<:Union{Int8, UInt8}
@ Base strings/substring.jl:122
…
---
### Author:  [@Sukera](https://discourse.julialang.org/u/Sukera)
#### Post date: [March 19, 2024, 9:29pm UTC](https://discourse.julialang.org/t/losing-bytes-when-reinterpreting/111842/4 "2024-03-19T21:29:02Z")
Ok, I think I see the issue; there’s a few problems/misconceptions here.
1. Julia structs [match the layout of C structs](https://docs.julialang.org/en/v1/manual/calling-c-and-fortran-code/#Struct-Type-Correspondences), so there’s no need to go through `uint8_t*`. You can go through `CntlOutput*` just fine, without having to `memcpy` things around.
2. You can then call `sendUDPbytes` by passing a `foo = Ref(blah)` like `@ccall "./udpSend.so".sendUDPbytes(foo::Ptr{CntlOutput}, 1::Cint)`. If your intention is to pass a collection/an array of values to C, you can just pass that too (see [these C wrapper examples](https://docs.julialang.org/en/v1/manual/calling-c-and-fortran-code/#C-Wrapper-Examples) from the manual).
> [@ion](#):
>
> If I don’t reinterpret it it gives me:
Yes, because there’s no `cconvert` of the appropriate type defined. See e.g. [Calling C and Fortran Code · The Julia Language](https://docs.julialang.org/en/v1/manual/calling-c-and-fortran-code/#automatic-type-conversion)
EDIT: you generally don’t need to define that either, unless you have a fancier wrapper struct that doesn’t match the layout on the C side anymore (e.g. it contains `Array`s where C would have pointers… in those cases, you’ll want to have a “julia version” that you then `cconvert` to a different struct matching the C version).
---
### Author:  [@ion](https://discourse.julialang.org/u/ion)
#### Post date: [March 19, 2024, 9:42pm UTC](https://discourse.julialang.org/t/losing-bytes-when-reinterpreting/111842/5 "2024-03-19T21:42:16Z")
I changed my function signature to:
```julia
int sendUDPbytes(CntlOutput* ptr)
```
and in Julia:
```julia
ret = ccall((:sendUDPbytes, "./udpSend.so"), Cint, (foo::Ptr{CntlOutput}), blah)
```
Now I get this:
> ERROR: LoadError: syntax: ccall argument types must be a tuple; try “(T,)” around /home/ig/git/julia-test-harness/NetworkComm/cfsPacking.jl:100
---
### Author:  [@Sukera](https://discourse.julialang.org/u/Sukera)
#### Post date: [March 19, 2024, 9:45pm UTC](https://discourse.julialang.org/t/losing-bytes-when-reinterpreting/111842/6 "2024-03-19T21:45:01Z")
If you use the `ccall` version, you still need to give it the argument types seperately from the objects themselves. Only the `@ccall` macro can mix them like that. See also their respective docstrings:
[`ccall`](https://docs.julialang.org/en/v1/base/c/#ccall)
> ```julia
> ccall((function_name, library), returntype, (argtype1, ...), argvalue1, ...)
> ccall(function_name, returntype, (argtype1, ...), argvalue1, ...)
> ccall(function_pointer, returntype, (argtype1, ...), argvalue1, ...)
>
> ```
[`@ccall`](https://docs.julialang.org/en/v1/base/c/#Base.@ccall)
> ```julia
> @ccall library.function_name(argvalue1::argtype1, ...)::returntype
> @ccall function_name(argvalue1::argtype1, ...)::returntype
> @ccall $function_pointer(argvalue1::argtype1, ...)::returntype
>
> ```
Note that I used `@ccall` (the macro) above, since it makes it easier to figure out which argument will be `cconvert`ed to which type.
---
### Author:  [@ion](https://discourse.julialang.org/u/ion)
#### Post date: [March 19, 2024, 9:49pm UTC](https://discourse.julialang.org/t/losing-bytes-when-reinterpreting/111842/7 "2024-03-19T21:49:08Z")
```julia
@ccall "./udpSend.so".sendUDPbytes(foo::Ptr{CntlOutput})::Cint
```
This worked!
Thank you
---
### Author:  [@mkitti](https://discourse.julialang.org/u/mkitti)
#### Post date: [March 19, 2024, 11:09pm UTC](https://discourse.julialang.org/t/losing-bytes-when-reinterpreting/111842/8 "2024-03-19T23:09:55Z")
> [@ion](#):
>
> `(foo::Ptr{CntlOutput})`
The above is not a tuple. `(foo::Ptr{CntlOutput},)` is a tuple. You need the comma.
```julia-repl
julia> (Ptr{CtrlOutput})
Ptr{CtrlOutput}
julia> (Ptr{CtrlOutput},)
(Ptr{CtrlOutput},)
julia> (Ptr{CtrlOutput}) isa Tuple
false
julia> (Ptr{CtrlOutput},) isa Tuple
true
```