Raspberry Pi Weighting Control System
This project serves as a simple weighting control system, that was realized as a Bachelor Thesis
user_workspace.h
Go to the documentation of this file.
1 #ifndef USER_WORKSPACE_H
2 #define USER_WORKSPACE_H
3 
4 #include <memory>
5 #include <string>
6 #include <ctime>
7 #include <vector>
8 #include "rfid_reader.h"
9 #include "hx711/common.h"
10 
16  public:
17  unsigned long id;
18  unsigned long measurement_number;
19  unsigned long measuree_id;
20  std::tm measuring_start;
21 
22  const char* get_header_label();
23 
24  private:
25  std::string label;
26 };
27 
28 class user_workspace; // defined later, due to changes its required in measurement
29 
34 class measurement {
35  public:
36  // this follows db structure
37  unsigned long id;
38  // uint8_t status; // isn't selected from db and isn't used anywhere anyway
39  unsigned long measurement_number;
40  unsigned long measurement_part = 1;
41  unsigned long measuree_id;
42  unsigned long measurer_id;
43  unsigned long measuring_length; // in microsec (us)
44  std::tm measuring_start;
45  std::tm measuring_end;
46  std::string description;
47  // std::string unit; // not required, raw numbers don't need to know unit to convert
48  uint8_t value_length;
49  unsigned long value_count;
50  std::vector<double> values; // in grams, only available for single measurements
51  // double raw_avg; // redundant - same as all_val_avg
52  double x_val_med; // in grams
53  double x_val_avg; // in grams
54  double all_val_med; // in grams
55  double all_val_avg; // in grams
56  std::tm created_at;
57 
58  // continuous
59  bool continuous = false;
60  int cont_measurements; // number of measurements (parts) taken during continous measurement
61 
62 
63  // convinience vars - these are used in GUI
64  HX711::Mass::Unit current_unit = HX711::Mass::Unit::G;
65  std::string x_val_med_str;
66  std::string x_val_avg_str;
67  std::string all_val_med_str;
68  std::string all_val_avg_str;
69  std::string measuree_uname;
70  std::string measurer_uname;
71  std::string length_str;
72  std::string start_str;
73  std::string end_str;
74 
75 
77  static void init_simple_measuring(measurement *m, std::vector<double> &values);
79  static void init_measuring(measurement *m, user_workspace *uspace, std::vector<double> &values,
80  std::tm *start_tm, std::tm *end_tm, unsigned long m_length);
82  static void calc_measuring_results(measurement *m);
84  static void prepare_continuous_to_picked(std::vector<measurement> &ms, measurement* picked);
85 
92  static std::pair<double, double> calc_every_x_values_stats(measurement *m);
93 
99  static std::pair<double, double> calc_all_values_stats(measurement *m);
100 
104  void init_value_strings();
106  void init_start_end_strings();
108  void init_convinience_vars(const char* measurer_uname, const char* measuree_uname);
110  int compare(measurement* m);
111 };
112 
118 class user_cont {
119  public:
120  unsigned long id;
121  unsigned long measure_count;
122  std::string rfid_serial;
123  uint8_t rfid_serial_bin[10];
124  uint8_t rfid_ser_len;
125  std::string username;
126  std::string name;
127  std::string lastname;
128  std::string description;
129  uint8_t role;
130  std::tm reg_date;
133  std::tm date_of_birth;
134 
136  std::vector<std::unique_ptr<measurement_header>> measur_headers;
137 
142  user_cont(unsigned long, uint8_t*, uint8_t, std::string, std::string, std::string,
143  std::string, uint8_t, std::tm, std::tm, std::tm, std::tm);
145  void log_user_to_debug();
146 }; // user_container, not using namespace hence user_cont as name instead of just "user"
147 
153  public:
154  // user loaded by user_logged (emp. can login pac. under them to measure/ view result)
155  std::unique_ptr<user_cont> subuser;
156  std::unique_ptr<measurement> measured;
157  std::unique_ptr<measurement> picked;
158 
159  std::vector<measurement> continuous_m;
160  std::unique_ptr<measurement> continuous_front;
161 
167  user_workspace(user_cont* user);
168 
170  void init_measured(std::vector<double> values, std::tm *start_tm, std::tm *end_tm, unsigned long m_length);
177 
178  bool has_user();
179  bool has_subuser();
180  std::pair<uint8_t*, uint8_t> get_rfid_serial();
181  unsigned long get_user_id();
182  user_cont* get_user();
183  std::string& get_username();
184  std::string& get_name();
185  std::string& get_lastname();
186  std::string& get_description();
187  uint8_t get_role();
188  const char* get_role_string();
190  std::vector<std::unique_ptr<measurement_header>>& get_user_measur_headers();
191 
193  unsigned long get_measured_id();
194  std::string& get_measured_username();
196  private:
197  std::unique_ptr<user_cont> user;
198 };
199 
200 
201 #endif
Serves as container for basic measurement information, that is dispayed to GUI.
unsigned long measuree_id
unsigned long measurement_number
const char * get_header_label()
unsigned long id
Container for measurement data and (convenience) variables, that are used to show measurement in GUI.
unsigned long measuring_length
static std::pair< double, double > calc_every_x_values_stats(measurement *m)
Calculates the median of medians and avarages of avarages of every X values (X is a defined constant ...
unsigned long id
uint8_t value_length
std::string all_val_avg_str
std::string length_str
int compare(measurement *m)
unsigned long measurement_part
std::vector< double > values
static void prepare_continuous_to_picked(std::vector< measurement > &ms, measurement *picked)
unsigned long value_count
std::tm created_at
HX711::Mass::Unit current_unit
void log_measurement_to_debug()
std::string end_str
void init_convinience_vars(const char *measurer_uname, const char *measuree_uname)
std::string all_val_med_str
std::tm measuring_end
double all_val_med
double all_val_avg
void init_start_end_strings()
static void init_simple_measuring(measurement *m, std::vector< double > &values)
std::string x_val_med_str
unsigned long measuree_id
std::string description
int cont_measurements
static std::pair< double, double > calc_all_values_stats(measurement *m)
Calculates the median and avarage of all values.
unsigned long measurer_id
std::tm measuring_start
std::string start_str
double x_val_avg
double x_val_med
static void init_measuring(measurement *m, user_workspace *uspace, std::vector< double > &values, std::tm *start_tm, std::tm *end_tm, unsigned long m_length)
static void calc_measuring_results(measurement *m)
std::string x_val_avg_str
std::string measurer_uname
void init_value_strings()
std::string measuree_uname
unsigned long measurement_number
Class used as a container for user data, that are selected from database. (and also for insert,...
std::string lastname
uint8_t role
user_cont(unsigned long, uint8_t *, uint8_t, std::string, std::string, std::string, std::string, uint8_t, std::tm, std::tm, std::tm, std::tm)
Construct a new user cont object through value parameters, but this isn't used. Originally inteded fo...
std::string username
void log_user_to_debug()
unsigned long id
std::tm last_login_date
std::vector< std::unique_ptr< measurement_header > > measur_headers
std::tm reg_date
std::tm date_of_birth
unsigned long measure_count
std::tm created_at_date
std::string rfid_serial
std::string description
uint8_t rfid_serial_bin[10]
std::string name
uint8_t rfid_ser_len
Container that servers for storing users data and manipulating them.
std::vector< measurement > continuous_m
unsigned long get_user_id()
void init_measured(std::vector< double > values, std::tm *start_tm, std::tm *end_tm, unsigned long m_length)
std::string & get_username()
std::string & get_lastname()
int compare_rfid_serials(rfid_reader::rfid_tag *tag)
std::unique_ptr< user_cont > subuser
user_cont * get_user()
unsigned long get_measured_id()
std::unique_ptr< measurement > measured
std::unique_ptr< measurement > continuous_front
std::string & get_description()
measurement * get_last_hx_measuring()
std::vector< std::unique_ptr< measurement_header > > & get_user_measur_headers()
std::string & get_measured_username()
std::unique_ptr< measurement > picked
user_cont * get_measured_user()
const char * get_role_string()
measurement * get_picked_hx_measuring()
std::string & get_name()
std::pair< uint8_t *, uint8_t > get_rfid_serial()
user_workspace(user_cont *user)
Construct a new user workspace object. This can only be done with a user that is logged in.
RFID tag structure. Stores data read from SPI.
Definition: rfid_reader.h:12