Updating variables and killing threads during thread execution - c++

Question

I am working on a raspberry pi project and want to have a parallel thread in my application that blinks an LED with different frequencies for different states of the application. I think this should be done by threads...
Basically I have an enum and couple of structs to define the states, the GPIO pins and the appropriate action when a status is required. Each status will blink a LED for a given number of times with predefined ON and OFF times.
Then there is a thread that keeps track of a global variable for current state.
My problem is, the function that performs the GPIO state change and On/OFF times using "sleep", sometimes need to be abruptly stopped and a new state be initiated.
How to approach this problem? Below is my very simplified version of code.
enum class Status { // Possible states of the application
Ok = 0,
ErrorNetwork,
NetworkOk
/* and more status! */
};
struct StatusPin { // Define a pin
std::string name;
const int number; // Pin number
};
// Define a pin and its action
struct StatusAction {
std::string name;
const StatusPin pin;
const unsigned int cycles;
const unsigned int millisOn;
const unsigned int millisOff;
};
// Create one pin
const StatusPin G_StatusLed = {
"Status LED",
2
};
// Map for status states
std::map<const Status, StatusAction> G_StatusMap = {
// One short blink
{Status::Ok,
{"Running", G_StatusLed, 1, 250, 0}},
// Blink 3 times with 500ms delay
{Status::ErrorNetwork,
{ "Network Error", G_StatusLed, 3, 500, 500}},
// Blink 6 times, 1 second high, 500ms low
{Status::NetworkOk,
{ "Network OK", G_StatusLed, 6, 1000, 500}}
/* and more states! */
}
const void performStatusAction(const StatusAction &action) {
for (int i = 0; i < action.cycles; i++) {
pi::digitalWrite(action.pin.number, 1); // Set high
// Sleep for high duration
std::this_thread::sleep_for(
std::chrono::milliseconds(action.millisOn));
pi::digitalWrite(action.pin.number, 0); // Set LOW
// Sleep for low duration
std::this_thread::sleep_for(
std::chrono::milliseconds(action.millisOff));
}
}
//------ GLOBAL VARIABLES ------\\
std::mutex mutex;
App::StatusAction* G_CurrentAction = nullptr; // Variable for status action
std::atomic<bool> G_AppRunning {true};
std::atomic<bool> G_StatusWorkerBusy {false};
//------- THREAD FUNCTION -------\\
void statusWorker() {
while(G_AppRunning) {
mutex.lock();
G_StatusWorkerBusy = true;
if(G_CurrentAction && !G_CurrentAction->name.empty()) {
performStatusAction(*G_CurrentAction);
// If OneShot, set point to null so that it does not repeat
if(G_CurrentAction->type == App::StatusActionType::OneShot) {
G_CurrentAction = nullptr;
} else {
spdlog::warn("StatusWorker NULLPTR");
}
}
G_StatusWorkerBusy = false;
mutex.unlock();
std::this_thread::sleep_for(1ms);
}
}
int main() {
init(); // Setup GPIO mode, etc...
std::thread threadStatus(statusWorker); // Start status thead
// Update thread variable and set
G_CurrentAction= &G_StatusMap.at(Status::Ok);
bool isAppDone = false;
// Main loop
while(!isAppDone) {
// do something long e.g. Check for network failed
// Set status to network error
G_CurrentAction= &G_StatusMap.at(Status::ErrorNetwork);
// Immidieatly after 1 second network is back, set new status
// Pervious status should stop and new status should be set
// How to cancel loop inside the statusWorker performStatusAction() ?
G_CurrentAction= &G_StatusMap.at(Status::NetworkOk);
/*
Do good stuff here and update status thread if necessary
*/
// At some point exit the loop
isAppDone = true;
}
// Clear up stuff
threadStatus.join();
return 0;
}

Answer 1

If I understand correctly, we want the LED status thread to notice anytime the app's gross state changes, so the thread can change its flashing/occulting pattern accordingly.
To do this, we can have a std::condition_variable representing the predicate "the state changed." Then, inside the status thread's loop, anytime we're idle we wait_for a signal on that condition variable (instead of sleep_for some time). If state has changed, we'll start over with a new pattern of flashing.
It'd look something like this:
std::condition_variable status_cv;
std::mutex m;
....
// inside status thread
while (G_AppRunning) {
std::unique_lock<std::mutex> locked(m);
// what is app state when we enter this pass?
Status status = G_CurrentStatus;
ActionStatus action = G_StatusMap.at(status);
for (int i = 0; i < action.cycles; i++) {
LED_on();
if (status_cv.wait_for(locked, action.millisOn, [] { return G_CurrentStatus != status; })) {
break; // start anew with a status pattern
}
LED_off();
if (status_cv.wait_for(locked, action.millisOff, [] { return G_CurrentStatus != status; })) {
break; // new state
}
}
}