examples/msr/msr_sample.c
changeset 234 fd04cfde1c4b
parent 232 f6594a07cdda
child 240 e55b0572933c
equal deleted inserted replaced
233:31d327ce38d3 234:fd04cfde1c4b
    31 #include "rtai_sem.h"
    31 #include "rtai_sem.h"
    32 
    32 
    33 // RT_lib
    33 // RT_lib
    34 #include <msr_main.h>
    34 #include <msr_main.h>
    35 #include <msr_reg.h>
    35 #include <msr_reg.h>
       
    36 #include <msr_time.h>
    36 #include "msr_param.h"
    37 #include "msr_param.h"
    37 
    38 
    38 // EtherCAT
    39 // EtherCAT
    39 #include "../../include/ecrt.h"
    40 #include "../../include/ecrt.h"
    40 
    41 
    48 // RTAI
    49 // RTAI
    49 RT_TASK task;
    50 RT_TASK task;
    50 SEM master_sem;
    51 SEM master_sem;
    51 cycles_t t_start = 0, t_critical;
    52 cycles_t t_start = 0, t_critical;
    52 
    53 
    53 // MSR
       
    54 extern unsigned long msr_controller_execution_time;
       
    55 extern unsigned long msr_controller_call_time;
       
    56 extern wait_queue_head_t msr_read_waitqueue;
       
    57 int count_wakeup = 0;
       
    58 
       
    59 // EtherCAT
    54 // EtherCAT
    60 ec_master_t *master = NULL;
    55 ec_master_t *master = NULL;
    61 ec_domain_t *domain1 = NULL;
    56 ec_domain_t *domain1 = NULL;
    62 
    57 
    63 // Prozessdaten
    58 // raw process data
    64 void *r_ssi;
    59 void *r_ssi;
    65 void *r_ssi_st;
    60 void *r_ssi_st;
    66 
    61 
    67 // Channels
    62 // Channels
    68 uint32_t k_ssi;
    63 uint32_t k_ssi;
    74     {}
    69     {}
    75 };
    70 };
    76 
    71 
    77 /*****************************************************************************/
    72 /*****************************************************************************/
    78 
    73 
       
    74 void msr_controller_run(void)
       
    75 {
       
    76     rt_sem_wait(&master_sem);
       
    77 
       
    78 #ifdef ASYNC
       
    79     // Empfangen
       
    80     ecrt_master_async_receive(master);
       
    81     ecrt_domain_process(domain1);
       
    82 #else
       
    83     // Senden und empfangen
       
    84     ecrt_domain_queue(domain1);
       
    85     ecrt_master_run(master);
       
    86     ecrt_master_sync_io(master);
       
    87     ecrt_domain_process(domain1);
       
    88 #endif
       
    89 
       
    90     // Prozessdaten verarbeiten
       
    91     k_ssi    = EC_READ_U32(r_ssi);
       
    92     k_ssi_st = EC_READ_U8 (r_ssi_st);
       
    93 
       
    94 #ifdef ASYNC
       
    95     // Senden
       
    96     ecrt_domain_queue(domain1);
       
    97     ecrt_master_run(master);
       
    98     ecrt_master_async_send(master);
       
    99 #endif
       
   100 
       
   101     rt_sem_signal(&master_sem);
       
   102 
       
   103     msr_write_kanal_list();
       
   104 }
       
   105 
       
   106 /*****************************************************************************/
       
   107 
    79 void msr_run(long data)
   108 void msr_run(long data)
    80 {
   109 {
    81     cycles_t t_last_start;
   110     while (1) {
    82 
       
    83     while (1)
       
    84     {
       
    85         t_last_start = t_start;
       
    86         t_start = get_cycles();
   111         t_start = get_cycles();
    87 
   112         MSR_RTAITHREAD_CODE(msr_controller_run(););
    88         rt_sem_wait(&master_sem);
       
    89 
       
    90 #ifdef ASYNC
       
    91         // Empfangen
       
    92         ecrt_master_async_receive(master);
       
    93         ecrt_domain_process(domain1);
       
    94 #else
       
    95         // Senden und empfangen
       
    96         ecrt_domain_queue(domain1);
       
    97         ecrt_master_run(master);
       
    98         ecrt_master_sync_io(master);
       
    99         ecrt_domain_process(domain1);
       
   100 #endif
       
   101 
       
   102         // Prozessdaten verarbeiten
       
   103         k_ssi =    EC_READ_U32(r_ssi);
       
   104         k_ssi_st = EC_READ_U8 (r_ssi_st);
       
   105 
       
   106 #ifdef ASYNC
       
   107         // Senden
       
   108         ecrt_domain_queue(domain1);
       
   109         ecrt_master_run(master);
       
   110         ecrt_master_async_send(master);
       
   111 #endif
       
   112 
       
   113         rt_sem_signal(&master_sem);
       
   114 
       
   115         /* write data to MSR ring buffers */
       
   116         msr_write_kanal_list();
       
   117 
       
   118         /* wake up MSR read queue */
       
   119         if(++count_wakeup >= MSR_ABTASTFREQUENZ / 10) {
       
   120             wake_up_interruptible(&msr_read_waitqueue);
       
   121             count_wakeup = 0;
       
   122         }
       
   123 
       
   124         /* calculate timing */
       
   125         msr_controller_execution_time =
       
   126             (unsigned long) (get_cycles() - t_start) * 1000 / cpu_khz;
       
   127         msr_controller_call_time =
       
   128             (unsigned long) (t_start - t_last_start) * 1000 / cpu_khz;
       
   129 
       
   130         rt_task_wait_period();
   113         rt_task_wait_period();
   131     }
   114     }
   132 }
   115 }
   133 
   116 
   134 /*****************************************************************************/
   117 /*****************************************************************************/