Разработка цифрового автомата, управляющего работой микроволновой печи

if(state.current_task_time.minutes >= 100) {

state.current_task_time.minutes = 99;

state.current_task_time.minutes = 59;

}

}

 

 

Листинг файла «Logger.cpp»

 

 

#include "stdafx.h"

#include <string>

#include "MicroWaveDlg.h"

#include "Dispatcher.h"

 

void Dispatcher::put_log(const CString& str)

{

parent->m_Log += str;

parent->m_LogWnd.SetRedraw(false);

parent->UpdateData(false);

parent->m_LogWnd.LineScroll(parent->lines++);

parent->m_LogWnd.SetRedraw(true);

parent->m_LogWnd.Invalidate();

}

 

void Dispatcher::log_enter(int automata, int state, int event)

{

CTime time = CTime::GetCurrentTime();

CString t((LPCTSTR)time.Format("%H:%M:%S"));

CString str;

 

str.Format(" {  A%d: в состоянии %d запущен с событием e%d\r\n", automata, state,

event);

 

put_log(t + str);

}

 

void Dispatcher::log_exit(int automata, int state, int event)

{

CTime time = CTime::GetCurrentTime();

CString t((LPCTSTR)time.Format("%H:%M:%S"));

CString str;

 

str.Format(" }  A%d: завершил обработку события e%d в состоянии %d\r\n", automata,

event, state);

 

put_log(t + str);

}

 

void Dispatcher::log_trans(int automata, int old_state, int new_state)

{

CTime time = CTime::GetCurrentTime();

CString t((LPCTSTR)time.Format("%H:%M:%S"));

CString str;

 

str.Format(" T  A%d: перешел из состояния %d в состояние %d\r\n", automata,

old_state, new_state);

 

put_log(t + str);

}

 

void Dispatcher::log_input(int x, bool result, const char* descr)

{

CTime time = CTime::GetCurrentTime();

CString t((LPCTSTR)time.Format("%H:%M:%S"));

CString str;

 

str.Format(" >  x%d: - %s - вернул %d\r\n", x, descr, result);

 

put_log(t + str);

}

 

void Dispatcher::log_output(int z, const char *descr, bool has_arg, bool arg)

{

CTime time = CTime::GetCurrentTime();

CString t((LPCTSTR)time.Format("%H:%M:%S"));

CString str;

 

if(has_arg) {

str.Format(" *  z%d_%d. %s\r\n", z, arg, descr);

} else {

str.Format(" * z%d. %s\r\n", z, descr);

}

 

put_log(t + str);

}

 

 

Листинг файла «Automata.h»

// Automata.h: interface for the Automata class.

//

//////////////////////////////////////////////////////////////////////

 

#if !defined(AFX_AUTOMATA_H__39EFE032_7B8A_48A5_810A_16C9F7E75F8B__INCLUDED_)

#define AFX_AUTOMATA_H__39EFE032_7B8A_48A5_810A_16C9F7E75F8B__INCLUDED_

 

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

 

class Dispatcher;

 

class Automata

{

protected:

int number;

int state;

Dispatcher *dispatcher;

protected:

virtual void state_changed() = 0;

virtual void handle_state(const int e) = 0;

virtual void nested_automatas(const int e) = 0;

public:

int get_state();

 

void wake(const int event);

 

Automata(Dispatcher * d);

virtual ~Automata();

};

 

#endif // !defined(AFX_AUTOMATA_H__39EFE032_7B8A_48A5_810A_16C9F7E75F8B__INCLUDED_)

 

 

Листинг файла «Automata.cpp»

// Automata.cpp: implementation of the Automata class.

//

//////////////////////////////////////////////////////////////////////

 

#include "stdafx.h"

#include "MicroWave.h"

#include "Dispatcher.h"

#include "Automata.h"

 

#ifdef _DEBUG

#undef THIS_FILE

static char THIS_FILE[]=__FILE__;

#define new DEBUG_NEW

#endif

 

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

 

Automata::Automata(Dispatcher *d) : dispatcher(d), state(0)

{

}

 

Automata::~Automata()

{

 

}

 

void Automata::wake(const int event)

{

int old_state = state;

dispatcher->log_enter(number, state, event);

nested_automatas(event);

handle_state(event);

if(state != old_state) {

dispatcher->log_trans(number, old_state, state);

state_changed();

}

dispatcher->log_exit(number, state, event);

}

 

int Automata::get_state()

{

return state;

}

 

 

Листинг файла «A0.h»

// A0.h: interface for the A0 class.

//

//////////////////////////////////////////////////////////////////////

 

#if !defined(AFX_A0_H__7ABC4FC7_F4F8_4520_91C6_05ED15AD1051__INCLUDED_)

#define AFX_A0_H__7ABC4FC7_F4F8_4520_91C6_05ED15AD1051__INCLUDED_

 

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

 

#include "Automata.h"

 

class A0 : public Automata

{

public:

A0(Dispatcher *d);

virtual ~A0();

protected:

void handle_state(const int e);

void state_changed();

void nested_automatas(const int e);

};

 

#endif // !defined(AFX_A0_H__7ABC4FC7_F4F8_4520_91C6_05ED15AD1051__INCLUDED_)

 

Листинг файла «A0.cpp»

// A0.cpp: implementation of the A0 class.

//

//////////////////////////////////////////////////////////////////////

 

#include "stdafx.h"

#include "A0.h"

#include "Dispatcher.h"

 

 

#ifdef _DEBUG

#undef THIS_FILE

static char THIS_FILE[]=__FILE__;

#define new DEBUG_NEW

#endif

 

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

 

A0::A0(Dispatcher *d) : Automata(d)

{

number = 0;

}

 

A0::~A0()

{

 

}

 

void A0::nested_automatas(const int e)

{

switch(state) {

case 0:

dispatcher->A[1]->wake(e);

break;

case 1:

dispatcher->A[1]->wake(e);

break;

}

}

 

void A0::handle_state(const int e)

{

bool _x4, _x5;

switch(state) {

case 0:

if(e == 10) {

dispatcher->z23(1);

} else if(e == 12) {

dispatcher->z23(0);

} else if (dispatcher->A[1]->get_state() == 4) {

state = 1;

} else if (dispatcher->A[1]->get_state() == 0) {

dispatcher->A[4]->wake(15);

}

break;

case 1:

_x5 = dispatcher->x5();

_x4 = dispatcher->x4();

if((dispatcher->A[1]->get_state() != 4) && (e == 8)) {

state = 0;

dispatcher->z23(0);

dispatcher->z24(0);

dispatcher->z28(0);

} else if ((dispatcher->A[1]->get_state() != 4) && (e == 10)) {

state = 0;

dispatcher->z24(0);

dispatcher->z28(0);

} else if (e == 16 && _x5 && !_x4) {

state = 0;

dispatcher->z31();

dispatcher->z23(0);

dispatcher->z24(0);

dispatcher->z28(0);

dispatcher->A[1]->wake(17);

dispatcher->A[4]->wake(15);

} else if ((e == 16) && _x5 && _x4) {

dispatcher->z30();

dispatcher->z29();

} else if ((e == 16) && !_x5) {

dispatcher->z31();

dispatcher->z29();

}

break;

}

}

 

void A0::state_changed()

{

switch(state) {

case 0:

dispatcher->A[1]->wake(0);

break;

case 1:

dispatcher->A[1]->wake(0);

dispatcher->z23(1);

dispatcher->z24(1);

dispatcher->z28(1);

dispatcher->z29();

break;

}

}

 

 

Листинг файла «A1.h»

// A1.h: interface for the A1 class.

//

//////////////////////////////////////////////////////////////////////

 

#if !defined(AFX_A1_H__FA3EB6DD_B0A0_448F_A4F3_9BDB008BA584__INCLUDED_)

#define AFX_A1_H__FA3EB6DD_B0A0_448F_A4F3_9BDB008BA584__INCLUDED_

 

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

 

#include "Automata.h"

 

 

class A1 : public Automata

{

protected:

void handle_state(const int e);

void nested_automatas(const int e);

void state_changed();

public:

A1(Dispatcher *d);

virtual ~A1();

};

 

#endif // !defined(AFX_A1_H__FA3EB6DD_B0A0_448F_A4F3_9BDB008BA584__INCLUDED_)

Листинг файла «A1.cpp»

// A1.cpp: implementation of the A1 class.

//

//////////////////////////////////////////////////////////////////////

 

#include "stdafx.h"

#include "Dispatcher.h"

#include "A1.h"

 

#ifdef _DEBUG

#undef THIS_FILE

static char THIS_FILE[]=__FILE__;

#define new DEBUG_NEW

#endif

 

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

 

A1::A1(Dispatcher *d) : Automata(d)

{

number = 1;

}

 

A1::~A1()

{

 

}

 

void A1::nested_automatas(const int e) {

switch(state) {

case 0:

dispatcher->A[2]->wake(e);

dispatcher->A[3]->wake(e);

break;

case 1:

dispatcher->A[2]->wake(e);

break;

case 2:

dispatcher->A[3]->wake(e);

break;

case 3:

break;

case 4:

break;

}

}

 

void A1::handle_state(const int e){

bool _x4;

switch(state) {

case 0:

if(e == 1 || e == 7) {

state = 2;

} else if(e == 6) {

state = 1;

} else if ((dispatcher->A[3]->get_state() == 0) && dispatcher->x4()) {

state = 4;

}

break;

case 1:

if(dispatcher->A[2]->get_state() == 0) {

state = 0;

}

break;

case 2:

_x4 = dispatcher->x4();

if((dispatcher->A[3]->get_state() == 0) && _x4) {

state = 4;

} else if((dispatcher->A[3]->get_state() == 0) && !_x4) {

state = 0;

}

break;

case 3:

if(e == 8) {

state = 0;

dispatcher->z10();

} else if ((e == 9) && dispatcher->x3()) {

state = 4;

}

break;

case 4:

if(e == 9) {

dispatcher->z32();

dispatcher->z29();

} else if (e == 17) {

state = 0;

} else if (e == 8|| e == 10) {

state = 3;

}

break;

}

}

 

void A1::state_changed()

{

switch(state) {

case 0:

dispatcher->A[2]->wake(0);

dispatcher->A[3]->wake(0);

break;

case 1:

dispatcher->A[2]->wake(0);

break;

case 2:

dispatcher->A[3]->wake(0);

break;

case 3:

break;

case 4:

break;

}

}

Листинг файла «A2.h»

// A2.h: interface for the A2 class.

//

//////////////////////////////////////////////////////////////////////

 

#if !defined(AFX_A2_H__839CF12F_227E_4056_B6FE_08F55ED58188__INCLUDED_)

#define AFX_A2_H__839CF12F_227E_4056_B6FE_08F55ED58188__INCLUDED_

 

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

 

#include "Automata.h"

 

class A2 : public Automata

{

protected:

void handle_state(const int e);

void nested_automatas(const int e) {};

void state_changed();

public:

A2(Dispatcher *d);

virtual ~A2();

 

};

 

#endif // !defined(AFX_A2_H__839CF12F_227E_4056_B6FE_08F55ED58188__INCLUDED_)

 

 

Листинг файла «A2.cpp»

// A2.cpp: implementation of the A2 class.

//

//////////////////////////////////////////////////////////////////////

 

#include "stdafx.h"