Passing variables by reference to avoid global variables and extern - c++

Question

I have had written my program but it was relying solely on the use of global variables and extern. I have decided to work on fixing my code and make it as simple as possible. However, It seems to be going in the wrong direction. I have 3 structures that are used pretty much everywhere in my code:
item_inside_struct
device_info
encoder_struct.
I have written a wrapper for the tft display. The tft display must know all the states of the 3 structs since it is displaying everything on the screen. So I pass these structs to my tft functions as a reference. But since the tft functions are being called elsewhere in the code ( it could be main.c or even invoked in other source files), the structures must be passed to other functions that invoke tft methods as well.
For example: I have written sensor.c and sensor.h. It contains all the sensor functions. After the sensor is read, based on the sensor result, it may need to do update tft display hence I must pass all the structure data to the function that performs reading the sensor even though the function itself does not care about these 3 structures apart from the ftf update function. My sensor.c :
void Read_sensor_no_delay(item_inside_struct* item_inside, device_info* device, encoder_struct* encoder){
if(sensor_disable == 0){
if(strncmp(item_inside->state, "PILDYMAS", 8) != 0)
{
sensor = digitalRead(SENSOR);
if(sensor==LOW && sensor_prev_state==HIGH)// SENSOR ON
{
sensor_prev_state=LOW; // set the previous state to LOW
if (strncmp(item_inside->state,"ACTIVE",6)!=0){ // IF NUMBER TO PICK ITEMS IS 0, SET RED LIGHT TO SHOW OPERATOR WRONG BOX
handle_wrong_box(item_inside,device,encoder);
}
}
else if(sensor==HIGH && sensor_prev_state==LOW) //SENSOR DEACTIVATED
{
if(item_inside->num_to_pick > 0 && (strncmp(item_inside->state,"ACTIVE",6)==0) )// if number_to_pick >0, and device is activated, take items
{
handle_active_device(item_inside,device,encoder);
sensor_disable = 1;
lastMsg2 = millis();
}
else if(strncmp(item_inside->state,"ACTIVE",6)!=0)
{
handle_not_active_device(item_inside,device,encoder);
}
sensor_prev_state = HIGH;
}
}
}
else{
if (now - lastMsg2 > 4000)
{
//Serial.println("5 seconds passed");
sensor_disable=0;
}
}
}
void handle_wrong_box(item_inside_struct* item_inside, device_info* device, encoder_struct* encoder){
turn_ON_timer();
LED_strip_ON(red,PixelCount);
update_screen_colour(ST77XX_RED,item_inside,device,encoder);
}
void handle_active_device(item_inside_struct* item_inside, device_info* device, encoder_struct* encoder){
sensor_prev_state = HIGH;
item_inside->num_to_pick--;
item_inside->quantity--;
mb.Hreg(MAIN_REG, 12); //PUT 55 IN REG1
mb.Hreg(NUMBER_TO_PICK_REG, item_inside->quantity); // register 24
update_screen_colour(ST77XX_BLACK,item_inside,device,encoder);
strcpy(item_inside->state,"DONE");
turn_ON_timer2();
if(item_inside->quantity <=10)
{
}
return;
}
void handle_not_active_device(item_inside_struct* item_inside, device_info* device, encoder_struct* encoder){
turn_OFF_timer();
LED_strip_ON(black,PixelCount);
update_screen_colour(ST77XX_BLACK,item_inside,device,encoder);
sensor_prev_state = HIGH;
}
Notice the read_sensor_no_delay() function only needs to know about item_inside_struct, but does not care about device_info or encoder_struct, but I still must pass those to the function. Further down in read_sensor_no_delay() function the other function is calledhandle_wrong_box(). This function will redraw the display and display the new data therefore it must know all 3 structures.
My tft.c:
#include "tft_custom.h"
int screen_colour = ST77XX_BLACK ;
int local_quantity = 0;
int local_number_to_pick = 0;
char local_eeprom_serial[10]="NONE";
char local_current_status[20] = "NONE";
int local_displaycounter = 0;
char local_device_id[10] = "NONE";
char local_device_version[10] = "NONE";
char local_mqtt_server[20] = "NONE";
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);
void TFT_setup(){
tft.initR(INITR_BLACKTAB);
tft.setRotation(3);
tft.setTextColor(ST77XX_WHITE, ST77XX_BLACK);
tft.fillScreen(ST77XX_BLACK);
}
void TFT_display_update(item_inside_struct* item_inside,device_info* device, encoder_struct* encoder){
tft.setTextSize(4);
if(local_quantity != item_inside->quantity)
{
tft.setCursor(0, 0);
tft.fillRect(0,0, 80, 32, screen_colour);
local_quantity = item_inside->quantity;
tft.print(local_quantity); //quantity inside
}
if(local_number_to_pick != item_inside->num_to_pick)
{
tft.setCursor(0,32);
tft.fillRect(0,32, 40, 32, screen_colour);
local_number_to_pick = item_inside->num_to_pick;
tft.print(local_number_to_pick); // number2 means number to_pick
}
tft.setTextSize(1);
if(strcmp(local_device_version,device->device_version)!= 0)
{
tft.setCursor(120,0);
tft.fillRect(120,0, 10, 10, screen_colour);
strcpy(local_device_version,device->device_version);
tft.print(local_device_version); // number2 means number to_pick
}
if(strcmp(local_mqtt_server,device->mqtt_server)!= 0)
{
tft.setCursor(80,10);
tft.fillRect(80,10, 40, 5, screen_colour);
strcpy(local_mqtt_server,device->mqtt_server);
tft.print(local_mqtt_server); // number2 means number to_pick
}
tft.setTextSize(2);
if(strcmp(local_device_id,device->DEVICE_ID)!= 0){
tft.setCursor(40,60);
tft.fillRect(40,60, 50, 16, screen_colour);
strcpy(local_device_id,device->DEVICE_ID);
tft.print(local_device_id);
}
if(strcmp(local_current_status,item_inside->state)!= 0){
tft.setCursor(40,32);
tft.fillRect(40,32, 120, 16, screen_colour);
strcpy(local_current_status,item_inside->state);
tft.print(local_current_status);
}
if(strcmp(local_eeprom_serial,item_inside->serial) !=0)
{
tft.setCursor(40,76);
tft.fillRect(40,76, 120, 16, screen_colour);
strcpy(local_eeprom_serial, item_inside->serial);
tft.print(local_eeprom_serial); //print SERIAL id
}
if(local_displaycounter != encoder->displaycounter)
{
tft.setCursor(40,94);
tft.fillRect(40,94, 60, 16, screen_colour);
local_displaycounter = encoder->displaycounter;
tft.print(local_displaycounter/10); //print SERIAL id
}
}
void TFT_display(item_inside_struct* item_inside,device_info* device, encoder_struct* encoder){
//tft.fillRect(0,0, 160, 80, ST77XX_BLACK);
tft.setTextSize(4);
tft.setCursor(0, 0);
tft.print(item_inside->quantity); //quantity inside
tft.setCursor(0,32);
tft.print(item_inside->num_to_pick); // number2 means number to_pick
tft.setTextSize(1);
tft.setCursor(120,0);
tft.print(device->device_version);
tft.setCursor(80,10);
tft.print(device->mqtt_server); // number2 means number to_pick
tft.setTextSize(2);
tft.setCursor(64,32);
tft.print(item_inside->state);
tft.setCursor(40,60);
tft.print(device->DEVICE_ID);
tft.setCursor(40,76);
tft.print(item_inside->serial); //print SERIAL id
tft.setCursor(40,94);
tft.print(encoder->displaycounter/10); //print SERIAL id
}
void update_screen_colour(int background_colour,item_inside_struct* item_inside, device_info* device, encoder_struct* encoder)
{
screen_colour=background_colour;
tft.setTextColor(ST77XX_WHITE, background_colour);
tft.fillScreen(background_colour);
TFT_display(item_inside,device,encoder);
}
Now I pretty much pass these 3 structs to every single function in my code because at some point tft update method will be called. Could someone point me in the right direction how this ugly code could be improved?
Trying to write tft class
I have rewritten my tft.c and tft.h and learned quite a bit in the process.
My tft.c :
include "tft_custom.h"
//class constructor, pass the 3 structures here
TFT::TFT(item_inside_struct &item_inside, device_info &device, encoder_struct &encoder){
Serial.println("calling tft class constructor");
screen_colour = ST77XX_BLACK ;
local_quantity = 0;
local_number_to_pick = 0;
local_displaycounter = 0;
strcpy(local_eeprom_serial,"NONE");
strcpy(local_current_status,"NONE");
strcpy(local_device_id,"NONE");
strcpy(local_device_version,"NONE");
strcpy(local_mqtt_server,"NONE");
class_item_inside = &item_inside;
class_device = &device;
class_encoder = &encoder;
}
void TFT::begin(){
tft.initR(INITR_BLACKTAB);
tft.setRotation(3);
tft.setTextColor(ST77XX_WHITE, ST77XX_BLACK);
tft.fillScreen(ST77XX_BLACK);
}
void TFT::update_display_once(){
tft.setTextSize(4);
tft.setCursor(0, 0);
tft.print(class_item_inside->quantity); //quantity inside
tft.setCursor(0,32);
tft.print(class_item_inside->num_to_pick); // number2 means number to_pick
tft.setTextSize(1);
tft.setCursor(120,0);
tft.print(class_device->device_version);
tft.setCursor(80,10);
tft.print(class_device->mqtt_server); // number2 means number to_pick
tft.setTextSize(2);
tft.setCursor(64,32);
tft.print(class_item_inside->state);
tft.setCursor(40,60);
tft.print(class_device->DEVICE_ID);
tft.setCursor(40,76);
tft.print(class_item_inside->serial); //print SERIAL id
tft.setCursor(40,94);
tft.print(class_encoder->displaycounter/10); //print SERIAL id
}
void TFT::TFT_display_update(){
tft.setTextSize(4);
if(local_quantity != class_item_inside->quantity)
{
tft.setCursor(0, 0);
tft.fillRect(0,0, 80, 32, screen_colour);
local_quantity = class_item_inside->quantity;
tft.print(local_quantity); //quantity inside
}
if(local_number_to_pick != class_item_inside->num_to_pick)
{
tft.setCursor(0,32);
tft.fillRect(0,32, 40, 32, screen_colour);
local_number_to_pick = class_item_inside->num_to_pick;
tft.print(local_number_to_pick); // number2 means number to_pick
}
tft.setTextSize(1);
if(strcmp(local_device_version,class_device->device_version)!= 0)
{
tft.setCursor(120,0);
tft.fillRect(120,0, 10, 10, screen_colour);
strcpy(local_device_version,class_device->device_version);
tft.print(local_device_version); // number2 means number to_pick
}
if(strcmp(local_mqtt_server,class_device->mqtt_server)!= 0)
{
tft.setCursor(80,10);
tft.fillRect(80,10, 40, 5, screen_colour);
strcpy(local_mqtt_server,class_device->mqtt_server);
tft.print(local_mqtt_server); // number2 means number to_pick
}
tft.setTextSize(2);
if(strcmp(local_device_id,class_device->DEVICE_ID)!= 0){
tft.setCursor(40,60);
tft.fillRect(40,60, 50, 16, screen_colour);
strcpy(local_device_id,class_device->DEVICE_ID);
tft.print(local_device_id);
}
if(strcmp(local_current_status,class_item_inside->state)!= 0){
tft.setCursor(40,32);
tft.fillRect(40,32, 120, 16, screen_colour);
strcpy(local_current_status,class_item_inside->state);
tft.print(local_current_status);
}
if(strcmp(local_eeprom_serial,class_item_inside->serial) !=0)
{
tft.setCursor(40,76);
tft.fillRect(40,76, 120, 16, screen_colour);
strcpy(local_eeprom_serial, class_item_inside->serial);
tft.print(local_eeprom_serial); //print SERIAL id
}
if(local_displaycounter != class_encoder->displaycounter)
{
tft.setCursor(40,94);
tft.fillRect(40,94, 60, 16, screen_colour);
local_displaycounter = class_encoder->displaycounter;
tft.print(local_displaycounter/10); //print SERIAL id
}
}
void TFT::update_screen_colour(int background_colour)
{
screen_colour=background_colour;
tft.setTextColor(ST77XX_WHITE, background_colour);
tft.fillScreen(background_colour);
update_display_once();
}
and tft.h:
#ifndef TFT_CUSTOM_H
#define TFT_CUSTOM_H
#include "Adafruit_ST7735.h" // Hardware-specific library for ST7735
#include "SPI.h"
#include "Adafruit_GFX.h"
#include "definitions.h"
#define TFT_CS 5 // Hallowing display control pins: chip select
#define TFT_RST 4 // Display reset
#define TFT_DC 2 // Display data/command select
#define TFT_MOSI 19 // Data out
#define TFT_SCLK 18 // Clock out
class TFT
{
private:
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);
//create 3 pointers to the struct
item_inside_struct *class_item_inside;
device_info *class_device;
encoder_struct *class_encoder;
int screen_colour;
int local_quantity;
int local_number_to_pick;
char local_eeprom_serial[10];
char local_current_status[20];
int local_displaycounter;
char local_device_id[10] ;
char local_device_version[10];
char local_mqtt_server[20];
public:
TFT(item_inside_struct &item_inside, device_info &device, encoder_struct &encoder);
void begin();
void update_display_once();
void TFT_display_update();
void update_screen_colour(int background_colour);
};
#endif
In my main.c I create a class constructor and pass the 3 structures. Inside a class constructor, I create a pointers for all 3 structures and I use these 3 pointers throughout the whole class
my main.c:
TFT tft_object(item_inside, device, encoder);
void setup() {
Serial.begin(115200);
pinMode(SENSOR, INPUT); // sets the digital pin 13 as output
Expander_SETUP();
setup_leds();
tft_object.begin();
tft_object.update_display_once();
}
void loop() {
if(strncmp(item_inside.state, "PILDYMAS", 8) != 0)
{
Read_sensor_no_delay(tft_object);
}
Notice in my read_sensor_no_delay function, I pass this the tft object.
And inside the read_sensor function I want to be able to read and write to the class object structures as shown below:
void Read_sensor_no_delay(TFT &tft_object ){
sensor = digitalRead(SENSOR);
if(sensor==LOW && sensor_prev_state==HIGH)// SENSOR ON
{
if (strncmp(tft_object.class_item_inside->state,"ACTIVE",6)!=0){ // IF NUMBER TO PICK ITEMS IS 0, SET RED LIGHT TO SHOW OPERATOR WRONG BOX
handle_activation(tft_object);
}
else if(sensor==HIGH && sensor_prev_state==LOW) //SENSOR DEACTIVATED
{
handle_deactivation(tft_object);
}
}
Notice if (strncmp(tft_object.class_item_inside->state,"ACTIVE",6)!=0) inside read sensor function. However, I am getting an issue due to all the variables in my tft class declared as private. Is the only way to solve this issue declare the 3 pointers to the structure public?

Answer 1

There is no right answer of course. If you try to come up with one, a bunch of people will hop on and tell you why its wrong :-)
But, a few choices:
It's actually ok to have global variables. It makes it harder for people to understand the code and where values are coming from, etc, but it's technically not "wrong" (ie, it compiles so the compiler thinks its ok right?). You can also use goto statements as well, and that's considered "bad" by many as well.
Some code encapsulates local copies of variables they need to know about within static variables in a file. Then you can create an init_sensors() function that takes those three pointers and remembers them.
Another common mechanism, probably preferred by most in raw-C code, is to create a single pointer that encapsulates the three other structures and to pass that pointer around instead as the first argument to pretty much every function. This also future-proofs your code a bit in case you ever need to add a fourth. Something like:
struct foo_context {
item_inside_struct* item_inside;
device_info* device;
encoder_struct* encoder;
}
You're using C++ but much of the code feels more "C" like. Getting a better handle on the object oriented nature might be helpful as well and trying to encapsulate more of the functionality into the objects. IE, if the TFT* functions were wrapped inside a new TFT object, then you could create that object once, pass the pointers in during its constructor and have it memorize them while the class' instance is alive.

Answer 2

This is certainly not a complete answer, just a pointer towards separating responsibilities, which others mentioned already.
Let's see this part:
After the sensor is read, based on the sensor result, it may need to do update tft display hence I must pass all the structure data to the function
This smells bad. The code reading a sensor needs not know about the tft display. There may be multiple objects which would need to give some feedback or other reaction on the sensor's state change – displaying something, blinking some LED, beeping an acoustic signal, logging the event in some file, etc, etc. You just can't know all possible future objects which will need to be updated. And your code must not depend on classes representing those objects.
A solution can be a message broker – an object who knows different participants and transfers messages between them (see Message broker at Wikipedia). This can be simply an object of a main application class: the item_inside_struct can contain a pointer to an App object and that would be responsible for proper handling (i.e. dispatching) events to other devices.
Another approach may be an observer (see Observer pattern at Wikipedia) – all objects of different classes in your application, which may utilize changes of the sensor's state somehow, would register in the sensor class object (i.e. by appending themselves to the list) and will be notified whenever a change is recognized. Then each of them will produce appropriate response without being known in details to the sensor's class.