37 #include <linux/interrupt.h> |
37 #include <linux/interrupt.h> |
38 |
38 |
39 #include "../../include/ecrt.h" // EtherCAT realtime interface |
39 #include "../../include/ecrt.h" // EtherCAT realtime interface |
40 #include "../../include/ecdb.h" // EtherCAT slave database |
40 #include "../../include/ecdb.h" // EtherCAT slave database |
41 |
41 |
|
42 #define PFX "ec_mini: " |
|
43 |
42 #define FREQUENCY 100 |
44 #define FREQUENCY 100 |
43 |
45 |
44 //#define KBUS |
46 //#define KBUS |
45 |
47 |
46 /*****************************************************************************/ |
48 /*****************************************************************************/ |
47 |
49 |
48 struct timer_list timer; |
50 static struct timer_list timer; |
49 |
51 |
50 // EtherCAT |
52 // EtherCAT |
51 ec_master_t *master = NULL; |
53 static ec_master_t *master = NULL; |
52 ec_domain_t *domain1 = NULL; |
54 static ec_domain_t *domain1 = NULL; |
53 spinlock_t master_lock = SPIN_LOCK_UNLOCKED; |
55 spinlock_t master_lock = SPIN_LOCK_UNLOCKED; |
|
56 static ec_master_status_t master_status, old_status = {}; |
54 |
57 |
55 // data fields |
58 // data fields |
56 #ifdef KBUS |
59 #ifdef KBUS |
57 void *r_inputs; |
60 static void *r_inputs; |
58 void *r_outputs; |
61 static void *r_outputs; |
59 #endif |
62 #endif |
60 |
63 |
61 void *r_dig_out; |
64 static void *r_dig_out; |
62 |
65 static void *r_ana_out; |
63 #if 1 |
66 static void *r_count; |
64 ec_pdo_reg_t domain1_pdos[] = { |
67 static void *r_freq; |
65 {"4", Beckhoff_EL2004_Outputs, &r_dig_out}, |
68 |
|
69 #if 1 |
|
70 const static ec_pdo_reg_t domain1_pdo_regs[] = { |
|
71 {"2", Beckhoff_EL2004_Outputs, &r_dig_out}, |
|
72 {"3", Beckhoff_EL4132_Output1, &r_ana_out}, |
|
73 {"#888:1", Beckhoff_EL5101_Value, &r_count}, |
|
74 {"4", Beckhoff_EL5101_Frequency, &r_freq}, |
66 {} |
75 {} |
67 }; |
76 }; |
68 #endif |
77 #endif |
69 |
78 |
70 /*****************************************************************************/ |
79 /*****************************************************************************/ |
88 counter--; |
97 counter--; |
89 } |
98 } |
90 else { |
99 else { |
91 counter = FREQUENCY; |
100 counter = FREQUENCY; |
92 blink = !blink; |
101 blink = !blink; |
|
102 |
|
103 spin_lock(&master_lock); |
|
104 ecrt_master_get_status(master, &master_status); |
|
105 spin_unlock(&master_lock); |
|
106 |
|
107 if (master_status.bus_status != old_status.bus_status) { |
|
108 printk(KERN_INFO PFX "bus status changed to %i.\n", |
|
109 master_status.bus_status); |
|
110 } |
|
111 if (master_status.bus_tainted != old_status.bus_tainted) { |
|
112 printk(KERN_INFO PFX "tainted flag changed to %u.\n", |
|
113 master_status.bus_tainted); |
|
114 } |
|
115 if (master_status.slaves_responding != |
|
116 old_status.slaves_responding) { |
|
117 printk(KERN_INFO PFX "slaves_responding changed to %u.\n", |
|
118 master_status.slaves_responding); |
|
119 } |
|
120 |
|
121 old_status = master_status; |
93 } |
122 } |
94 |
123 |
95 #ifdef KBUS |
124 #ifdef KBUS |
96 EC_WRITE_U8(r_outputs + 2, blink ? 0xFF : 0x00); |
125 EC_WRITE_U8(r_outputs + 2, blink ? 0xFF : 0x00); |
97 #endif |
126 #endif |
98 |
127 |
99 // send |
128 // send |
100 spin_lock(&master_lock); |
129 spin_lock(&master_lock); |
101 ecrt_domain_queue(domain1); |
130 ecrt_domain_queue(domain1); |
102 spin_unlock(&master_lock); |
131 spin_unlock(&master_lock); |
103 |
|
104 ecrt_master_run(master); |
|
105 |
132 |
106 spin_lock(&master_lock); |
133 spin_lock(&master_lock); |
107 ecrt_master_send(master); |
134 ecrt_master_send(master); |
108 spin_unlock(&master_lock); |
135 spin_unlock(&master_lock); |
109 |
136 |
129 |
156 |
130 /*****************************************************************************/ |
157 /*****************************************************************************/ |
131 |
158 |
132 int __init init_mini_module(void) |
159 int __init init_mini_module(void) |
133 { |
160 { |
|
161 #if 1 |
|
162 ec_slave_t *slave; |
|
163 #endif |
|
164 |
|
165 printk(KERN_INFO PFX "Starting...\n"); |
|
166 |
|
167 if (!(master = ecrt_request_master(0))) { |
|
168 printk(KERN_ERR PFX "Requesting master 0 failed!\n"); |
|
169 goto out_return; |
|
170 } |
|
171 |
|
172 ecrt_master_callbacks(master, request_lock, release_lock, NULL); |
|
173 |
|
174 printk(KERN_INFO PFX "Registering domain...\n"); |
|
175 if (!(domain1 = ecrt_master_create_domain(master))) { |
|
176 printk(KERN_ERR PFX "Domain creation failed!\n"); |
|
177 goto out_release_master; |
|
178 } |
|
179 |
|
180 #if 1 |
|
181 printk(KERN_INFO PFX "Configuring alternative PDO mapping...\n"); |
|
182 if (!(slave = ecrt_master_get_slave(master, "4", Beckhoff_EL5101))) |
|
183 goto out_release_master; |
|
184 |
|
185 if (ecrt_slave_pdo_mapping(slave, EC_DIR_INPUT, 2, 0x1A00, 0x1A02)) |
|
186 goto out_release_master; |
|
187 #endif |
|
188 |
|
189 printk(KERN_INFO PFX "Registering PDOs...\n"); |
|
190 #if 1 |
|
191 if (ecrt_domain_register_pdo_list(domain1, domain1_pdo_regs)) { |
|
192 printk(KERN_ERR PFX "PDO registration failed!\n"); |
|
193 goto out_release_master; |
|
194 } |
|
195 #endif |
|
196 |
|
197 #ifdef KBUS |
|
198 if (!(slave = ecrt_master_get_slave(master, "0", Beckhoff_BK1120))) |
|
199 goto out_release_master; |
|
200 |
|
201 if (!ecrt_domain_register_pdo_range( |
|
202 domain1, slave, EC_DIR_OUTPUT, 0, 4, &r_outputs)) { |
|
203 printk(KERN_ERR PFX "PDO registration failed!\n"); |
|
204 goto out_release_master; |
|
205 } |
|
206 |
|
207 if (!ecrt_domain_register_pdo_range( |
|
208 domain1, slave, EC_DIR_INPUT, 0, 4, &r_inputs)) { |
|
209 printk(KERN_ERR PFX "PDO registration failed!\n"); |
|
210 goto out_release_master; |
|
211 } |
|
212 #endif |
|
213 |
134 #if 0 |
214 #if 0 |
135 ec_slave_t *slave; |
215 if (!(slave = ecrt_master_get_slave(master, "4", Beckhoff_EL5001))) |
136 #endif |
|
137 |
|
138 printk(KERN_INFO "=== Starting Minimal EtherCAT environment... ===\n"); |
|
139 |
|
140 if (!(master = ecrt_request_master(0))) { |
|
141 printk(KERN_ERR "Requesting master 0 failed!\n"); |
|
142 goto out_return; |
|
143 } |
|
144 |
|
145 ecrt_master_callbacks(master, request_lock, release_lock, NULL); |
|
146 |
|
147 printk(KERN_INFO "Registering domain...\n"); |
|
148 if (!(domain1 = ecrt_master_create_domain(master))) { |
|
149 printk(KERN_ERR "Domain creation failed!\n"); |
|
150 goto out_release_master; |
|
151 } |
|
152 |
|
153 printk(KERN_INFO "Registering PDOs...\n"); |
|
154 #if 1 |
|
155 if (ecrt_domain_register_pdo_list(domain1, domain1_pdos)) { |
|
156 printk(KERN_ERR "PDO registration failed!\n"); |
|
157 goto out_release_master; |
|
158 } |
|
159 #endif |
|
160 |
|
161 #ifdef KBUS |
|
162 if (!ecrt_domain_register_pdo_range(domain1, "0", Beckhoff_BK1120, |
|
163 EC_DIR_OUTPUT, 0, 4, &r_outputs)) { |
|
164 printk(KERN_ERR "PDO registration failed!\n"); |
|
165 goto out_release_master; |
|
166 } |
|
167 if (!ecrt_domain_register_pdo_range(domain1, "0", Beckhoff_BK1120, |
|
168 EC_DIR_INPUT, 0, 4, &r_inputs)) { |
|
169 printk(KERN_ERR "PDO registration failed!\n"); |
|
170 goto out_release_master; |
|
171 } |
|
172 #endif |
|
173 |
|
174 #if 0 |
|
175 if (!(slave = ecrt_master_get_slave(master, "2"))) |
|
176 goto out_release_master; |
216 goto out_release_master; |
177 |
217 |
178 if (ecrt_slave_conf_sdo8(slave, 0x4061, 1, 0)) |
218 if (ecrt_slave_conf_sdo8(slave, 0x4061, 1, 0)) |
179 goto out_release_master; |
219 goto out_release_master; |
180 #endif |
220 #endif |
181 |
221 |
182 printk(KERN_INFO "Activating master...\n"); |
222 #if 1 |
|
223 #endif |
|
224 |
|
225 printk(KERN_INFO PFX "Activating master...\n"); |
183 if (ecrt_master_activate(master)) { |
226 if (ecrt_master_activate(master)) { |
184 printk(KERN_ERR "Failed to activate master!\n"); |
227 printk(KERN_ERR PFX "Failed to activate master!\n"); |
185 goto out_release_master; |
228 goto out_release_master; |
186 } |
229 } |
187 |
230 |
188 printk("Starting cyclic sample thread.\n"); |
231 printk(KERN_INFO PFX "Starting cyclic sample thread.\n"); |
189 init_timer(&timer); |
232 init_timer(&timer); |
190 timer.function = run; |
233 timer.function = run; |
191 timer.expires = jiffies + 10; |
234 timer.expires = jiffies + 10; |
192 add_timer(&timer); |
235 add_timer(&timer); |
193 |
236 |
194 printk(KERN_INFO "=== Minimal EtherCAT environment started. ===\n"); |
237 printk(KERN_INFO PFX "Started.\n"); |
195 return 0; |
238 return 0; |
196 |
239 |
197 out_release_master: |
240 out_release_master: |
|
241 printk(KERN_ERR PFX "Releasing master...\n"); |
198 ecrt_release_master(master); |
242 ecrt_release_master(master); |
199 out_return: |
243 out_return: |
|
244 printk(KERN_ERR PFX "Failed to load. Aborting.\n"); |
200 return -1; |
245 return -1; |
201 } |
246 } |
202 |
247 |
203 /*****************************************************************************/ |
248 /*****************************************************************************/ |
204 |
249 |
205 void __exit cleanup_mini_module(void) |
250 void __exit cleanup_mini_module(void) |
206 { |
251 { |
207 printk(KERN_INFO "=== Stopping Minimal EtherCAT environment... ===\n"); |
252 printk(KERN_INFO PFX "Stopping...\n"); |
208 |
253 |
209 del_timer_sync(&timer); |
254 del_timer_sync(&timer); |
210 printk(KERN_INFO "Releasing master...\n"); |
255 printk(KERN_INFO PFX "Releasing master...\n"); |
211 ecrt_release_master(master); |
256 ecrt_release_master(master); |
212 |
257 |
213 printk(KERN_INFO "=== Minimal EtherCAT environment stopped. ===\n"); |
258 printk(KERN_INFO PFX "Unloading.\n"); |
214 } |
259 } |
215 |
260 |
216 /*****************************************************************************/ |
261 /*****************************************************************************/ |
217 |
262 |
218 MODULE_LICENSE("GPL"); |
263 MODULE_LICENSE("GPL"); |