API tools faq
paste
Advertisement
Guest User

PETRAMULT

a guest
May 5th, 2016
49
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 9.21 KB | None | 0 0
raw download clone embed print report
  1. #include <unistd.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <sys/types.h>
  5. #include <sys/mman.h>
  6. #include <errno.h>
  7. #include <sys/stat.h>
  8. #include <semaphore.h>
  9. #include <sys/time.h>
  10. #include <time.h>
  11. #include <sys/resource.h>
  12. #include <signal.h>
  13. #include <fcntl.h>
  14. #include <sched.h>
  15. #include <setjmp.h>
  16. #include <mqueue.h>
  17.  
  18. #define NB_PIECE 2
  19.  
  20. #define CP 1
  21. #define C1 2
  22. #define C2 3
  23. #define PV 4
  24. #define PA 5
  25. #define AA 6
  26. #define GA 7
  27. #define TROU 8
  28. #define ENCOCHE 9
  29. #define PRISE 10
  30. #define STOCKTROU 11
  31. #define NBPIECE 12
  32.  
  33. struct  ACTUATEURS
  34.         {
  35.                  unsigned Cp : 2;
  36.                  unsigned c1 : 1;
  37.                  unsigned c2 : 1;
  38.                  unsigned Pv : 1;
  39.                  unsigned Pa : 1;
  40.                  unsigned Aa : 1;
  41.                  unsigned Ga : 1;
  42.                } ;
  43. union
  44.     {
  45.     struct ACTUATEURS act ;
  46.     unsigned char byte ;
  47.     } u_act ;
  48.  
  49.  
  50.  
  51. struct  CAPTEURS
  52.         {
  53.                  unsigned L1 : 1;
  54.                  unsigned L2 : 1;
  55.                  unsigned t  : 1;
  56.                  unsigned s  : 1;
  57.                  unsigned Cs : 1;
  58.                  unsigned Ap : 1;
  59.                  unsigned Pp : 1;
  60.                  unsigned De : 1;
  61.               } ;
  62.  
  63. union
  64.     {
  65.     struct CAPTEURS capt ;
  66.     unsigned char byte ;
  67.     } u_capt ;
  68. int fd_petra_in, fd_petra_out ;
  69.  
  70. pid_t idPlongeur,tapis1,tapis2;
  71. caddr_t  shm_ptr;
  72.  
  73. void fctPlongeur();
  74. void fctTapis1(int);
  75. void fctTapis2(int);
  76. void handlerSIGINT(int);
  77.  
  78. sem_t *ptr_Fin;
  79. sem_t *ptr_Tapis1;
  80. sem_t *ptr_Tapis2;
  81. sem_t *ptr_PrendrePiece;
  82. sem_t *ptr_Mauvaise;
  83.  
  84. int main()
  85. {
  86.     struct timespec tim;
  87.     int shm;
  88.     int i;
  89.     int ret_val;
  90.  
  91.     tim.tv_sec = 0;
  92.     tim.tv_nsec = 50000000;
  93.  
  94.     ptr_Fin = sem_open("FIN", O_CREAT, 0777, 0);
  95.     ptr_Tapis1 = sem_open("TAPIS1", O_CREAT, 0777, 0);
  96.     ptr_Tapis2 = sem_open("TAPIS2", O_CREAT, 0777, 0);
  97.     ptr_PrendrePiece = sem_open("PRENDREPIECE", O_CREAT, 0777, 1);
  98.  
  99.     struct sigaction act;
  100.     act.sa_flags = 0;
  101.     act.sa_handler = &handlerSIGINT;
  102.     sigaction(SIGINT, &act, NULL );
  103.  
  104.     fd_petra_in = open ( "/dev/capteursPETRA", O_RDONLY );
  105.     fd_petra_out = open ( "/dev/actuateursPETRA", O_WRONLY );
  106.  
  107.     shm = shm_open("/tmp/SHM", (O_CREAT | O_RDWR), 0);
  108.     if(shm == -1)
  109.     {
  110.         perror("Creation SHM failed");
  111.     }
  112.     ftruncate(shm, 30);
  113.  
  114.     shm_ptr = mmap(0, 30, PROT_WRITE|PROT_READ,MAP_SHARED, shm, 0);
  115.     if(*shm_ptr == -1)
  116.     {
  117.         perror("MMAP failed");
  118.     }
  119.  
  120.     for(i=0;i<13;i++)
  121.     {
  122.         *(shm_ptr+i)=0;
  123.     }
  124.  
  125.     idPlongeur=fork();
  126.     if(!idPlongeur)
  127.     {
  128.         fctPlongeur(getpid());
  129.     }
  130.     tapis1=fork();
  131.     if(!tapis1)
  132.     {
  133.         fctTapis1(getpid());
  134.     }
  135.     tapis2=fork();
  136.     if(!tapis2)
  137.     {
  138.         fctTapis2(getpid());
  139.     }
  140.  
  141.     do
  142.     {
  143.  
  144.         u_act.act.Cp =*(shm_ptr + CP);
  145.         u_act.act.c1 =*(shm_ptr + C1);
  146.         u_act.act.c2 =*(shm_ptr + C2);
  147.         u_act.act.Aa =*(shm_ptr + AA);
  148.         u_act.act.Ga =*(shm_ptr + GA);
  149.         u_act.act.Pa =*(shm_ptr + PA);
  150.         u_act.act.Pv =*(shm_ptr + PV);
  151.         write(fd_petra_out, &u_act.byte, 1);
  152.         nanosleep(&tim,0);
  153.  
  154.     }while(sem_trywait(ptr_Fin)==-1);
  155.  
  156.     puts(" Fin des processus : tapis1, tapis2, plongeur");
  157.     kill(idPlongeur,SIGKILL);
  158.     kill(tapis1,SIGKILL);
  159.     kill(tapis2,SIGKILL);
  160.  
  161.     u_act.act.Cp =0;
  162.     u_act.act.c1 =0;
  163.     u_act.act.c2 =0;
  164.     u_act.act.Aa =0;
  165.     u_act.act.Ga =0;
  166.     u_act.act.Pa =0;
  167.     u_act.act.Pv =0;
  168.     write(fd_petra_out, &u_act.byte, 1);
  169.  
  170.     puts(" De-allocation m�moire partagee");
  171.     ret_val=munmap(shm_ptr,30);
  172.     if ( ret_val == -1 )
  173.     {
  174.         perror ( "\n\rMAIN : munmap failed !!!" );
  175.     }
  176.  
  177.     puts(" Fermeture m�moire partagee");
  178.     ret_val = close ( shm );
  179.     if ( ret_val == -1 )
  180.     {
  181.         perror ( "\n\rMAIN : close failed !!!" );
  182.     }
  183.  
  184.     puts(" Effacement de l'objet m�moire partagee");
  185.     ret_val = shm_unlink ( "/tmp/SHM" );
  186.     if ( ret_val == -1 )
  187.     {
  188.         perror ( "\n\rMAIN : shm_unlink failed !!!" );
  189.     }
  190.  
  191.     puts(" Destruction des semaphores");
  192.     /*sem_destroy(ptr_Fin);
  193.     sem_destroy(ptr_Tapis1);
  194.     sem_destroy(ptr_Tapis2);
  195.     sem_destroy(ptr_PrendrePiece);*/
  196.  
  197.     ret_val = sem_unlink ( "FIN" );
  198.         if ( ret_val == -1 )
  199.         perror ( "\n\rMAIN : sem_unlink failed !!!" ) ;
  200.  
  201.     ret_val = sem_unlink ( "TAPIS1" );
  202.         if ( ret_val == -1 )
  203.         perror ( "\n\rMAIN : sem_unlink failed !!!" ) ;
  204.  
  205.     ret_val = sem_unlink ( "TAPIS2" );
  206.         if ( ret_val == -1 )
  207.         perror ( "\n\rMAIN : sem_unlink failed !!!" ) ;
  208.  
  209.     ret_val = sem_unlink ( "PRENDREPIECE" );
  210.         if ( ret_val == -1 )
  211.         perror ( "\n\rMAIN : sem_unlink failed !!!" ) ;
  212.  
  213.     puts(" Fermeture programme");
  214.     close (fd_petra_out);
  215.     close (fd_petra_in);
  216.  
  217.     return 0;
  218. }
  219.  
  220. void fctPlongeur(pid_t pid)
  221. {
  222.     struct timespec tim;
  223.     tim.tv_sec = 0;
  224.     tim.tv_nsec = 300000000;
  225.  
  226.     while(sem_wait(ptr_PrendrePiece)==0)
  227.     {
  228.             tim.tv_sec = 0;
  229.             tim.tv_nsec = 500000000;
  230.  
  231.             read (fd_petra_in , &u_capt.byte , 1);
  232.             while(u_capt.capt.De == 1&&*(shm_ptr + PRISE)==0)
  233.             {
  234.                 read (fd_petra_in , &u_capt.byte , 1);
  235.                 nanosleep(&tim,0);
  236.             }
  237.  
  238.             if(*(shm_ptr + PRISE)==1)
  239.             {
  240.                 tim.tv_nsec = 100000000;
  241.                 tim.tv_sec = 0;
  242.  
  243.                 *(shm_ptr + CP) = 3;
  244.                 nanosleep(&tim,NULL);
  245.  
  246.                 //boucle tant que plongeur n'est Pas stable
  247.                 do
  248.                 {
  249.                     read (fd_petra_in , &u_capt.byte , 1);
  250.                 }while(u_capt.capt.Cs != 0);
  251.  
  252.                 *(shm_ptr + PA) = 1; //descendre
  253.                 nanosleep(&tim,NULL);
  254.  
  255.                 //tant que le plongeur n'est Pas arriv� en bas on boucle
  256.                 do
  257.                 {
  258.                     read (fd_petra_in , &u_capt.byte , 1);
  259.                 }while(u_capt.capt.Pp != 1);
  260.  
  261.                 sleep(1);
  262.                 *(shm_ptr + PV) = 1; // asspire la pi�ce
  263.                 nanosleep(&tim,NULL);
  264.  
  265.                 *(shm_ptr + PA) = 0; //remonte le plongeur
  266.  
  267.                 //boucle tant que le plongeur n'est Pas en position haute
  268.                 do
  269.                 {
  270.                     read (fd_petra_in , &u_capt.byte , 1);
  271.                 }while(u_capt.capt.Pp != 0);
  272.  
  273.                 *(shm_ptr + CP) = 2; //envoie le plongeur en position 2 au dessus de la poubelle
  274.                 nanosleep(&tim,NULL);
  275.  
  276.                 //boucle tant que plongeur n'est Pas en position 3
  277.                 do
  278.                 {
  279.                     read (fd_petra_in , &u_capt.byte , 1);
  280.                 }while(u_capt.capt.Cs != 0);
  281.  
  282.                 *(shm_ptr + PV) = 0;
  283.                 *(shm_ptr + CP) = 0;
  284.                 sleep(3);
  285.                 if(*(shm_ptr +NBPIECE)>=2)
  286.                     *(shm_ptr+TROU)=*(shm_ptr+STOCKTROU);
  287.                 puts("UNE PIECE SUPPRIME");
  288.                         *(shm_ptr+NBPIECE)=*(shm_ptr+NBPIECE)-1;
  289.                 *(shm_ptr+PRISE)=0;
  290.             }
  291.             else
  292.             {
  293.                 sleep(3);
  294.                 *(shm_ptr + PA) = 1;
  295.                 sleep(2);
  296.  
  297.                 *(shm_ptr + PV) = 1;
  298.                 sleep(1);
  299.  
  300.                 *(shm_ptr + PA) = 0;
  301.                 sleep(2);
  302.  
  303.                 *(shm_ptr + CP) = 1;
  304.  
  305.                 sleep(2);
  306.                 do
  307.                 {
  308.                     read (fd_petra_in , &u_capt.byte , 1);
  309.                     nanosleep(&tim,NULL);
  310.                 }while(u_capt.capt.Cs != 0);
  311.                 nanosleep(&tim,NULL);
  312.                 *(shm_ptr + PV) = 0;
  313.                 nanosleep(&tim,NULL);
  314.                 *(shm_ptr + CP) = 0;
  315.                 sem_post(ptr_Tapis1);
  316.             }
  317.         }
  318. }
  319.  
  320.  
  321. void fctTapis1(pid_t pid) // (2)
  322. {
  323.     struct timespec tim;
  324.     tim.tv_sec = 0;
  325.     tim.tv_nsec = 300000000;
  326.     int compteur;
  327.     int cmp;
  328.     int slotprec;
  329.  
  330.     while(sem_wait(ptr_Tapis1)==0)
  331.     {
  332.         tim.tv_nsec = 100000000;
  333.         tim.tv_sec = 0;
  334.         while(*(shm_ptr+10)==1)
  335.         {
  336.             nanosleep(&tim,NULL);
  337.         }
  338.         nanosleep(&tim,NULL);
  339.         puts("NOUVELLE PIECE");
  340.         *(shm_ptr +NBPIECE)=*(shm_ptr+NBPIECE)+1;
  341.         *(shm_ptr + AA) = 0;
  342.         *(shm_ptr + C1) = 1;
  343.         compteur=0;
  344.         cmp=0;
  345.         if(*(shm_ptr +NBPIECE)>=2)
  346.         {
  347.             *(shm_ptr+STOCKTROU)=0;
  348.         }
  349.             else
  350.         {
  351.             *(shm_ptr+TROU)=0;
  352.         }
  353.         sem_post(ptr_PrendrePiece);
  354.         while(compteur != 80) //Verification du slot si 4 changements alors slot ok
  355.         {
  356.             slotprec = u_capt.capt.s;
  357.             read (fd_petra_in , &u_capt.byte , 1);
  358.             if(u_capt.capt.s != slotprec)
  359.             {
  360.                 cmp++;
  361.             }
  362.             nanosleep(&tim,NULL);
  363.             compteur++;
  364.         }
  365.         if(cmp == 4)
  366.         {
  367.             if(*(shm_ptr +NBPIECE)>=2)
  368.             {
  369.                 *(shm_ptr+STOCKTROU)=1;
  370.                 puts("STOCKTROU");
  371.             }
  372.             else
  373.             {
  374.             *(shm_ptr+TROU) = 1;
  375.             *(shm_ptr+STOCKTROU)=1; //trouok
  376.             puts(" TROU OK");
  377.             }
  378.         }
  379.         else
  380.         {
  381.             puts(" TROU NOK");
  382.         }
  383.  
  384.         *(shm_ptr + C1) = 0;
  385.         *(shm_ptr + GA) = 1;
  386.         sleep(1);
  387.  
  388.         *(shm_ptr + AA) = 1;
  389.  
  390.         do
  391.         {
  392.             read (fd_petra_in , &u_capt.byte , 1);
  393.             nanosleep(&tim,NULL);
  394.         }while(u_capt.capt.Ap != 1);
  395.  
  396.         sleep(1);
  397.         sem_post(ptr_Tapis2);
  398.     }
  399. }
  400.  
  401. void fctTapis2(pid_t pid) // (3)
  402. {
  403.     struct timespec tim;
  404.     tim.tv_nsec = 500000000;
  405.     tim.tv_sec = 0;
  406.     int compteur;
  407.  
  408.     while(sem_wait(ptr_Tapis2)==0)
  409.     {
  410.         tim.tv_nsec = 100000000;
  411.         tim.tv_sec = 0;
  412.  
  413.         while(*(shm_ptr+10)==1)
  414.         {
  415.             nanosleep(&tim,NULL);
  416.         }
  417.  
  418.         *(shm_ptr + C2) = 1;
  419.         *(shm_ptr + GA) = 0;
  420.  
  421.         compteur=0;
  422.         *(shm_ptr+ENCOCHE)=1;
  423.         while(compteur != 58) //Verification de l'encoche
  424.         {
  425.             read (fd_petra_in , &u_capt.byte , 1);
  426.             while(u_capt.capt.L1 == 1)
  427.             {
  428.                 read (fd_petra_in , &u_capt.byte , 1);
  429.                 if(u_capt.capt.L2 == 1 && u_capt.capt.L1 == 1)
  430.                 {
  431.                     *(shm_ptr+ENCOCHE) = 0;
  432.                     puts(" ENCOCHE MAUVAISE ");
  433.                     fflush(stdin);
  434.                 }
  435.             }
  436.             nanosleep(&tim,NULL);
  437.             compteur++;
  438.         }
  439.  
  440.         if(*(shm_ptr + ENCOCHE)==0 || *(shm_ptr + TROU) == 0)
  441.         {
  442.             *(shm_ptr + PRISE)=1;
  443.             sleep(1);
  444.             *(shm_ptr + C2) = 0;
  445.             sem_post(ptr_PrendrePiece); // D�marre le grappin pour la mauvaise pi�ce
  446.         }
  447.         else
  448.         {
  449.         sleep(2);
  450.         puts("UNE PIECE SUPPRIMEE");
  451.         if(*(shm_ptr +NBPIECE)>=2)
  452.             *(shm_ptr+TROU)=*(shm_ptr+STOCKTROU);
  453.         *(shm_ptr +NBPIECE)=*(shm_ptr +NBPIECE)-1;
  454.         *(shm_ptr + C2) = 0;
  455.         }
  456.     }
  457. }
  458.  
  459. void handlerSIGINT(int sig)
  460. {
  461.     puts(" FIN PROGRAMME");
  462.     sem_post(ptr_Fin);
  463. }
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!