API tools faq
paste
Mark2020H

Void Realms 3 may 2020

Mark2020H
Apr 29th, 2020
850
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 12.60 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <time.h>
  5.  
  6. // gtk libraries
  7. #include <gtk/gtk.h>
  8. #include <glib.h>
  9. #include <glib/gprintf.h>
  10. #include <bcm2835.h>
  11.  
  12. /* Globale variables that must be seen by all  main and functions
  13.  * this is done so as to determine if when creating
  14.  * the timer that its has been created succesfully
  15.  * Hence we create variables timerID ,  and pointers to lbl_time
  16.  * and an int to hold seconds which we will print to the lbl_time
  17.  * defined in our glad file  using the event timertick
  18.  * This fires every 1000 ms  = 1 second
  19.  */
  20.  
  21. gint delay = -1 ;
  22. guint seconds = 0 ;
  23. guint timerId = 0;
  24.  
  25. guint switch_count = 0 ;
  26.  
  27. GtkWidget   *lbl_time  = NULL ;
  28. GtkWidget   *btnUpdate = NULL ;
  29. GtkWidget   *window    = NULL;
  30. GtkBuilder  *builder   = NULL;
  31. GError      *error     = NULL;
  32. GtkWidget   *spinhrs   = NULL;
  33. GtkWidget   *spinmins  =  NULL ;
  34. GtkWidget   *spinsecs  = NULL ;
  35. GtkWidget   *duration  = NULL ;
  36. GtkWidget   *lbl_alarm = NULL ;
  37. GtkWidget   *lbl_Time_left = NULL ;
  38. GtkWidget   *lbStatus  = NULL ;
  39.  
  40. // images  we need
  41. GtkWidget   *alarmImage = NULL ;
  42. GtkWidget   *Rm1Status = NULL ;
  43. GtkWidget   *Rm2Status = NULL ;
  44. GtkWidget   *Rm3Status = NULL ;
  45. GtkWidget   *Rm4Status = NULL ;
  46. GtkWidget   *Rm5Status = NULL ;
  47. GtkWidget   *Rm6Status = NULL ;
  48.  
  49. //  sw0 to sw5
  50.  
  51. GtkWidget   *sw0 = NULL ;
  52. GtkWidget   *sw1 = NULL ;
  53. GtkWidget   *sw2 = NULL ;
  54. GtkWidget   *sw3 = NULL ;
  55. GtkWidget   *sw4 = NULL ;
  56. GtkWidget   *sw5 = NULL ;
  57.  
  58.  
  59. GtkImage    *image = NULL   ;
  60. gboolean    running  = FALSE ;
  61. gboolean    alarmtrig =FALSE ; // tells us when alram triiggered
  62.  
  63. // The states of each switch
  64. gboolean    states[6] ;
  65.  
  66. // defines pins
  67.  
  68. #define PIN0 RPI_GPIO_P1_11     // gpio_0 pin 11
  69. #define PIN1 RPI_GPIO_P1_12     // gpio_1 pin 12
  70. #define PIN2 RPI_GPIO_P1_13     // gpio_2 this is on pin21
  71. #define PIN3 RPI_GPIO_P1_15     // gpio_3 pin 15
  72. #define PIN4 RPI_GPIO_P1_16     // gpio_4 pin 16
  73. #define PIN5 RPI_GPIO_P1_18     // gpio_5 pin 18
  74.  
  75.  
  76.  
  77. void debug (const char * data)
  78. {
  79.     g_print("%s called.\n",data);
  80. }
  81.  
  82. void quitBCM()
  83. {
  84.     bcm2835_gpio_write(PIN0, LOW);
  85.     bcm2835_gpio_write(PIN1, LOW);
  86.     bcm2835_gpio_write(PIN2, LOW);
  87.     bcm2835_gpio_write(PIN3, LOW);
  88.     bcm2835_gpio_write(PIN4, LOW);
  89.     bcm2835_gpio_write(PIN5, LOW);
  90.    
  91.     bcm2835_close();   
  92. }
  93.  
  94.  
  95. /*timer tick event handler */
  96.  
  97. gboolean timerTick(__attribute__((unused)) gpointer userData)
  98. {  
  99.    
  100.    
  101.    const gchar *alarmtext  ;
  102.    const gchar *currenttime ;
  103.    
  104.     char temp[9];
  105.     struct tm *now_tm;
  106.     time_t now;
  107.  
  108.      
  109.         // to get current time
  110.         time(&now) ;
  111.                 now_tm=localtime(&now) ;
  112.        
  113.             // print time in minutes,
  114.             // hours and seconds
  115.             sprintf(temp,"%02d:%02d:%02d" ,
  116.             now_tm->tm_hour,
  117.             now_tm->tm_min,      
  118.             now_tm->tm_sec) ;
  119.            
  120.             // update label
  121.             gtk_label_set_text(GTK_LABEL(lbl_time), temp);
  122.            
  123.                
  124.             // get values of alarmtext , currenttime     
  125.                
  126.             currenttime = gtk_label_get_text(GTK_LABEL(lbl_time)) ;
  127.            
  128.                
  129.                 if(running)
  130.                 {
  131.                     // compare time strings for equality
  132.                    alarmtext   = gtk_label_get_text(GTK_LABEL(lbl_alarm)) ;
  133.                    
  134.                    
  135.                     //  compare
  136.                     if (g_strcmp0(alarmtext, currenttime) == 0){
  137.                     g_print("Alarm activated  alarm is %s  Time is %s\n" , alarmtext ,currenttime ) ;
  138.                     gtk_image_set_from_file(GTK_IMAGE(alarmImage), "icons/Blue.ico");
  139.                     alarmtrig = TRUE ;
  140.                     gtk_label_set_text(GTK_LABEL(lbStatus), "Alarm Off" );  
  141.                     running = FALSE ;
  142.                     }
  143.                 }
  144.                
  145.                 if (alarmtrig)
  146.                 {
  147.                     switch(switch_count)
  148.                     {
  149.                     case 0 :
  150.                         gtk_switch_set_active(GTK_SWITCH(sw0),TRUE);
  151.                             switch_count+=1 ;
  152.                         break ;
  153.                     case 1:
  154.                             gtk_switch_set_active(GTK_SWITCH(sw1),TRUE);
  155.                                 switch_count+=1 ;
  156.                         break ;
  157.                            
  158.                     case 2:
  159.                         gtk_switch_set_active(GTK_SWITCH(sw2),TRUE);
  160.                                 switch_count+=1 ;
  161.                         break ;
  162.                    
  163.                     default :
  164.                         switch_count=0 ;
  165.                         alarmtrig = FALSE ;
  166.                         g_print("switch count  = %d \n" ,switch_count) ;
  167.                    
  168.                     }// end switch case
  169.                 }
  170.                
  171.     return TRUE;
  172.  
  173.  
  174. }
  175.  
  176. void on_destroy (__attribute__((unused)) GtkWidget *widget,__attribute__((unused)) gpointer data )
  177. {
  178.     debug(__FUNCTION__);
  179.     quitBCM() ;
  180.     bcm2835_close();
  181.     gtk_main_quit ();
  182. }
  183.  
  184. void on_BtnAlarm_Off_clicked (__attribute__((unused)) GtkWidget *widget,__attribute__((unused)) gpointer data )
  185. {
  186.      char status[10] = "Alarm Off" ;
  187.      
  188.      gtk_image_set_from_file(GTK_IMAGE(alarmImage), "icons/off.ico");
  189.      
  190.      gtk_label_set_text(GTK_LABEL(lbStatus), status);  
  191.      running = FALSE ;
  192. }
  193.  
  194. void on_btnAlarm_on_clicked(__attribute__((unused)) GtkWidget *widget,__attribute__((unused)) gpointer data )
  195. {  
  196.     // grab the image  
  197.      gtk_image_set_from_file(GTK_IMAGE(alarmImage), "icons/On.ico");
  198.      char status[10] = "Alarm  On" ;
  199.      gtk_label_set_text(GTK_LABEL(lbStatus), status);  
  200.      running = TRUE ;
  201. }
  202. void on_btnupdate_clicked (__attribute__((unused))GtkButton *btnupdate,__attribute__((unused))gpointer user_data)
  203. {
  204.     char  temp[9] ;
  205.     gdouble hrs = 0.0 ;
  206.     gdouble mins = 0.0 ;
  207.     gdouble secs =0.0 ;
  208.     gdouble f_delay = 0.0 ;
  209.    
  210.    
  211.    
  212.     hrs     = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinhrs)) ;
  213.     mins    = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinmins)) ;
  214.     secs    = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinsecs)) ;
  215.     f_delay  = gtk_spin_button_get_value(GTK_SPIN_BUTTON(duration));
  216.    
  217.     g_sprintf(temp,"%02d:%02d:%02d" , (int)hrs,(int)mins,(int)secs);
  218.    
  219.     gtk_label_set_text(GTK_LABEL(lbl_alarm), temp);  
  220.    
  221.     delay = (guint) f_delay ;
  222.     g_sprintf(temp,"%03d" ,(guint) f_delay) ;
  223.     gtk_label_set_text(GTK_LABEL(lbl_Time_left), temp);
  224. }
  225.  
  226.  
  227.     gboolean  on_id_sw5_state_set (__attribute__((unused))GtkSwitch *id_sw5,__attribute__((unused)) gpointer user_data)
  228.     {
  229.        
  230.        
  231.         states[5] = gtk_switch_get_active(GTK_SWITCH(id_sw5)) ;
  232.         if(states[5])
  233.         {
  234.             gtk_image_set_from_file(GTK_IMAGE(Rm6Status), "icons/On.ico");
  235.         bcm2835_gpio_write(PIN5, HIGH);
  236.         }
  237.         else
  238.             {
  239.                gtk_image_set_from_file(GTK_IMAGE(Rm6Status), "icons/off.ico");
  240.                bcm2835_gpio_write(PIN5, LOW);
  241.                  }
  242.                  
  243.                  
  244.         //g_print("State 5 = %d \n" , states[5]) ;
  245.                
  246.         return TRUE ;
  247.     }
  248.  
  249.     gboolean on_id_sw4_state_set (__attribute__((unused))GtkSwitch *id_sw4, __attribute__((unused))gpointer user_data)
  250.     {
  251.         //debug(__FUNCTION__);
  252.        
  253.         states[4] = gtk_switch_get_active(GTK_SWITCH(id_sw4)) ;
  254.            
  255.            if(states[4])
  256.            {
  257.             gtk_image_set_from_file(GTK_IMAGE(Rm5Status), "icons/On.ico");
  258.         bcm2835_gpio_write(PIN4, HIGH);
  259.            }
  260.               else
  261.             {
  262.                 gtk_image_set_from_file(GTK_IMAGE(Rm5Status), "icons/off.ico");
  263.                 bcm2835_gpio_write(PIN4, LOW);
  264.             }    
  265.            
  266.         // g_print("State 4 = %d \n" , states[4]) ;
  267.         return TRUE ;
  268.     }
  269.  
  270.     gboolean on_id_sw3_state_set (__attribute__((unused))GtkSwitch *id_sw3, __attribute__((unused))gpointer user_data)
  271.     {
  272.         //debug(__FUNCTION__);
  273.        
  274.         states[3] = gtk_switch_get_active(GTK_SWITCH(id_sw3)) ;
  275.        
  276.         if(states[3])
  277.         {
  278.             gtk_image_set_from_file(GTK_IMAGE(Rm4Status), "icons/On.ico");
  279.             bcm2835_gpio_write(PIN3, HIGH);
  280.         }
  281.            else {
  282.                  gtk_image_set_from_file(GTK_IMAGE(Rm4Status), "icons/off.ico");
  283.                  bcm2835_gpio_write(PIN3, LOW);
  284.             }
  285.            
  286.         // g_print("State 3 = %d \n" , states[3]) ;
  287.         return TRUE ;
  288.     }
  289.  
  290.     gboolean on_id_sw2_state_set (__attribute__((unused))GtkSwitch *id_sw2, __attribute__((unused))gpointer user_data)
  291.     {
  292.         //debug(__FUNCTION__);
  293.        
  294.         states[2] = gtk_switch_get_active(GTK_SWITCH(id_sw2)) ;
  295.        
  296.          if(states[2])
  297.          {
  298.             gtk_image_set_from_file(GTK_IMAGE(Rm3Status), "icons/On.ico");
  299.         bcm2835_gpio_write(PIN2, HIGH);
  300.        
  301.           }
  302.                else {
  303.                  gtk_image_set_from_file(GTK_IMAGE(Rm3Status), "icons/off.ico");
  304.                  bcm2835_gpio_write(PIN2, LOW);
  305.                     // g_print("State 2 = %d \n" , states[2]) ;
  306.             }
  307.        
  308.        
  309.         return TRUE ;
  310.     }
  311.  
  312.     gboolean on_id_sw1_state_set (__attribute__((unused))GtkSwitch *id_sw1, __attribute__((unused))gpointer user_data)
  313.     {  
  314.         //debug(__FUNCTION__);
  315.        
  316.         states[1] = gtk_switch_get_active(GTK_SWITCH(id_sw1)) ;
  317.        
  318.     if(states[1]){
  319.             gtk_image_set_from_file(GTK_IMAGE(Rm2Status), "icons/On.ico");
  320.             bcm2835_gpio_write(PIN1, HIGH);
  321.            }
  322.            else
  323.            {
  324.              gtk_image_set_from_file(GTK_IMAGE(Rm2Status), "icons/off.ico");
  325.             bcm2835_gpio_write(PIN1, LOW);
  326.            }
  327.                  
  328.        
  329.         //g_print("State 1 = %d \n" , states[1]) ;
  330.      
  331.         return TRUE ;  
  332.     }
  333.  
  334.     gboolean on_id_sw0_state_set (__attribute__((unused))GtkSwitch *id_sw0,__attribute__((unused)) gpointer user_data)
  335.     {  
  336.         //debug(__FUNCTION__);
  337.        
  338.         states[0] = gtk_switch_get_active(GTK_SWITCH(id_sw0)) ;
  339.        
  340.         if(states[0])
  341.         {
  342.             gtk_image_set_from_file(GTK_IMAGE(Rm1Status), "icons/On.ico");
  343.         bcm2835_gpio_write(PIN0, HIGH);
  344.             }
  345.         else
  346.         {
  347.           bcm2835_gpio_write(PIN0, LOW);
  348.           gtk_image_set_from_file(GTK_IMAGE(Rm1Status), "icons/off.ico");
  349.          
  350.              }
  351.                    
  352.        
  353.        
  354.        
  355.         //g_print("State 0 = %d \n" , states[0]) ;
  356.        
  357.         return TRUE ;
  358.     }
  359.  
  360.  
  361.  
  362.  
  363.  int main(int argc,char **argv)
  364.  {
  365.    
  366.     // set up all pins on  the RPI  and intialise port registers
  367.     if (!bcm2835_init())
  368.     {
  369.       return 1;
  370.     }
  371.     else
  372.     {
  373.      // Set the pin to be an output
  374.         bcm2835_gpio_fsel(PIN0, BCM2835_GPIO_FSEL_OUTP);    // gpio_0
  375.         bcm2835_gpio_fsel(PIN1, BCM2835_GPIO_FSEL_OUTP);    // gpio_1
  376.         bcm2835_gpio_fsel(PIN2, BCM2835_GPIO_FSEL_OUTP);    // gpio_2
  377.         bcm2835_gpio_fsel(PIN3, BCM2835_GPIO_FSEL_OUTP);    // gpio_3
  378.         bcm2835_gpio_fsel(PIN4, BCM2835_GPIO_FSEL_OUTP);    // gpio_4
  379.         bcm2835_gpio_fsel(PIN5, BCM2835_GPIO_FSEL_OUTP);    // gpio_5
  380.     }
  381.    
  382.    // calls gtk init and passes any paramamters to program
  383.    gtk_init(&argc , &argv);
  384.    
  385.     builder = gtk_builder_new();
  386.  
  387.     if( gtk_builder_add_from_file (builder,"ui/clock.glade" , NULL) == 0)
  388.      {
  389.          printf("gtk_builder_add_from_file FAILED\n");
  390.          g_print("%s\n",error->message);
  391.          return EXIT_FAILURE ;
  392.        
  393.      }
  394.    
  395.    // get all the widget components from the builder file
  396.    
  397.    
  398.     window          = GTK_WIDGET(gtk_builder_get_object (builder,"main_window"));
  399.         lbl_time        = GTK_WIDGET(gtk_builder_get_object (builder,"lbl_time"));
  400.         btnUpdate       = GTK_WIDGET(gtk_builder_get_object (builder,"btnupdate"));
  401.         spinhrs         = GTK_WIDGET(gtk_builder_get_object (builder,"spinHrs"));
  402.         spinmins        = GTK_WIDGET(gtk_builder_get_object (builder,"spinMinutes"));
  403.         spinsecs        = GTK_WIDGET(gtk_builder_get_object (builder,"spinSecs"));
  404.         duration        = GTK_WIDGET(gtk_builder_get_object (builder,"spinDuration"));
  405.         lbl_alarm       = GTK_WIDGET(gtk_builder_get_object (builder,"lbl_alarm"));
  406.         lbl_Time_left       = GTK_WIDGET(gtk_builder_get_object (builder,"lbl_delayOff "));
  407.         lbStatus            = GTK_WIDGET(gtk_builder_get_object (builder,"lbStatus"));
  408.        
  409.         /*  sw0 to sw5  for which rooms  you want to set via BCM header */
  410.        
  411.         sw0             = GTK_WIDGET(gtk_builder_get_object (builder,"id_sw0"));
  412.         sw1             = GTK_WIDGET(gtk_builder_get_object (builder,"id_sw1"));
  413.         sw2             = GTK_WIDGET(gtk_builder_get_object (builder,"id_sw2"));
  414.         sw3             = GTK_WIDGET(gtk_builder_get_object (builder,"id_sw3"));
  415.         sw4             = GTK_WIDGET(gtk_builder_get_object (builder,"id_sw4"));
  416.         sw5             = GTK_WIDGET(gtk_builder_get_object (builder,"id_sw5"));
  417.        
  418.         // get all images
  419.        
  420.         alarmImage      = GTK_WIDGET(gtk_builder_get_object (builder,"alarm_image"));
  421.         Rm1Status       = GTK_WIDGET(gtk_builder_get_object (builder,"Rm1Status"));
  422.         Rm2Status       = GTK_WIDGET(gtk_builder_get_object (builder,"Rm2Status"));
  423.         Rm3Status       = GTK_WIDGET(gtk_builder_get_object (builder,"Rm3Status"));
  424.         Rm4Status       = GTK_WIDGET(gtk_builder_get_object (builder,"Rm4Status"));
  425.         Rm5Status       = GTK_WIDGET(gtk_builder_get_object (builder,"Rm5Status"));
  426.         Rm6Status       = GTK_WIDGET(gtk_builder_get_object (builder,"Rm6Status"));
  427.        
  428.      // build signals table
  429.      gtk_builder_connect_signals(builder,NULL);
  430.      
  431.    
  432.      
  433.      g_object_unref(builder); // release recources
  434.      
  435.      // create a timer and  connect to event
  436.      if(timerId == 0){
  437.        timerId = g_timeout_add(1000,timerTick,NULL);
  438.      }
  439.      else
  440.     {       g_print("Already Running\n");
  441.        
  442.     }
  443.          
  444.      gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  445.      
  446.      gtk_widget_show_all (window);
  447.    
  448.      gtk_main();
  449.      
  450.    
  451.      
  452.      return EXIT_SUCCESS ;
  453.  }
Add Comment
Please, Sign In to add comment
Public Pastes
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!