API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 20th, 2017
67
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 19.19 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. * Beispiel: Grundgeruest einer Modbus-Kommunikation
  3. *
  4. * Aufbau einer Modbus-Kommunikation ohne weitere Funktion
  5. *
  6. */
  7.  
  8. // Linked Header
  9. #include <rtai_mbx.h>
  10. #include <rtai_sched.h>
  11. #include <uint128.h>
  12. #include <sys/rtai_modbus.h>
  13. #include <time.h>
  14.  
  15.  
  16. // Register Values
  17.  
  18. // Digital Output Register
  19. // Define Name Maskierte Bits
  20. #define dOut_Magazin1 (1<<0)|(1<<1) //Bit dOut.00 und dOut.01
  21. #define dOut_Magazin2 (1<<2)|(1<<3) //Bit dOut.02 und dOut.03
  22. #define dOut_Auswerfer (1<<4) //Bit dOut.04
  23. #define dOut_Magazin3 (1<<5)|(1<<6) //Bit dOut.05 und dOut.06
  24. #define dOut_Band (1<<7) //Bit dOut.07
  25.  
  26. //#define BandAn (1<<3) //Bit Out 00
  27. //#define BandAus (1<<3) //Bit Out 01
  28.  
  29. //#define MagazStopp (1<<3)|(1<<4) //Bit Out 00
  30. //#define MagzinPull (1<<3)|(1<<4) //Bit Out 10
  31. //#define MagzinPush (1<<3)|(1<<4) //Bit Out 01
  32.  
  33.  
  34. // Digital Input Register
  35. // Define Name Maskierte Bits
  36. #define dIn_Magazin1_On 0 //Bit dIn.00 Magazin 1 eingefahren
  37. #define dIn_Magazin1_Off 1 //Bit dIn.01 Magazin 1 ausgefahren
  38. #define dIn_Magazin1_Empty 2 //Bit dIn.02 Magazin 1 leer (ohne Inhalt)
  39.  
  40. #define dIn_Magazin2_On 3 //Bit dIn.03 Magazin 2 eingefahren
  41. #define dIn_Magazin2_Off 4 //Bit dIn.04 Magazin 2 ausgefahren
  42. #define dIn_Magazin2_Empty 5 //Bit dIn.05 Magazin 2 leer (ohne Inhalt)
  43. #define dIn_Magazin2_Critical 15 //Bit dIn.15 Magazin 2 kritischer Bereich betreten
  44.  
  45.  
  46. #define dIn_Magazin3_On 7 //Bit dIn.07 Magazin 3 eingefahren
  47. #define dIn_Magazin3_Off 8 //Bit dIn.08 Magazin 3 ausgefahren
  48. #define dIn_Magazin3_Empty 9 //Bit dIn.09 Magazin 3 leer (ohne Inhalt)
  49. #define dIn_Magazin3_Critical 6 //Bit dIn.06 Magazin 3 kritischer Bereich betreten
  50.  
  51. #define dIn_Auswerfer_In 10 //Bit dIn.10 Auswerfer eingefahren
  52. #define dIn_Auswerfer_Out 11 //Bit dIn.11 Auswerfer ausgefahren
  53.  
  54. #define dIn_Rutsche_Voll 14 //Bit dIn.14 Magazin 3 kritischer Bereich betreten
  55.  
  56. #define dIn_Altitude_W_Reg 12 //Bit dIn.14 Höhensensor hat Werkstück registriert
  57. #define dIn_Altitude_M_OK 13 //Bit dIn.13 Höhensensor Messung ist in Ordnung
  58.  
  59. /*
  60. #define dIn_Magazin1_On (1<<00) //Bit dIn.00 Magazin 1 eingefahren
  61. #define dIn_Magazin1_Off (1<<01) //Bit dIn.01 Magazin 1 ausgefahren
  62. #define dIn_Magazin1_Empty (1<<02) //Bit dIn.02 Magazin 1 leer (ohne Inhalt)
  63.  
  64. #define dIn_Magazin2_On (1<<03) //Bit dIn.03 Magazin 2 eingefahren
  65. #define dIn_Magazin2_Off (1<<04) //Bit dIn.04 Magazin 2 ausgefahren
  66. #define dIn_Magazin2_Empty (1<<05) //Bit dIn.05 Magazin 2 leer (ohne Inhalt)
  67. #define dIn_Magazin2_Critical (1<<15) //Bit dIn.15 Magazin 2 kritischer Bereich betreten
  68.  
  69.  
  70. #define dIn_Magazin3_On (1<<07) //Bit dIn.07 Magazin 3 eingefahren
  71. #define dIn_Magazin3_Off (1<<08) //Bit dIn.08 Magazin 3 ausgefahren
  72. #define dIn_Magazin3_Empty (1<<09) //Bit dIn.09 Magazin 3 leer (ohne Inhalt)
  73. #define dIn_Magazin3_Critical (1<<06) //Bit dIn.06 Magazin 3 kritischer Bereich betreten
  74.  
  75. #define dIn_Auswerfer_In (1<<10) //Bit dIn.10 Auswerfer eingefahren
  76. #define dIn_Auswerfer_Out (1<<11) //Bit dIn.11 Auswerfer ausgefahren
  77.  
  78. #define dIn_Rutsche_Voll (1<<14) //Bit dIn.14 Magazin 3 kritischer Bereich betreten
  79.  
  80. #define dIn_Altitude_W_Reg (1<<12) //Bit dIn.14 Höhensensor hat Werkstück registriert
  81. #define dIn_Altitude_M_OK (1<<13) //Bit dIn.13 Höhensensor Messung ist in Ordnung
  82. */
  83.  
  84. // Analog Input Register
  85. // Define Name Maskierte Bits
  86. //efine aIn_Hoehensenormesswert //Bit aIn.00 bis 16
  87.  
  88.  
  89. /// Hilfsvariablen Global
  90. int fd_node;
  91. short valAnalog = 0;
  92. short valDigital = 0;
  93. int Mag3Senzor = 0;
  94. int Mag2Senzor = 0 ;
  95. int BadPart = 0 ;
  96. unsigned short registers; // theorisch muss sie nicht global sein
  97.  
  98.  
  99. //Threads bzw. Tasks
  100. static RT_TASK task;
  101. static RT_TASK tskM1;
  102. static RT_TASK tskM2;
  103. static RT_TASK tskM3;
  104. static RT_TASK ReadStatus;
  105. static RT_TASK tskRemoveBadPart;
  106.  
  107.  
  108. #define STACKSIZE 10000
  109.  
  110. // Union zur Bitmanipulation
  111.  
  112. // Output Register
  113. union {
  114. short Value;
  115. struct {
  116. unsigned char bit0 :1;
  117. unsigned char bit1 :1;
  118. unsigned char bit2 :1;
  119. unsigned char bit3 :1;
  120. unsigned char bit4 :1;
  121. unsigned char bit5 :1;
  122. unsigned char bit6 :1;
  123. unsigned char bit7 :1;
  124. } bits;
  125. } var;
  126.  
  127. // Output Register
  128. union {
  129. int Value;
  130. struct {
  131. unsigned char bit0 :1;
  132. unsigned char bit1 :1;
  133. unsigned char bit2 :1;
  134. unsigned char bit3 :1;
  135. unsigned char bit4 :1;
  136. unsigned char bit5 :1;
  137. unsigned char bit6 :1;
  138. unsigned char bit7 :1;
  139. unsigned char bit8 :1;
  140. unsigned char bit9 :1;
  141. unsigned char bit10 :1;
  142. unsigned char bit11 :1;
  143. unsigned char bit12 :1;
  144. unsigned char bit13 :1;
  145. unsigned char bit14 :1;
  146. unsigned char bit15 :1;
  147. unsigned char bit16 :1;
  148. } bits;
  149. } read;
  150.  
  151. //Funktionen
  152. // Deklarationen
  153. long long decimalToBinary(long n);
  154. int setMask(int Register);
  155. int getMask(int Register);
  156. void RemovePusherOn (unsigned int);
  157. void RemovePusherOff (unsigned int);
  158.  
  159. // Funktionen
  160. // Hilfsfunktion
  161.  
  162.  
  163.  
  164. // Set Registers with mask
  165. // Tested: OK
  166. void setBit(char *var, unsigned int pos){
  167. unsigned int mask=1;
  168.  
  169. mask = mask << (pos);
  170.  
  171. *var = *var|mask;
  172. }
  173.  
  174. // Get Registers with mask
  175. // Tested: OK
  176. unsigned int getBit(unsigned int var, int pos){
  177. unsigned int mask = 1;
  178. unsigned int old = var;
  179. mask = mask << (pos);
  180. mask = old|mask;
  181.  
  182. var = var&mask; // nur neu bits hinzufügen alte sollen bleiben, was im mom nicht passiter
  183. var = var >> (pos);
  184.  
  185. return (unsigned short)var; // rück gabe wert 16stellig. und dmait als == vergleichswert ungeeignet für bolsche algebra
  186. }
  187.  
  188. // Control WE über Union
  189. // Tested: OK
  190.  
  191. // 3 Input Values
  192. // Actor: 'M' = Magazin n, 'B' = Band, 'P' = Pusher/Greifer
  193. // Number: 1 for (M1, B and P), 2 for M2 , 3 for M3
  194. // Mode: Desired Operation Mode
  195.  
  196. //For M1, M2, M3
  197. // Mode: 00 Pressure off (and stay)
  198. // Mode: 10 Pull in (Pull the piston IN; back again)
  199. // Mode: 01 Push out (Push the piston OUT)
  200.  
  201. //For B,P
  202. // Mode 0 Turn off
  203. // Mode 1 Turn on
  204. /*
  205. void controlActUnion(char actor, int number, int mode) {
  206. int OldValue;
  207. OldValue = var.Value;
  208. if (actor == 'M') {
  209. if (number == 1) {
  210. if (mode == 0) {
  211. var.bits.bit0 = 0;
  212. var.bits.bit1 = 0;
  213. }
  214. if (mode == 1) {
  215. var.bits.bit0 = 1;
  216. var.bits.bit1 = 0;
  217. }
  218. if (mode == 2) {
  219. var.bits.bit0 = 0;
  220. var.bits.bit1 = 1;
  221. }
  222. //rt_sleep(300 * nano2count(1000000));
  223. //var.bits.bit0=0;
  224. //var.bits.bit1=0;
  225. }
  226. if (number == 2) {
  227. if (mode == 0) {
  228. var.bits.bit2 = 0;
  229. var.bits.bit3 = 0;
  230. }
  231. if (mode == 1) {
  232. var.bits.bit2 = 1;
  233. var.bits.bit3 = 0;
  234. }
  235. if (mode == 2) {
  236. var.bits.bit2 = 0;
  237. var.bits.bit3 = 1;
  238. }
  239. //rt_sleep(300 * nano2count(1000000));
  240. //var.bits.bit2=0;
  241. //var.bits.bit3=0;
  242. }
  243. if (number == 3) {
  244. if (mode == 0) {
  245. var.bits.bit5 = 0;
  246. var.bits.bit6 = 0;
  247. }
  248. if (mode == 1) {
  249. var.bits.bit5 = 1;
  250. var.bits.bit6 = 0;
  251.  
  252. }
  253. if (mode == 2) {
  254. var.bits.bit5 = 0;
  255. var.bits.bit6 = 1;
  256. }
  257. //rt_sleep(300 * nano2count(1000000));
  258. //var.bits.bit5=0;
  259. //var.bits.bit6=0;
  260. }
  261. }
  262. if (actor == 'P') {
  263. if (mode == 1 || mode == 0) {
  264. var.bits.bit4 = mode;
  265. }
  266. }
  267. if (actor == 'B') {
  268. if (mode == 1 || mode == 0) {
  269. var.bits.bit7 = mode;
  270. }
  271. }
  272. rt_modbus_set(fd_node, DIGITAL_OUT, 0, var.Value);
  273. }
  274. */
  275. void controlAct(char actor, int number, int mode) {
  276. int OldValue;
  277. OldValue = var.Value;
  278. if (actor == 'M') {
  279. if (number == 1) {
  280. if (mode == 0) {
  281. clearBit(&registers, dIn_Magazin1_On );
  282. clearBit(&registers, dIn_Magazin1_Off);
  283. }
  284. if (mode == 1) {
  285. setBit(&registers, dIn_Magazin1_On);
  286. clearBit(&registers, dIn_Magazin1_Off);
  287. }
  288. if (mode == 2) {
  289. clearBit(&registers, dIn_Magazin1_On);
  290. setBit(&registers, dIn_Magazin1_Off);
  291. }
  292. //rt_sleep(300 * nano2count(1000000));
  293. //var.bits.bit0=0;
  294. //var.bits.bit1=0;
  295. }
  296. if (number == 2) {
  297. if (mode == 0) {
  298. clearBit(&registers, 2);
  299. clearBit(&registers, 3);
  300. }
  301. if (mode == 1) {
  302. setBit(&registers, 2);
  303. clearBit(&registers, 3);
  304. }
  305. if (mode == 2) {
  306. clearBit(&registers, 2);
  307. setBit(&registers, 3);
  308. }
  309. //rt_sleep(300 * nano2count(1000000));
  310. //var.bits.bit2=0;
  311. //var.bits.bit3=0;
  312. }
  313. if (number == 3) {
  314. if (mode == 0) {
  315. clearBit(&registers, 5);
  316. clearBit(&registers, 6);
  317. }
  318. if (mode == 1) {
  319. setBit(&registers, 5);
  320. clearBit(&registers, 6);
  321. }
  322. if (mode == 2) {
  323. clearBit(&registers, 5);
  324. setBit(&registers, 6);
  325. }
  326. //rt_sleep(300 * nano2count(1000000));
  327. //var.bits.bit5=0;
  328. //var.bits.bit6=0;
  329. }
  330. }
  331. if (actor == 'P') {
  332. if (mode == 1){
  333. setBit(&registers, 4);
  334. }
  335. if (mode == 0){
  336. clearBit(&registers, 4);
  337. }
  338. }
  339. if (actor == 'B') {
  340. if (mode == 1) {
  341. setBit(&registers, 7);
  342. }
  343. if (mode == 0){
  344. clearBit(&registers, 7);
  345. }
  346. }
  347. rt_modbus_set(fd_node, DIGITAL_OUT, 0, registers);
  348. }
  349.  
  350.  
  351. // Control WE über unsigned short
  352. // Tested: Untested
  353.  
  354.  
  355.  
  356. // Turn Magazin Pressure off (Magzin Mode Change to 00)
  357. void controlActToZero(char actor, int number, int mode) {
  358. controlAct(actor, number, mode);
  359. //rt_sleep(3000 * nano2count(1000000));
  360. controlAct(actor, number, 0);
  361. }
  362.  
  363. // Coverts long Value into binary
  364. // Tested: OK
  365. // Copied from:
  366. long long decimalToBinary(long n) {
  367. int remainder;
  368. long long binary = 0, i = 1;
  369. while (n != 0) {
  370. remainder = n % 2;
  371. n = n / 2;
  372. binary = binary + (remainder * i);
  373. i = i * 10;
  374. }
  375. return binary;
  376. }
  377.  
  378. // Get Temp Register and
  379. // Tested: OK
  380. // Copied from:
  381. void func(int DIG_IN, int setMask) {
  382. // int fd_node;
  383. short valDigital = 0;
  384.  
  385. if ((fd_node = rt_modbus_connect("modbus-node")) == -1) {
  386. rt_printk("control: task exited\n");
  387. return;
  388. }
  389.  
  390. int tempRegister = rt_modbus_get(fd_node, DIGITAL_IN, 0, &valDigital);
  391.  
  392. rt_printk("Register: %d", tempRegister);
  393. }
  394.  
  395. // Slap Pusher with Delay
  396. // Tested: OK
  397. void RemovePusherOn (unsigned int secs) {
  398. unsigned int retTime = time(0) + secs; // Get finishing time.
  399. while (time(0) < retTime);
  400. controlAct('P', 0, 1);
  401. // Loop until it arrives.
  402. }
  403.  
  404. // Slap Pusher with Delay back
  405. // Tested: OK
  406. void RemovePusherOff (unsigned int secs) {
  407. unsigned int retTime = time(0) + secs; // Get finishing time.
  408. while (time(0) < retTime);
  409. controlAct('P', 0, 0);
  410. // Loop until it arrives.
  411. }
  412.  
  413. // Threads
  414. // Threads
  415. // Threads
  416. // Threads
  417. // Threads
  418.  
  419. // Task 1: Magazin 1
  420. // Tested: OK
  421. // Comments:
  422. static void mag1(long x) {
  423. int status = 0;
  424. while (1) {
  425. //if (getBit(&register, 0)==1 && getBit(&registers, 1)==0 && getBit(&registers, 2)==0
  426. if (read.bits.bit0 == 1 && read.bits.bit1 == 0 && read.bits.bit2 == 0) // here checks if the magazine have something inside
  427. {
  428. controlAct('M', 1, 2);
  429. rt_sleep(200 * nano2count(1000000));
  430. controlAct('M', 1, 0);
  431. status = 1;
  432. rt_sleep(200 * nano2count(1000000));
  433. }
  434. else {
  435. if (read.bits.bit0 == 0 && read.bits.bit1 == 1 && read.bits.bit2 == 0 && status == 1)
  436. {
  437.  
  438. controlAct('M', 1, 1);
  439. rt_sleep(200 * nano2count(1000000));
  440. controlAct('M', 1, 0);
  441. rt_sleep(200 * nano2count(1000000));
  442. status = 0;
  443.  
  444. }
  445. rt_sleep(10 * nano2count(1000000));
  446. }
  447. }
  448.  
  449. }
  450.  
  451. // Task 2: Magazin 2
  452. // Tested: OK
  453. // Comments:
  454. static void mag2(long x) {
  455. int status=0;
  456.  
  457. while (1) {
  458. if (Mag2Senzor == 1)
  459. {rt_sleep(2000 * nano2count(1000000));
  460. rt_printk("\nMag2 on pause\n");
  461. }
  462.  
  463. else {
  464. if (read.bits.bit3 == 1 && read.bits.bit4 == 0 && read.bits.bit5 == 0) // here checks if the magazine have something inside
  465. {
  466. controlAct('M', 2, 2);
  467.  
  468. rt_sleep(200 * nano2count(1000000));
  469. controlAct('M', 2, 0);
  470.  
  471. rt_sleep(200 * nano2count(1000000));
  472. status=1;}
  473.  
  474. // push mag out
  475.  
  476.  
  477. //stop presure
  478.  
  479. if (status==1){
  480.  
  481. controlAct('M', 2, 1);
  482. // get the piston back
  483. rt_sleep(200 * nano2count(1000000)); // wait for piston to be full in
  484. controlAct('M', 2, 0);
  485. // stop the air presure
  486. rt_sleep(200 * nano2count(1000000));
  487. status =0;
  488. }
  489.  
  490. rt_sleep(10 * nano2count(1000000));
  491. }
  492. }
  493. }
  494.  
  495. // Task 3: Magazin 3
  496. // Tested: OK
  497. // Comments:
  498. static void mag3(long x) {
  499. int status = 0;
  500. while (1) {
  501. if (Mag3Senzor == 1)
  502. {rt_sleep(2000 * nano2count(1000000));
  503. rt_printk("\nMag3 on pause\n");}
  504. else{
  505.  
  506. if (read.bits.bit7 == 1 && read.bits.bit8 == 0 && read.bits.bit9 == 0) // here checks if the magazine have something inside
  507. {
  508. controlAct('M', 3, 2);
  509.  
  510. rt_sleep(200 * nano2count(1000000));
  511. controlAct('M', 3, 0);
  512. //stop presure
  513. rt_sleep(200 * nano2count(1000000));
  514. status = 1;
  515. }
  516. if (status == 1) {
  517. controlAct('M', 3, 1); // get the piston back
  518. rt_sleep(200 * nano2count(1000000)); // wait for piston to be full in
  519. controlAct('M', 3, 0); // stop the air presure
  520. rt_sleep(200 * nano2count(1000000));
  521. status = 0;
  522. }
  523.  
  524. rt_sleep(10 * nano2count(1000000));
  525. }
  526. }
  527. }
  528.  
  529. // Task 4: Sensors
  530. // Tested: OK
  531. // Comments:
  532. static void ReadAllSensors(long x) {
  533. int PusherSenzor =0;
  534. while (1) {
  535. rt_modbus_get(fd_node, ANALOG_IN, 0, &valAnalog);
  536. rt_modbus_get(fd_node, DIGITAL_IN, 0, &valDigital);
  537. read.Value = valDigital;
  538. Mag3Senzor = read.bits.bit6;
  539. Mag2Senzor = read.bits.bit15;
  540.  
  541. if (valAnalog > 20000) {
  542. PusherSenzor++;
  543. if (PusherSenzor > 5)
  544.  
  545. BadPart = 1;
  546. rt_printk("Push senzor: %d", PusherSenzor);
  547. }
  548. else
  549. PusherSenzor = 0;
  550.  
  551. rt_sleep(30 * nano2count(1000000));
  552.  
  553. }
  554. }
  555.  
  556. // Task 5: Slap Bad Parts to Slide
  557. // Tested: OK
  558. // Comments:
  559.  
  560.  
  561. static void RemoveBadPart(long x)
  562. {
  563. int tm =0,start = 1300,end = 1000;
  564. rt_printk("Remove bad part: task started\n");
  565. while (1) {
  566. if ( BadPart == 1 )
  567. {
  568. rt_printk("\nRemove bad part: Removal started\n");
  569.  
  570.  
  571.  
  572.  
  573. // rt_sleep(1300 * nano2count(1000000));
  574. // controlAct('P', 0, 1);
  575. RemovePusherOn(1);
  576. // rt_sleep(1000 * nano2count(1000000));
  577. RemovePusherOff(1);
  578. // controlAct('P', 0, 0);
  579. BadPart = 0;
  580. }
  581. rt_sleep(30 * nano2count(1000000));
  582. }
  583. }
  584.  
  585. // Task 6: Check for critical area of M2/M3 with delay
  586. // Tested: no
  587. static void CheckCriticalArea(long x) {
  588. while(getBit(&registers, dIn_Magazin2_Critical)==1){
  589.  
  590. }
  591. // sleep
  592. }
  593.  
  594.  
  595.  
  596.  
  597. // Task 0: Control
  598. // Tested: OK
  599. // Comments:
  600.  
  601.  
  602. static void control(long x) {
  603. // int fd_node;
  604. int ready = 0;
  605. int s1 =0;
  606. float valAnalogeVoltage = 0.0;
  607.  
  608. int* valDigitalOut = 0x1000;
  609. int val = 0;
  610.  
  611. rt_printk("control: task started\n");
  612.  
  613. /* Verbindung zum Modbus-Knoten herstellen */
  614. if ((fd_node = rt_modbus_connect("modbus-node")) == -1) {
  615. rt_printk("control: task exited\n");
  616. return;
  617. }
  618. rt_printk("control: MODBUS communication opened\n");
  619.  
  620. while (1) {
  621. /* Ablauf des Control Tasks */
  622. rt_printk("\nHallo!\n");
  623.  
  624. /* Evtl. Ausgang zum Aufraemen */
  625. if (ready)
  626. goto fertig;
  627.  
  628. /* Fair zu Linux sein und Zeit abgeben */
  629. rt_sleep(1000 * nano2count(1000000));
  630.  
  631. // Bit mani set bit
  632. // tmp = (1<<3) | (1<<2); // set bit 3 and 2
  633.  
  634. // ANALOG_IN
  635. // rt_modbus_get(fd_node, ANALOG_IN, 0, &valAnalog);
  636. rt_printk("AnalogValue %d\n", valAnalog);
  637. //valAnalogeVoltage = valAnalog*333.33; // in µV
  638. //rt_printk("AnalogValue %f µV\n", valAnalogeVoltage);
  639.  
  640. // DIGITAL_IN
  641. // rt_modbus_get(fd_node, DIGITAL_IN, 0, &valDigital);
  642. rt_printk("DigitalValue: Dez: %lu Hex: %08x ", valDigital, valDigital);
  643.  
  644. unsigned long long zahl = decimalToBinary(valDigital);
  645. rt_printk("\nBin: %lu ", zahl);
  646.  
  647. // read.Value = valDigital;
  648.  
  649. rt_printk("Laser status: %d", read.bits.bit15);
  650. rt_printk("\n");
  651. rt_sleep(1000 * nano2count(1000000));
  652.  
  653. rt_printk("Laser ID: %d", Mag3Senzor);
  654.  
  655.  
  656.  
  657. // Steuerung in Control Funktion
  658. if (val==0){
  659. int i;
  660. for (i=1; i<=15; i++)
  661. rt_modbus_set(fd_node,IB_IL_AO,i,30000);
  662. controlAct('B', 2, 1);
  663. rt_task_resume(&ReadStatus);
  664. rt_printk("\nRead Task started !\n");
  665. rt_task_resume(&tskM1);
  666. rt_printk("\nM1 task started!\n");
  667. rt_task_resume(&tskRemoveBadPart);
  668. rt_printk("\nremove bad parts task started\n");
  669. rt_sleep(2000 * nano2count(1000000));
  670. rt_task_resume(&tskM2);
  671. rt_printk("\nM2 task started!\n");
  672. rt_sleep(3000 * nano2count(1000000));
  673. rt_task_resume(&tskM3);
  674. rt_printk("\nM3 task started\n");
  675.  
  676.  
  677.  
  678. val++;}
  679.  
  680.  
  681.  
  682.  
  683.  
  684. }
  685.  
  686. //
  687.  
  688.  
  689.  
  690.  
  691. // if (rt_task_suspend(&tskM3)== 0)
  692. // {
  693. // rt_printk("\nTask 3 suspended\n");
  694. // s1 =1;
  695. // }
  696. // else
  697. // {
  698. // rt_printk("\nTask 3 suspend FAILURE\n");
  699. // }
  700. // }
  701. //
  702. //
  703. // else
  704. // if (read.bits.bit6 == 0 && s1 ==1)
  705. // {
  706. //
  707. //
  708. // rt_printk("Task 3 resumed");
  709. // rt_printk("\n");
  710. // rt_task_resume(&tskM3);
  711. // s1 =0;
  712. // }
  713.  
  714.  
  715.  
  716.  
  717. // rt_printk("BIT 1: %d", read.bits.bit4);
  718. // rt_printk("\n");
  719. // rt_printk("BIT 2: %d", read.bits.bit5);
  720. // rt_printk("\n");
  721.  
  722.  
  723.  
  724. /* Aufraeumen */
  725. fertig: rt_modbus_disconnect(fd_node);
  726. rt_printk("control: task exited\n");
  727. }
  728.  
  729. /* Funktion die beim Entfernen des Moduls aufgerufen wird */
  730. static void __exit
  731. example_exit(void) {
  732. /* Task loeschen */
  733. rt_task_delete(&task);
  734. /* Timer stoppen */
  735. stop_rt_timer();
  736. printk("rtai_example unloaded\n");
  737. }
  738.  
  739. /* Funktion die beim Laden des Moduls aufgerufen wird */
  740. static int __init
  741. example_init(void) {
  742. /* variables Timing basierend auf dem CPU-Takt */
  743. rt_set_oneshot_mode();
  744. /* Timer starten */
  745. start_rt_timer(0);
  746. /* Modbuskommunikation initialisieren */
  747. modbus_init();
  748.  
  749. /* Taskinitialisierung
  750. *
  751. * &task = Adresse des zu initialisierenden TCB
  752. * control = zum Task gehörende Funktion
  753. * 0 = Uebergabeparameter an die zum Task gehoerende Funktion (long)
  754. * 1024 = Stacksize
  755. * 0 = Priorität des Tasks (0 = groesste)
  756. * 0 = uses_fpu (Fliesskommaeinheit nicht benutzen); im Praktikum sollte es 0 bleiben
  757. * NULL = &signal_handler; Referenz zu einer Fkt., die bei jeder Aktivierung
  758. * des Tasks aufgerufen wird, ansonsten NULL
  759. *
  760. * Achtung: Nach der Initialisierung ist der Task "suspended"!
  761. *
  762. */
  763. if (rt_task_init(&task, control, 0, STACKSIZE, 0, 0, NULL)) {
  764. printk("cannot initialize control task\n");
  765. goto fail;
  766. }
  767.  
  768. if (rt_task_init(&tskM1, mag1, 0,STACKSIZE , 0, 0, NULL)) {
  769. printk("cannot initialize M1 task\n");
  770.  
  771. goto fail;
  772. }
  773.  
  774. if (rt_task_init(&tskM2, mag2, 0, STACKSIZE, 0, 0, NULL)) {
  775. printk("cannot initialize M2 task\n");
  776. goto fail;
  777. }
  778.  
  779. if (rt_task_init(&tskM3, mag3, 0, STACKSIZE, 0, 0, NULL)) {
  780. printk("cannot initialize M3 task\n");
  781. goto fail;
  782. }
  783. if (rt_task_init(&ReadStatus, ReadAllSensors, 0, STACKSIZE, 0, 0, NULL)) {
  784. printk("cannot initialize Read All Sensors task\n");
  785. goto fail;
  786. }
  787. if (rt_task_init(&tskRemoveBadPart, RemoveBadPart, 0, STACKSIZE, 0, 0, NULL)) {
  788. printk("cannot initialize RemoveBadPart task\n");
  789. goto fail;
  790. }
  791.  
  792. /* suspend -> ready bzw. running */
  793. rt_task_resume(&task);
  794. printk("rtai_example loaded\n");
  795. return (0);
  796.  
  797. fail:
  798. /* Aufraeumen */
  799. rt_task_delete(&tskM1);
  800. rt_task_delete(&tskM2);
  801. rt_task_delete(&tskM3);
  802. stop_rt_timer();
  803. return (1);
  804. }
  805.  
  806. /* Modulein- und ausstieg festlegen */
  807. module_exit(example_exit)
  808. module_init(example_init)
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!