1

/**

     2

 * Linux specific code

     3

 **/

     4

     5

#include <stdio.h>

     6

#include <string.h>

     7

#include <time.h>

     8

#include <signal.h>

     9

#include <stdlib.h>

    10

#include <sys/mman.h>

    11

    12

#include <native/task.h>

    13

#include <native/timer.h>

    14

#include <native/mutex.h>

    15

#include <native/sem.h>

    16

    17

unsigned int PLC_state = 0;

    18

#define PLC_STATE_TASK_CREATED                  1

    19

#define PLC_STATE_PYTHON_MUTEX_CREATED          2

    20

#define PLC_STATE_PYTHON_WAIT_SEM_CREATED       4

    21

#define PLC_STATE_DEBUG_MUTEX_CREATED           8

    22

#define PLC_STATE_DEBUG_WAIT_SEM_CREATED       16

    23

    24

/* provided by POUS.C */

    25

extern int common_ticktime__;

    26

    27

long AtomicCompareExchange(long* atomicvar,long compared, long exchange)

    28

{

    29

    return __sync_val_compare_and_swap(atomicvar, compared, exchange);

    30

}

    31

    32

void PLC_GetTime(IEC_TIME *CURRENT_TIME)

    33

{

    34

    RTIME current_time = rt_timer_read();

    35

    CURRENT_TIME->tv_sec = current_time / 1000000000;

    36

    CURRENT_TIME->tv_nsec = current_time % 1000000000;

    37

}

    38

    39

RT_TASK PLC_task;

    40

RT_TASK WaitDebug_task;

    41

RT_TASK WaitPythonCommand_task;

    42

RT_TASK UnLockPython_task;

    43

RT_TASK LockPython_task;

    44

int PLC_shutdown = 0;

    45

    46

void PLC_SetTimer(long long next, long long period)

    47

{

    48

  RTIME current_time = rt_timer_read();

    49

  rt_task_set_periodic(&PLC_task, current_time + next, rt_timer_ns2ticks(period));

    50

}

    51

    52

void PLC_task_proc(void *arg)

    53

{

    54

    PLC_SetTimer(Ttick, Ttick);

    55

    56

    while (1) {

    57

        PLC_GetTime(&__CURRENT_TIME);

    58

        __run();

    59

        if (PLC_shutdown) break;

    60

        rt_task_wait_period(NULL);

    61

    }

    62

}

    63

    64

static int __debug_tick;

    65

    66

RT_SEM python_wait_sem;

    67

RT_MUTEX python_mutex;

    68

RT_SEM debug_wait_sem;

    69

RT_MUTEX debug_mutex;

    70

    71

void PLC_cleanup_all(void)

    72

{

    73

    if (PLC_state & PLC_STATE_TASK_CREATED) {

    74

        rt_task_delete(&PLC_task);

    75

        PLC_state &= ~PLC_STATE_TASK_CREATED;

    76

    }

    77

    78

    if (PLC_state & PLC_STATE_PYTHON_WAIT_SEM_CREATED) {

    79

        rt_sem_delete(&python_wait_sem);

    80

        PLC_state &= ~ PLC_STATE_PYTHON_WAIT_SEM_CREATED;

    81

    }

    82

    83

    if (PLC_state & PLC_STATE_PYTHON_MUTEX_CREATED) {

    84

        rt_mutex_delete(&python_mutex);

    85

        PLC_state &= ~ PLC_STATE_PYTHON_MUTEX_CREATED;

    86

    }

    87

    88

    if (PLC_state & PLC_STATE_DEBUG_WAIT_SEM_CREATED) {

    89

        rt_sem_delete(&debug_wait_sem);

    90

        PLC_state &= ~ PLC_STATE_DEBUG_WAIT_SEM_CREATED;

    91

    }

    92

    93

    if (PLC_state & PLC_STATE_DEBUG_MUTEX_CREATED) {

    94

        rt_mutex_delete(&debug_mutex);

    95

        PLC_state &= ~ PLC_STATE_DEBUG_MUTEX_CREATED;

    96

    }

    97

}

    98

    99

int stopPLC()

   100

{

   101

    PLC_shutdown = 1;

   102

    /* Stop the PLC */

   103

    PLC_SetTimer(0, 0);

   104

    PLC_cleanup_all();

   105

    __cleanup();

   106

    __debug_tick = -1;

   107

    rt_sem_v(&debug_wait_sem);

   108

    rt_sem_v(&python_wait_sem);

   109

}

   110

   111

//

   112

void catch_signal(int sig)

   113

{

   114

    stopPLC();

   115

//  signal(SIGTERM, catch_signal);

   116

    signal(SIGINT, catch_signal);

   117

    printf("Got Signal %d\n",sig);

   118

    exit(0);

   119

}

   120

   121

#define max_val(a,b) ((a>b)?a:b)

   122

int startPLC(int argc,char **argv)

   123

{

   124

    int ret = 0;

   125

   126

    signal(SIGINT, catch_signal);

   127

   128

    /* ne-memory-swapping for this program */

   129

    mlockall(MCL_CURRENT | MCL_FUTURE);

   130

   131

    /* Translate PLC's microseconds to Ttick nanoseconds */

   132

    Ttick = 1000000 * max_val(common_ticktime__,1);

   133

   134

    /* create python_wait_sem */

   135

    ret = rt_sem_create(&python_wait_sem, "python_wait_sem", 0, S_FIFO);

   136

    if (ret) goto error;

   137

    PLC_state |= PLC_STATE_PYTHON_WAIT_SEM_CREATED;

   138

   139

    /* create python_mutex */

   140

    ret = rt_mutex_create(&python_mutex, "python_mutex");

   141

    if (ret) goto error;

   142

    PLC_state |= PLC_STATE_PYTHON_MUTEX_CREATED;

   143

   144

    /* create debug_wait_sem */

   145

    ret = rt_sem_create(&debug_wait_sem, "debug_wait_sem", 0, S_FIFO);

   146

    if (ret) goto error;

   147

    PLC_state |= PLC_STATE_DEBUG_WAIT_SEM_CREATED;

   148

   149

    /* create debug_mutex */

   150

    ret = rt_mutex_create(&debug_mutex, "debug_mutex");

   151

    if (ret) goto error;

   152

    PLC_state |= PLC_STATE_DEBUG_MUTEX_CREATED;

   153

   154

    /* create can_driver_task */

   155

    ret = rt_task_create(&PLC_task, "PLC_task", 0, 50, 0);

   156

    if (ret) goto error;

   157

    PLC_state |= PLC_STATE_TASK_CREATED;

   158

   159

    ret = __init(argc,argv);

   160

    if (ret) goto error;

   161

   162

    /* start can_driver_task */

   163

    ret = rt_task_start(&PLC_task, &PLC_task_proc, NULL);

   164

    if (ret) goto error;

   165

   166

    return 0;

   167

   168

error:

   169

    PLC_cleanup_all();

   170

    return 1;

   171

}

   172

   173

int TryEnterDebugSection(void)

   174

{

   175

    return rt_mutex_acquire(&debug_mutex, TM_NONBLOCK) == 0;

   176

}

   177

   178

void LeaveDebugSection(void)

   179

{

   180

    rt_mutex_release(&debug_mutex);

   181

}

   182

   183

extern int __tick;

   184

/* from plc_debugger.c */

   185

int WaitDebugData()

   186

{

   187

    rt_task_shadow(&WaitDebug_task, "WaitDebug_task", 0, 0);

   188

    /* Wait signal from PLC thread */

   189

    rt_sem_p(&debug_wait_sem, TM_INFINITE);

   190

    return __debug_tick;

   191

}

   192

   193

/* Called by PLC thread when debug_publish finished

   194

 * This is supposed to unlock debugger thread in WaitDebugData*/

   195

void InitiateDebugTransfer()

   196

{

   197

    /* remember tick */

   198

    __debug_tick = __tick;

   199

    /* signal debugger thread it can read data */

   200

    rt_sem_v(&debug_wait_sem);

   201

}

   202

   203

void suspendDebug(void)

   204

{

   205

    __DEBUG = 0;

   206

    /* Prevent PLC to enter debug code */

   207

    rt_mutex_acquire(&debug_mutex, TM_INFINITE);

   208

}

   209

   210

void resumeDebug(void)

   211

{

   212

    __DEBUG = 1;

   213

    /* Let PLC enter debug code */

   214

    rt_mutex_release(&debug_mutex);

   215

}

   216

   217

/* from plc_python.c */

   218

int WaitPythonCommands(void)

   219

{

   220

    rt_task_shadow(&WaitPythonCommand_task, "WaitPythonCommand_task", 0, 0);

   221

    /* Wait signal from PLC thread */

   222

    rt_sem_p(&python_wait_sem, TM_INFINITE);

   223

}

   224

   225

/* Called by PLC thread on each new python command*/

   226

void UnBlockPythonCommands(void)

   227

{

   228

    /* signal debugger thread it can read data */

   229

    rt_sem_v(&python_wait_sem);

   230

}

   231

   232

int TryLockPython(void)

   233

{

   234

    return rt_mutex_acquire(&python_mutex, TM_NONBLOCK) == 0;

   235

}

   236

   237

void UnLockPython(void)

   238

{

   239

    rt_task_shadow(&UnLockPython_task, "UnLockPython_task", 0, 0);

   240

    rt_mutex_release(&python_mutex);

   241

}

   242

   243

void LockPython(void)

   244

{

   245

    rt_task_shadow(&LockPython_task, "LockPython_task", 0, 0);

   246

    rt_mutex_acquire(&python_mutex, TM_INFINITE);

   247

}