phmonitor.g - The Monitor program in Photon

Cogent Tools Demo and Tutorials: Version 4.0
Prev | Chapter 3. View the Code | Next

# 3.7. `phmonitor.g` - The Monitor program in Photon

    /*--------------------------------------------------------------------
     * File:        phmonitor.g
     *
     * Description: Monitors and controls the PID Emulator.
     *
     * Functions:
     *                toggle_sym
     *                slider_callback
     *                accumulate_trends
     *                update_trends
     *                create_monitor
     *                main
     *------------------------------------------------------------------*/

    /*--------------------------------------------------------------------
     * Function:    toggle_sym
     * Returns:     t or nil
     * Description: Toggles a database point between 0 and 1 when a button
     *              is pressed.
     *------------------------------------------------------------------*/
    function toggle_sym(sym)
    {
      set (sym, eval(sym) == 0 ? 1 : 0);
      write_point (sym, eval(sym));
    }

    /*--------------------------------------------------------------------
     * Function:    slider_callback
     * Returns:     t or nil
     * Description: Attaches a callback and adds and exception function to
     *              a slider widget.  The callback writes a value to the
     *              datahub point specified, and the exception function
     *              assigns the value of the datahub point to the slider
     *              widget whenever the value of the point changes in the
     *              datahub.
     *------------------------------------------------------------------*/
    function slider_callback(sld, !pnt)
    {
      PtAttachCallback(sld, Pt_CB_SLIDER_MOVE,
                       `write_point(@pnt, ((@eval(sld)).gauge_value)));
      add_exception_function(eval(pnt),
                             `(@eval(sld)).gauge_value = (@eval(pnt)));
    }

    /* Assign each DataHub point a property value, which in this case is an
     * array.  These arrays will be used to hold a short history of each point,
     * allowing them to be plotted by the trend widget.
     */
    setprop (#SP_001, #tdata, make_array (0));
    setprop (#MV_001, #tdata, make_array (0));
    setprop (#PV_001, #tdata, make_array (0));

    /*--------------------------------------------------------------------
     * Function:    accumulate_trends
     * Returns:     t or nil
     * Description: Adds new data to property value arrays.  These arrays
     *              are property values for the variables that correspond
     *              to the DataHub points, and are used to update the trend
     *              widget.
     *------------------------------------------------------------------*/
    function accumulate_trends (syms...)
    {
      local data;
            with sym in syms do
            {
                    data = getprop (sym, #tdata);
                    data[length(data)] = eval (sym);
            }
    }

    /*--------------------------------------------------------------------
     * Function:    update_trends
     * Returns:     t or nil
     * Description: Assigns the most recent arrays to the trend widget.
     *------------------------------------------------------------------*/
    function update_trends (widget, syms...)
    {
      local        tarray = make_array (length(syms)), i = 0, sym;

      with sym in syms do
        tarray[i++] = getprop (sym, #tdata);
      widget.put_data(tarray);
      with sym in syms do
        shorten_array (getprop (sym, #tdata), 0);
    }

    /*--------------------------------------------------------------------
     * Function:    create_monitor
     * Returns:     doesnt' return
     * Description: Creates the Monitor window.
     *------------------------------------------------------------------*/
    function create_monitor ()
    {
      local wfile, window, monitor_win, slidesp, progmv, progpv;
      local slideauto, slidedp, numkp, numki, numkd, numprop, numint;
      local butam, butgood, butpoor, butosc, butout, butx;

      wfile = PhabReadWidgetFile(anyos_assign("monitor_widgetfile"));
      window = PhabCreateWidgets(wfile, nil, nil);
      monitor_win = PhabLookupWidget(window, #Ptmonitor, nil);
      slidesp = PhabLookupWidget(window, #PtSliderSP, nil);
      slideclr = PhabLookupWidget(window, #RtProgressColor, nil);

      butam = PhabLookupWidget(window, #PtOnOffButtonAutomode, nil);
      numfreq = PhabLookupWidget(window, #PtNum1, nil);
      numkp = PhabLookupWidget(window, #PtNum2, nil);
      numki = PhabLookupWidget(window, #PtNum3, nil);
      numkd = PhabLookupWidget(window, #PtNum4, nil);
      numprop = PhabLookupWidget(window, #PtNum5, nil);
      numint = PhabLookupWidget(window, #PtNum6, nil);

      butgood = PhabLookupWidget(window, #PtToggleGood, nil);
      butpoor = PhabLookupWidget(window, #PtTogglePoor, nil);
      butosc = PhabLookupWidget(window, #PtToggleOscillating, nil);
      butout = PhabLookupWidget(window, #PtToggleOOC, nil);
      labprop = PhabLookupWidget(window, #PtLabelPropVal, nil);
      progmv = PhabLookupWidget(window, #ProgressMV, nil);
      progpv = PhabLookupWidget(window, #ProgressPV, nil);
      trend1 = PhabLookupWidget(window, #Trend1, nil);

      slidesp.gauge_value = read_point(#SP_001);
      slideclr.gauge_value = read_point(#SP_001);
      progmv.gauge_value = read_point(#MV_001);
      progpv.gauge_value = read_point(#PV_001);
      butam.onoff_state = read_point(#AUTO_001);

      numfreq.numeric_value = read_point(#FREQ_001);

      anyver_numeric_assign(numkp, numki, numkd, numprop, numint);

      add_exception_function(#AUTO_001, `(@butam).onoff_state = AUTO_001);
      add_exception_function(#SP_001, `(@slideclr).gauge_value = SP_001);
      add_echo_function(#SP_001, `(@slideclr).gauge_value = SP_001);
      add_exception_function(#MV_001, `(@progmv).gauge_value = MV_001);
      add_exception_function(#PV_001, `(@progpv).gauge_value = PV_001);

      slider_callback (slidesp, #SP_001);

      attach_msg(monitor_win, "3", "1");
      attach_msg(slidesp, "3.1a", "3");
      attach_msg(butam, "3.1", "3");
      attach_msg(numfreq, "3.2", "3");
      attach_msg(numkp, "3.3", "3");
      attach_msg(numki, "3.4", "3");
      attach_msg(numkd, "3.5", "3");
      attach_msg(numprop, "3.6", "3");
      attach_msg(numint, "3.7", "3");
      attach_msg(butgood, "3.8", "3");
      attach_msg(butpoor, "3.9", "3");
      attach_msg(butosc, "3.10", "3");
      attach_msg(butout, "3.11", "3");

      anyver_num_callback (numfreq, #FREQ_001);
      anyver_num_callback (numkp, #PID1_Kp);
      anyver_num_callback (numki, #PID1_Ki);
      anyver_num_callback (numkd, #PID1_Kd);
      anyver_num_callback (numprop, #PROP_001);
      anyver_num_callback (numint, #INT_001);

      PtAttachCallback(butgood, Pt_CB_ACTIVATE,
                       `anyos_change_settings(t, @numfreq, 4, @numkp, .05,
                                              @numki, .45, @numkd, .05,
                                              @numprop, .7, @numint, 1.0,
                                              3.8, @butam));

      PtAttachCallback(butpoor, Pt_CB_ACTIVATE,
                       `anyos_change_settings(t, @numfreq, 10, @numkp, .05,
                                              @numki, .70, @numkd, .05,
                                              @numprop, .7, @numint, 5.0,
                                              3.8, @butam));

      PtAttachCallback(butosc, Pt_CB_ACTIVATE,
                       `anyos_change_settings(nil, @numfreq, 10, @numkp, .05,
                                              @numki, 1.37, @numkd, .05,
                                              @numprop, .7, @numint, .54,
                                              3.8, @butam));

      PtAttachCallback(butout, Pt_CB_ACTIVATE,
                       `anyos_change_settings(nil, @numfreq, 10, @numkp, .05,
                                              @numki, .45, @numkd, 1.00,
                                              @numprop, .7, @numint, .54,
                                              3.8, @butam));

      PtAttachCallback(butam, Pt_CB_ONOFF_NEW_VALUE, `toggle_sym(#AUTO_001));

      butx = PhabLookupWidget(window, #Ptxbut, nil);
      PtAttachCallback(butx, Pt_CB_ACTIVATE, #exit_program(-1));

      /* Set up the trend widget.  We must set the trend resources in the
       * order below to ensure that the trend widget knows what to do with
       * the line colors.  We want 3 traces, in the same colors that the
       * designer set when creating the slider and progress bars in the
       * Photon App Builder.
       */
      trend1.trend_count = 3;
      trend1.trend_color_list = array (slideclr.progress_bar_color,
                                       progmv.progress_bar_color,
                                       progpv.progress_bar_color);
      trend1.trend_attributes = array (1, 2, 3);

      /* Animate trends every tenth of a second.  The trend data arrays are
       * stored in the property lists of the associated database variables.
       * We can accumulate trend data faster than we display it by changing
       * the rates of accumulation and update.  It does not make sense to display
       * trend data faster than about 27Hz, because the eye cannot distinguish
       * anything beyond that from smooth motion.  In reality, 10Hz is plenty.
       */
      every (0.1, #accumulate_trends (#SP_001, #MV_001, #PV_001));
      every (0.1, #update_trends (trend1, #SP_001, #MV_001, #PV_001));

      monitor_win.SetPos(360, 10);
        PtRealizeWidget(monitor_win);
      send_message("nsnames");

    //  PtMainLoop();
      while(t) next_event();

    }

    /*--------------------------------------------------------------------
     * Function:    main
     * Returns:
     * Description:
     *------------------------------------------------------------------*/
    function main()
    {
      /* Get access to the library of common functions. */
      require("lib/common.g");

      program_startup("monitor", "monq", #create_monitor(), "3");
    }

Prev | Home | Next
`gtkmonitor.g` - The Monitor program in GTK | Up | `gtklog.g` - The Log program in GTK

Copyright 1995-2002 by Cogent Real-Time Systems, Inc.