SOEM-sys 0.2.0

Rust FFI bindings for SOEM
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

/*
 * Licensed under the GNU General Public License version 2 with exceptions. See
 * LICENSE file in the project root for full license information
 */

#include <rt.h>
#include <sys/time.h>
#include <osal.h>

static int64_t sysfrequency;
static double qpc2usec;

#define USECS_PER_SEC     1000000

int osal_gettimeofday (struct timeval *tv, struct timezone *tz)
{
   return gettimeofday (tv, tz);
}

ec_timet osal_current_time (void)
{
   struct timeval current_time;
   ec_timet return_value;

   osal_gettimeofday (&current_time, 0);
   return_value.sec = current_time.tv_sec;
   return_value.usec = current_time.tv_usec;
   return return_value;
}

void osal_timer_start (osal_timert * self, uint32 timeout_usec)
{
   struct timeval start_time;
   struct timeval timeout;
   struct timeval stop_time;

   osal_gettimeofday (&start_time, 0);
   timeout.tv_sec = timeout_usec / USECS_PER_SEC;
   timeout.tv_usec = timeout_usec % USECS_PER_SEC;
   timeradd (&start_time, &timeout, &stop_time);

   self->stop_time.sec = stop_time.tv_sec;
   self->stop_time.usec = stop_time.tv_usec;
}

boolean osal_timer_is_expired (osal_timert * self)
{
   struct timeval current_time;
   struct timeval stop_time;
   int is_not_yet_expired;

   osal_gettimeofday (&current_time, 0);
   stop_time.tv_sec = self->stop_time.sec;
   stop_time.tv_usec = self->stop_time.usec;
   is_not_yet_expired = timercmp (&current_time, &stop_time, <);

   return is_not_yet_expired == FALSE;
}

int osal_usleep(uint32 usec)
{
   RtSleepEx (usec / 1000);
   return 1;
}

/* Mutex is not needed when running single threaded */

void osal_mtx_lock(osal_mutex_t * mtx)
{
        /* RtWaitForSingleObject((HANDLE)mtx, INFINITE); */
}

void osal_mtx_unlock(osal_mutex_t * mtx)
{
        /* RtReleaseMutex((HANDLE)mtx); */
}

int osal_mtx_lock_timeout(osal_mutex_t * mtx, uint32_t time_ms)
{
        /* return RtWaitForSingleObject((HANDLE)mtx, time_ms); */
        return 0;
}

osal_mutex_t * osal_mtx_create(void)
{
        /* return (void*)RtCreateMutex(NULL, FALSE, NULL); */
        return (void *)0;
}