user_interface.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 2010, Bosch LLC
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of Bosch LLC nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

//\Author Joerg Wagner, Philip Roan, Bosch LLC

//wxwidgets stuff
#include <wx/stattext.h>
#include <wx/statline.h>
#include <wx/checkbox.h>

//common stuff
#include "proximity_sensor_dashboard/user_interface.h"
#include "proximity_sensor_dashboard/skin.h"

#include <math.h>
#include <iostream>

//TODO:
//      - change the software to handle 192 instead of 191 sensors
//      - Implementation of error handling routines

MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size): wxFrame( NULL, -1, title, pos, size )
{
  //Timer to execute ros::spinOnce();
  timer_ = new wxTimer(this, skin_id::ID_TIMER);
  timer_->Start(250);
  Connect(skin_id::ID_TIMER, wxEVT_TIMER, wxTimerEventHandler(MyFrame::gridUpdate), NULL, this);
  
  //Menubar
  menubar = new wxMenuBar;
  file = new wxMenu;
  file->Append(skin_id::ID_About, wxT("&About..."));
  file->AppendSeparator();
  file->Append(wxID_EXIT, wxT("&Quit"));
  menubar->Append(file, wxT("&File"));
  SetMenuBar(menubar);
  
  Connect(skin_id::ID_About, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MyFrame::OnAbout));
  Connect(wxID_EXIT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MyFrame::OnQuit));

  wxBoxSizer* v_sizer = new wxBoxSizer( wxVERTICAL ); 
  views = new wxNotebook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxNB_TOP); 
  expert_panel = new wxPanel(views, wxID_ANY); // expert and debug information
  basic_panel = new wxPanel(views, wxID_ANY); // basic measurements
  
  //headline of Frame
  wxStaticText *headline = new wxStaticText(expert_panel, wxID_ANY, title,wxPoint(15,15));
  
  wxFont headline_font = headline->GetFont(); //Set Font of headline
  headline_font.SetWeight(wxBOLD);
  headline_font.SetPointSize(15);
  headline->SetFont(headline_font);
  
  //Line
  //wxStaticLine *sl1 = new wxStaticLine(expert_panel, wxID_ANY, wxPoint(15,40), wxSize(730,1));
  
  //Creates grid and sets size of cells
  const wxString col_title_[18] = { wxT("Adr"),
                                    wxT("Stat"),
                                    wxT("X"),
                                    wxT("Ini"),
                                    wxT("Limit"),
                                    wxT("U1"),
                                    wxT("U2"),
                                    wxT("U3"),
                                    wxT("Dyn"),
                                    wxT(""),
                                    wxT("SE-NR."),
                                    wxT(""),
                                    wxT("A"),
                                    wxT("B"),
                                    wxT("C"),
                                    wxT("D"),
                                    wxT("E") };
  grid = new wxGrid(expert_panel, wxID_ANY, wxPoint(30,85), wxSize(699, 770));
  grid->CreateGrid(skind_def::max_sensor_number, 16);
  
  grid->SetColLabelSize(30);
  grid->SetRowLabelSize(50);
  
  wxColour label_background_colour;
  label_background_colour = grid->GetLabelBackgroundColour();
  
  for(int i = 0; i < skind_def::max_sensor_number ; i++)//Sets Row Size + Sets backgroundcolour of column 8, 9 and  10 + set aligns position of text
  {
    grid->SetRowSize(i, 20);
    grid->SetCellBackgroundColour(i, 8, label_background_colour);
    grid->SetCellBackgroundColour(i, 10, label_background_colour);
    grid->SetCellBackgroundColour(i, 9, *wxWHITE);
    for(int j = 0; j < 16; j++)
    {
      grid->SetCellAlignment(i, j, wxALIGN_CENTRE, wxALIGN_CENTRE);
    }
  }
  
  for(int j = 0; j < 8 ; j++)//Sets Column Size (column 0-7)
  {
    grid->SetColSize(j, 50);
  }
  
  grid->SetColSize(8, 25);//Sets Column Size (column 8-10)
  grid->SetColSize(9, 80);
  grid->SetColSize(10, 25);
  
  for(int i = 11 ; i < 16 ; i++)//Sets Column Size (column 11-15)
  {
    grid->SetColSize(i, 20);
  }
  
  //sets Value of column-labels
  for(int k = 0; k < 16; k++)
  {
    grid->SetColLabelValue((k),col_title_[k+1]);
  }
  
  //Inserts sensor number in the  9th column, change text colour, set background colour
  for(int i = 0; i < skin_dat_.u8sensor_number_ ; i++)
  {
    grid->SetCellValue(i,9,wxString::Format(wxT("%i"),i+1));
    grid->SetCellTextColour(i,9,wxColour(255,255,0));
  }
  
  //Disables user manipulations
  grid->EnableEditing(false);
  grid->EnableDragRowSize(false);
  grid->EnableDragColSize(false);
  
  //Sets the number of pixels per scroll increment
  grid->SetScrollLineY(20);
  
  //Inserts the text of the first cell
  wxPoint first_cell_point;
  first_cell_point = grid->GetPosition();
  wxSize first_cell_size;
  first_cell_size.Set(grid->GetRowLabelSize(), grid->GetColLabelSize());
  wxColour background_colour = grid->GetLabelBackgroundColour();
  
  wxPanel *cover_first_cell = new wxPanel(expert_panel, wxID_ANY, first_cell_point, first_cell_size, wxSUNKEN_BORDER);
  cover_first_cell->SetBackgroundColour(background_colour);
  
  wxStaticText *first_cell_text = new wxStaticText(cover_first_cell, wxID_ANY, col_title_[0],wxPoint(10, 5), wxDefaultSize);
  
  wxFont grid_label_font = grid->GetLabelFont();
  first_cell_text->SetFont(grid_label_font);
  
  //Insert Cover for Col 8
  wxPanel *cover_col8 = new wxPanel(expert_panel, wxID_ANY, wxPoint(479, first_cell_point.y+28), wxSize(grid->GetColSize(8)+1,grid->GetRowSize(0)*38 + 10 - 28), wxSUNKEN_BORDER);
  cover_col8->SetBackgroundColour(background_colour);
  
  //Insert Cover for Col 10
  wxPanel *cover_col10 = new wxPanel(expert_panel, wxID_ANY, wxPoint(479 + grid->GetColSize(8) + grid->GetColSize(9), first_cell_point.y+28), wxSize(grid->GetColSize(8)+1,grid->GetRowSize(0)*38 + 10 - 28), wxSUNKEN_BORDER);
  cover_col10->SetBackgroundColour(background_colour);
  
  //Textlabel "X Col Bar"
  wxPanel *textlabel_x_col_bar = new wxPanel(expert_panel, wxID_ANY, wxPoint(479 + grid->GetColSize(8),first_cell_point.y - grid->GetColLabelSize()), wxSize(grid->GetColSize(9) + 1, grid->GetColLabelSize()), wxSUNKEN_BORDER);
  textlabel_x_col_bar->SetBackgroundColour(background_colour);
  
  wxStaticText *text_x_col_bar = new wxStaticText(textlabel_x_col_bar, wxID_ANY, wxT("X Col.Bar"),wxPoint(3, 5), wxDefaultSize);
  
  text_x_col_bar->SetFont(grid_label_font);
  
  //TextLabel "ErrorBar"
  wxPanel *textlabel_errorbar = new wxPanel(expert_panel, wxID_ANY, wxPoint(479 + grid->GetColSize(8) + grid->GetColSize(9)+ grid->GetColSize(10),first_cell_point.y - grid->GetColLabelSize()), wxSize(grid->GetColSize(11)*5 + 1, grid->GetColLabelSize()), wxSUNKEN_BORDER);
  textlabel_errorbar->SetBackgroundColour(background_colour);
  
  wxStaticText *text_errorbar = new wxStaticText(textlabel_errorbar, wxID_ANY, wxT("ErrorBar"),wxPoint(16, 5), wxDefaultSize);
  
  text_errorbar->SetFont(grid_label_font);
  
  //Checkbox for switch between Hex and Dec
  wxCheckBox *cb_hex_dec = new wxCheckBox(expert_panel, skin_id::ID_HEX, wxT("Hex"), wxPoint(100,55), wxDefaultSize);
  Connect(skin_id::ID_HEX, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler(MyFrame::OnCheck));
  cb_hex_dec->SetValue(false);
  bhex_ = cb_hex_dec->GetValue();
  
  //Statusbar (Go/NoGo, NoErr/Err)
  wxStaticText *text_status = new wxStaticText(expert_panel, wxID_ANY, wxT("Status:"),wxPoint(200, 57), wxDefaultSize);
  text_status->SetFont(grid_label_font);
  
  text_go_nogo = new wxStaticText(expert_panel, wxID_ANY, wxT(""),wxPoint(270, 57), wxDefaultSize, wxALIGN_CENTRE);
  text_err_noerr = new wxStaticText(expert_panel, wxID_ANY, wxT(""),wxPoint(320, 57), wxDefaultSize, wxALIGN_CENTRE);
  
  
  //Creating the address row
  
  for(int k = 0; k < skind_def::max_sensor_number; k++)
  {
    if(bhex_)
    {
      grid->SetRowLabelValue(k,hexadezimal(skin_dat_.u8readadr_lo_+256*skin_dat_.u8readadr_hi_+skind_def::anz_byte_per_sensor*k));
    }
    else
    {
      grid->SetRowLabelValue(k, wxString::Format(wxT("%i"),(skin_dat_.u8readadr_lo_+256*skin_dat_.u8readadr_hi_+skind_def::anz_byte_per_sensor*k)));
    }
  }
  



  // create basic panel
  wxBoxSizer* layout_v1 = new wxBoxSizer( wxVERTICAL );
  wxBoxSizer* layout_h1 = new wxBoxSizer( wxHORIZONTAL );  
  wxStaticText* basic_text = new wxStaticText(basic_panel, wxID_ANY, wxT("Welcome to the Basic Dashboard"));
  basic_text->SetFont(headline_font);
  
  basic_data = new wxGrid(basic_panel, wxID_ANY);
  basic_data->CreateGrid(skind_def::max_sensor_number, 3);

  //grid->SetColLabelSize(30);
  //grid->SetRowLabelSize(50)
  for( int i = 0; i < skind_def::max_sensor_number; i++ )
  {
    basic_data->SetRowSize(i, 20);
    for(int j = 0; j < 3; j++)
    {
      basic_data->SetCellAlignment(i, j, wxALIGN_CENTRE, wxALIGN_CENTRE);
    }
  }
  basic_data->SetColSize(0, 80);
  basic_data->SetColSize(1, 80);
  basic_data->SetColSize(2, 80);
  basic_data->SetColLabelValue( 0, wxT("Sensor") );
  basic_data->SetColLabelValue( 1, wxT("Value") );
  basic_data->SetColLabelValue( 2, wxT("Visual") );


  //Sets the number of pixels per scroll increment
  basic_data->SetScrollLineY(20);

  //Disables user manipulations
  basic_data->EnableEditing(false);
  basic_data->EnableDragRowSize(false);
  basic_data->EnableDragColSize(false);
  
  layout_v1->Add(basic_text, 0, wxEXPAND);
  layout_v1->Add(basic_data, 1, wxEXPAND);

  layout_h1->Add(layout_v1, 1, wxEXPAND);

  layout_v1->SetSizeHints(basic_panel);
  layout_h1->SetSizeHints(basic_panel);
  basic_panel->SetSizer(layout_h1);
  
  
  // create tabbed pane
  views->AddPage(basic_panel, wxT("Basic"));  // add basic
  views->AddPage(expert_panel, wxT("Expert")); // add expert
  
  v_sizer->Add(views, 1, wxEXPAND);
  SetSizer(v_sizer);


  //display initialze data
  publish_data_2_gui();
    
}


void MyFrame::gridUpdate(wxTimerEvent& evt)//trigger a new message callback
{
  ros::spinOnce();
  ROS_DEBUG("Update results grid.");
  publish_data_2_gui();//publish data to GUI
  
  if (!ros::ok())
  {
    Close();
  }
}


void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{
  Close(true);
}


void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
  wxMessageBox( wxT(".....      text  text  text     ....."), wxT("Proximity Sensor Dashboard from Bosch RTC"), wxICON_INFORMATION, this );
}


void MyFrame::OnCheck(wxCommandEvent& event)//switch between Hex and Dec
{
  if(bhex_)
  {
    bhex_ = false;
  }
  else
  {
    bhex_ = true;
  }
}


wxString MyFrame::hexadezimal(uint32_t conv_value)//convert a dec. value into a hex-string
{
  const wxString ziffern[16] = { wxT("0"),
                                 wxT("1"),
                                 wxT("2"),
                                 wxT("3"),
                                 wxT("4"),
                                 wxT("5"),
                                 wxT("6"),
                                 wxT("7"),
                                 wxT("8"),
                                 wxT("9"),
                                 wxT("A"),
                                 wxT("B"),
                                 wxT("C"),
                                 wxT("D"),
                                 wxT("E"),
                                 wxT("F") };
  int i = 0;
  wxString ts;
  
  ts = wxT("");
  for(i = 3 ; i >= 0 ; i--)
  {
    ts = ts + ziffern[((conv_value >> (4*i)) & (15))]; // 15 = 000FH = 1111B
  }
  return ts;
}


void MyFrame::publish_data_2_gui()
{
  ROS_DEBUG("Publishing data to GUI.");
  
  //clear gui if sensor number was changed
  if(skin_dat_.bsens_num_changed == true)
  {
    grid->ClearGrid();
    basic_data->ClearGrid();
    skin_dat_.bsens_num_changed = false;
    
    //Inserts sensor number in the  9th column, change text colour, set background colour
    for(int i = 0; i < skind_def::max_sensor_number ; i++)
    {
      grid->SetCellValue(i,9,wxString::Format(wxT("%i"),i+1));
      grid->SetCellTextColour(i,9,wxColour(255,255,0));

      basic_data->SetCellValue( i, 0, wxString::Format(wxT("%i"), i+1) );
    }

    //clear background colour
    for(int k = skin_dat_.u8sensor_number_; k < skind_def::max_sensor_number; k++)
    {
      grid->SetCellBackgroundColour(k, 9, *wxWHITE);//x Col.Bar
      grid->SetCellBackgroundColour(k, 11, *wxWHITE);//ErrorBar
      grid->SetCellBackgroundColour(k, 12, *wxWHITE);//ErrorBar
      grid->SetCellBackgroundColour(k, 13, *wxWHITE);//ErrorBar
      grid->SetCellBackgroundColour(k, 14, *wxWHITE);//ErrorBar
      grid->SetCellBackgroundColour(k, 15, *wxWHITE);//ErrorBar
    }
  }
  


  //check if publisher node is online (online: time stamp of the last subscription < (ceil(float(skin_dat_.u8sensor_number_) / 32.0) -1 ) * 0.1 + 0.3 ago)
  //1 Sens - 32 Sens            - limit : 0.25
  //33 Sens - 64 Sens   - limit : 0.35
  //65 Sens - 96 Sens   - limit : 0.45
  //97 Sens - 128 Sens  - limit : 0.55
  //129 Sens - 160 Sens         - limit : 0.65
  //161 Sens - 192 Sens         - limit : 0.75
  //determination of the limit: (ceil(float(skin_dat_.u8sensor_number_) / 32.0) -1 ) * 0.1 + 0.3
  
  ros::Time dcurrent_time = ros::Time::now();
  if( ( dcurrent_time > (skin_dat_.dtime_subscription_ + ros::Duration((ceil(float(skin_dat_.u8sensor_number_) / 32.0) -1 ) * 0.1 + 0.3))) )
  {
    skin_dat_.initialize_sensor_data();//reset data to initial values
    
    text_go_nogo->SetLabel(wxT(""));//status diplay is empty if publisher node is offline
    text_err_noerr->SetLabel(wxT(""));
  }
  else
  {
    //status diplay
    if(skin_dat_.bstatus_go_ == true)
    {
      text_go_nogo->SetLabel(wxT("Go"));
      text_go_nogo->SetForegroundColour(*wxGREEN);
    }
    else
    {
      text_go_nogo->SetLabel(wxT("NoGo"));
      text_go_nogo->SetForegroundColour(*wxRED);
    }
    
    if(skin_dat_.bstatus_err_ == false)
    {
      text_err_noerr->SetLabel(wxT("NoErr"));
      text_err_noerr->SetForegroundColour(*wxGREEN);
    }
    else
    {
      text_err_noerr->SetLabel(wxT("Err"));
      text_err_noerr->SetForegroundColour(*wxRED);
    }
  }
  
  //create new address-row depending on bhex_
  for(int l = 0; l < skind_def::max_sensor_number; l++)
  {
    if(bhex_)
    {
      grid->SetRowLabelValue(l,hexadezimal(skin_dat_.u8readadr_lo_+256*skin_dat_.u8readadr_hi_+skind_def::anz_byte_per_sensor*l));
    }
    else
    {
      grid->SetRowLabelValue(l, wxString::Format(wxT("%i"),(skin_dat_.u8readadr_lo_+256*skin_dat_.u8readadr_hi_+skind_def::anz_byte_per_sensor*l)));
    }
  }
  
  for(int k = 0; k < skin_dat_.u8sensor_number_; k++)
  {
    //publish skin_data to main grid (Col0 to Col7)
    for(int j = 0; j < 8; j++)
    {
      //write data to grid
      if(bhex_)
      {
        grid->SetCellValue(k,j,hexadezimal(skin_dat_.u8asensor_data_[k][j]));//convert data to hex-string
      }
      else
      {
        grid->SetCellValue(k,j,wxString::Format(wxT("%i"),skin_dat_.u8asensor_data_[k][j]));
      }

    }
    basic_data->SetCellValue( k, 1, wxString::Format(wxT("%i"), skin_dat_.u8asensor_data_[k][1] - skin_dat_.u8asensor_data_[k][2]) );
    
    
    //         Creating the ErrorBar
    
    //self diagnosis display for each sensor element (errorbar)
    //  green: no error
    //  red:   error found
    //  white: no sensor element
    //  error conditions:
    //    A: U2 > 32            (= berrcond_[0])
    //    B: U3 < 16            (= berrcond_[1])
    //    C: U3-U1 < 16         (= berrcond_[2])
    //    D: Err_IO = 1         (= berrcond_[3])
    //    E: ErrTMS = 1         (= berrcond_[4])
    //    U1 = sensor_data[k][4]
    //    U2 = sensor_data[k][5]
    //    U3 = sensor_data[k][6]
    //    Stat  = sensor_data[k][0]
    //    Limit = sensor_data[k][3]
    
    
    berrcond_[0] = ( (skin_dat_.u8asensor_data_[k][5]) > 32 );
    berrcond_[1] = ( (skin_dat_.u8asensor_data_[k][6]) < 16 );
    berrcond_[2] = ( ((skin_dat_.u8asensor_data_[k][6]) - (skin_dat_.u8asensor_data_[k][4])) < 16 );
    berrcond_[3] = ( ((skin_dat_.u8asensor_data_[k][0]) & 16) > 0 );    //masking of Stat: if ((sensor_data[k][0]) & 16)>0 -> Err_IO = 1
    berrcond_[4] = ( ((skin_dat_.u8asensor_data_[k][0]) & 32) > 0 );    //masking of Stat: if ((sensor_data[k][0]) & 32)>0 -> ErrTMS = 1
    
    wxColour errcol;
    
    for(int i = 0; i < 5; i++)
    {
      errcol = *wxWHITE;
      if((skin_dat_.u8sensor_number_ > 0) & (skin_dat_.u8sensor_number_ <= skind_def::max_sensor_number))//number of sensors:  0 < Sennr <= 192
      {
        if( ((skin_dat_.u8asensor_data_[k][0]) & 1) == 1)//(Sensorelement is evaluated)
        {
          if(berrcond_[i])
          {
            errcol = *wxRED;
          }
          else
          {
            errcol = *wxGREEN;
          }
        }
        grid->SetCellBackgroundColour(k, i + 11, errcol);
      }
    }
    
    //sensor element readings (X COL.BAR)
    //    Limit = sensor_data[k][3]
    //    X     = sensor_data[k][1]
    //    Ini   = sensor_data[k][2]
    
    //    Creating the X. Col.Bar
    
    float tr;
    wxColour statcol;
    
    if( skin_dat_.u8asensor_data_[k][3] != 0 )
    {
      tr = float ( (skin_dat_.u8asensor_data_[k][1]) - (skin_dat_.u8asensor_data_[k][2]) ) / float (skin_dat_.u8asensor_data_[k][3]); // tr = (X - Ini) / Limit
    }
    else
    {
      tr = 2;
    }
    
    
    if(tr > 0)
    {
      if(tr > 1)
      {
        tr = 1;
      }
      statcol.Set(int (tr * 255)*65536);
      grid->SetCellBackgroundColour(k, 9, statcol);
      basic_data->SetCellBackgroundColour(k, 2, statcol);
    }
    else
    {
      tr = -tr;
      if(tr > 1)
      {
        tr = 1;
      }
      statcol.Set(int (tr * 255));
      grid->SetCellBackgroundColour(k, 9, statcol);
      basic_data->SetCellBackgroundColour(k, 2, statcol);
    }
  }
  
  grid->ForceRefresh();
  basic_data->ForceRefresh();
}