1. tilakone switch-case rakenteella

#ifndef CONSTANDENUM_H
#define CONSTANDENUM_H
enum CycleState {Alkutila,TilaAskel1,TilaAskel2,Odotus_1,Odotus_2,Keskeytystila,PaluuAlkutilaan};
#endif // CONSTANDENUM_H

#ifndef TILAKONE_H
#define TILAKONE_H

#include <QObject>
#include "ConstAndEnum.h"

class Tilakone : public QObject
{
Q_OBJECT
private:
    CycleState tilakoneenTila;//asetetaan privateksi, jottei muut oliot pääse käsiksi
    int Laskuri;
public:
    explicit Tilakone(QObject *parent = 0);
    void AlkutilanToimenpiteet();
    void Alustus();
    void Askel_1_Toimenpiteet();
    void Askel_2_Toimenpiteet();
    void Odottelutila1Toimenpiteet();
    void Odottelutila2Toimenpiteet();
    void ToimintoKeskeytetty();
    void TilatAjettuLoppuun();
    void PaluuAlkuun();
    int TilojenSuoritus(int Komento);
    void KeskeytetynTilanToiminnot();
    int AnnaLaskurinArvo();
signals:
    void TilaSignaali(CycleState,QString);
public slots:
};

#endif // TILAKONE_H

#include "tilakone.h"

Tilakone::Tilakone(QObject *parent) :
    QObject(parent)
{
    Laskuri=0;
    tilakoneenTila=Alkutila;
}

//välitetään yksityisen laskurin arvo kutsujalle
int Tilakone::AnnaLaskurinArvo()
{
    return Laskuri;
}

void Tilakone::Alustus()
{
    //alustukset
}

void Tilakone::AlkutilanToimenpiteet()
{
   //alkutilan toimenpiteet
}

void Tilakone::Askel_1_Toimenpiteet()
{
    Laskuri++;
    //tilassa jatkuvasti tehtävät asiat
}

void Tilakone::Askel_2_Toimenpiteet()
{
    Laskuri--;
      //tilassa jatkuvasti tehtävät asiat
}

void Tilakone::Odottelutila1Toimenpiteet()
{
    //pysayta kone
}

void Tilakone::Odottelutila2Toimenpiteet()
{
    //pysayta kone
}

void Tilakone::ToimintoKeskeytetty()
{
    //keskeyta askellus

}

void Tilakone::TilatAjettuLoppuun()
{
    //ohjelmasykli valmis
}

void Tilakone::PaluuAlkuun()
{
    //tilakoneenTila=Alkutila;
    Laskuri--;

   //jos tarvetta
}

void Tilakone::KeskeytetynTilanToiminnot()
{

}
//Alkutila,TilaAskel1,TilaAskel2,odotus_1,odotus_2,
//                 kesketystila,valmistila,paluutila};

int Tilakone::TilojenSuoritus(int Komento)//1 start 2 odotus 3 keskeytys 4 paluu keskeytyksestä tai odotuksesta
{
    switch (tilakoneenTila)
    {  //!odotustila ja alustus
        case  Alkutila :
            AlkutilanToimenpiteet();
            if(Komento==1){
                tilakoneenTila=TilaAskel1;
                emit TilaSignaali(TilaAskel1,trUtf8("Tila yksi"));
            }
        break;
        case  TilaAskel1:
            Askel_1_Toimenpiteet();
            if(Laskuri>99){
                tilakoneenTila=TilaAskel2;
                emit TilaSignaali(TilaAskel2,trUtf8("Tila kaksi"));
            }
            if(Komento==2){
                tilakoneenTila=Odotus_1;
                emit TilaSignaali(Odotus_1,trUtf8("odotus tila"));
            }
            if(Komento==3){
                tilakoneenTila=Keskeytystila;
                emit TilaSignaali(Keskeytystila,trUtf8("Testi keskeytetty"));
            }
        break;
        case  TilaAskel2:
            Askel_2_Toimenpiteet();
            if(Laskuri<1){
                tilakoneenTila=Alkutila;
                emit TilaSignaali(Alkutila,trUtf8("alkutila"));
            }
            if(Komento==2){
                tilakoneenTila=Odotus_2;
                emit TilaSignaali(Odotus_2,"odotus tila");
            }
            if(Komento==3){
                tilakoneenTila=Keskeytystila;
                emit TilaSignaali(Keskeytystila,"Testi keskeytetty");
            }
        break;

        case  Odotus_1:
            Odottelutila1Toimenpiteet();
            if(Komento==1) {
                tilakoneenTila=TilaAskel1;
                emit TilaSignaali(TilaAskel1,"Tila yksi");
            }
            if(Komento==3){
                tilakoneenTila=Keskeytystila;
                emit TilaSignaali(Keskeytystila,"Testi keskeyetty");
            }
            if(Komento==4){
                tilakoneenTila=PaluuAlkutilaan;
                emit TilaSignaali(PaluuAlkutilaan,"Paluu alkutilaan");
            }
        break;
        case  Odotus_2:
            Odottelutila2Toimenpiteet();
            if(Komento==1) {
                tilakoneenTila=TilaAskel2;
                emit TilaSignaali(TilaAskel2,"Tila kaksi");
            }
            if(Komento==3){
                tilakoneenTila=Keskeytystila;
                emit TilaSignaali(Keskeytystila,"Testi keskeyetty");
            }
            if(Komento==4){
                tilakoneenTila=PaluuAlkutilaan;
                emit TilaSignaali(PaluuAlkutilaan,"Paluu alkutilaan");
            }
        break;
        case Keskeytystila:
            KeskeytetynTilanToiminnot();
            if(Komento==4){
                tilakoneenTila=PaluuAlkutilaan;
                emit TilaSignaali(PaluuAlkutilaan,"Paluu alkutilaan");
            }

        break;

        case PaluuAlkutilaan:
        PaluuAlkuun();

        if(Laskuri<1){
            tilakoneenTila=Alkutila;
            emit TilaSignaali(Alkutila,"alkutila");
        }

        break;
        default : break;
    }
    return tilakoneenTila;
}

#ifndef DIALOG_H
#define DIALOG_H

#include <QDialog>
#include <QTimer>
#include "tilakone.h"

namespace Ui {
    class Dialog;
}

class Dialog : public QDialog {
    Q_OBJECT
public:
    Dialog(QWidget *parent = 0);
    ~Dialog();
    Tilakone tilakone;
    QTimer *timer;
    int StartKomento;
    CycleState kopioTilakoneelta;
protected:

private:
    Ui::Dialog *ui;

public slots:
    void NaytaTila(CycleState state, QString Tila);
private slots:
    void on_Pause_clicked(bool checked);
    void on_Interrupt_clicked();
    void Update();
    void on_Start_clicked(bool checked);
    void on_toHome_clicked();
};

#endif // DIALOG_H

#include "dialog.h"
#include "ui_dialog.h"

Dialog::Dialog(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::Dialog)
{
    ui->setupUi(this);
    timer=new(QTimer);
    timer->start(50);
    connect(this->timer,SIGNAL(timeout()),this,SLOT(Update()));
    connect(&tilakone,SIGNAL(TilaSignaali(CycleState,QString)),this,SLOT(NaytaTila(CycleState,QString)));
    StartKomento=0;
}

Dialog::~Dialog()
{
    delete ui;
}

void Dialog::on_Start_clicked(bool checked)
{
    if(checked)
    {
        ui->Started->setChecked(true);
        StartKomento=1;
    }
    else
    {
         StartKomento=0;
         ui->viestit->setText(trUtf8("Kone sammuu työkierron jälkeen"));
    }
}

void Dialog::Update()
{
    tilakone.TilojenSuoritus(StartKomento);
    ui->progressBar->setValue(tilakone.AnnaLaskurinArvo());
}


void Dialog::on_Interrupt_clicked()
{
    StartKomento=3;
    ui->Started->setChecked(false);
}

void Dialog::NaytaTila(CycleState state,QString Tila)
{
    ui->lineEdit->setText(Tila);
    kopioTilakoneelta=state;
    if(StartKomento==0 && kopioTilakoneelta==Alkutila){
        ui->Started->setChecked(false);
    }
}

void Dialog::on_Pause_clicked(bool checked)
{
    if(checked==true)
        StartKomento=2;
    else
        StartKomento=1;
}

void Dialog::on_toHome_clicked()
{
    if(kopioTilakoneelta==Odotus_1 ||kopioTilakoneelta==Odotus_2||kopioTilakoneelta==Keskeytystila){
    ui->Started->setChecked(false);
    StartKomento=4;
    ui->Start->setChecked(false);
    }
    else{
        ui->viestit->setText(trUtf8("kone ei voi palata alkutilaan kesken työkierron"));
    }
}