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

static char THIS_FILE[]=__FILE__;

#define new DEBUG_NEW

#endif

 

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

// Construction/Destruction

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

 

const bool State::CLOCK_MODE_12H = false;

const bool State::CLOCK_MODE_24H = true;

 

Dispatcher::Dispatcher(CMicroWaveDlg *p) : A(5), parent(p)

{

A[0] = new A0(this);

A[1] = new A1(this);

A[2] = new A2(this);

A[3] = new A3(this);

A[4] = new A4(this);

 

A[0]->wake(0);

}

 

Dispatcher::~Dispatcher()

{

if(parent->second_delay_timer)

parent->KillTimer(parent->second_delay_timer);

if(parent->power_choose_timer)

parent->KillTimer(parent->power_choose_timer);

if(parent->task_timer)

parent->KillTimer(parent->task_timer);

 

for(std::vector<Automata*>::iterator it = A.begin(); it != A.end(); ++it) {

delete (*it);

}

}

 

 

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

 

#include "stdafx.h"

#include "Dispatcher.h"

#include "MicroWaveDlg.h"

 

#ifdef _DEBUG

#undef THIS_FILE

static char THIS_FILE[]=__FILE__;

#define new DEBUG_NEW

#endif

 

bool Dispatcher::x1()

{

bool result = (state.choosed_task_time.minutes == 0) &&

(state.choosed_task_time.seconds == 0);

 

log_input(1, result, "выбранное  время выполнения задания равно 0?");

 

return result;

}

 

bool Dispatcher::x2()

{

bool result = state.current_mass == 0;

log_input(2, result, "выбранная  масса равна 0?");

return result;

}

 

bool Dispatcher::x3()

{

bool result = !parent->is_door_open;

log_input(3, result, "дверь закрыта?");

return result;

}

 

bool Dispatcher::x4()

{

bool result = !state.task_queue.empty();

log_input(4, result, "есть еще  задания в очереди?");

return result;

}

 

bool Dispatcher::x5()

{

bool result = (state.current_task_time.minutes == 0)

&& (state.current_task_time.seconds == 1);

log_input(4, result, "до конца  задания одна секунда?");

return result;

}

 

 

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

 

#include "stdafx.h"

#include "MicroWaveDlg.h"

#include "Dispatcher.h"

 

#ifdef _DEBUG

#undef THIS_FILE

static char THIS_FILE[]=__FILE__;

#define new DEBUG_NEW

#endif

 

void Dispatcher::z1()

{

log_output(1, "Установить максимальную  мощность (750W).");

state.current_power = 750;

}

 

void Dispatcher::z2()

{

CString str;

int& pow = state.current_power;

switch(pow) {

case 750:

pow = 600;

break;

case 600:

pow = 450;

break;

case 450:

pow = 300;

break;

case 300:

pow = 180;

break;

case 180:

pow = 100;

break;

case 100:

pow = 750;

break;

}

 

str.Format("Установить следующую  по списку мощность (%dW).", pow);

log_output(2, (LPCTSTR)str);

}

 

 

void Dispatcher::z3()

{

log_output(3, "Показать текущую  мощность.");

parent->m_Content.Format("%dW",state.current_power);

parent->UpdateData(false);

}

 

void Dispatcher::z4()

{

log_output(4, "Показать выбранное  время выполнения задания.");

parent->m_Content.Format("%.2d:%.2d",

state.choosed_task_time.minutes,

state.choosed_task_time.seconds);

parent->UpdateData(false);

}

 

void Dispatcher::z5()

{

log_output(5, "Установить время  выполнения задания в 0.");

state.choosed_task_time.minutes = 0;

state.choosed_task_time.seconds = 0;

}

 

void Dispatcher::z6()

{

log_output(6, "Добавить к  выбранному времени выполнения  задания 10 мин.");

state.choosed_task_time.minutes += 10;

state.choosed_task_time.minutes %= 100;

}

 

void Dispatcher::z7()

{

log_output(7, "Добавить к  выбранному времени выполнения задания 1 мин.");

if(state.choosed_task_time.minutes % 10 == 9) {

state.choosed_task_time.minutes -= 9;

} else {

state.choosed_task_time.minutes += 1;

}

}

 

void Dispatcher::z8()

{

log_output(8, "Добавить к  выбранному времени выполнения  задания 10 сек.");

state.choosed_task_time.seconds += 10;

state.choosed_task_time.seconds %= 60;

}

 

void Dispatcher::z9()

{

log_output(9, "Добавить задание  в очередь.");

state.task_queue.push_back(Task(state.choosed_task_time, state.current_power));

}

 

void Dispatcher::z10()

{

log_output(10, "Отчистить очередь заданий.");

state.task_queue.clear();

}

 

void Dispatcher::z11()

{

log_output(11, "Установить текущую массу в 0.");

state.current_mass = 0;

}

 

void Dispatcher::z12()

{

log_output(12, "Показать текущую  массу.");

parent->m_Content.Format("%d",state.current_mass);

parent->UpdateData(false);

}

 

void Dispatcher::z13()

{

log_output(13, "Добавить к текущей массе 100 гр.");

state.current_mass = (state.current_mass + 100) % 1600;

}

 

void Dispatcher::z14()

{

int seconds;

state.current_power = 100;

seconds = 75 * (state.current_mass / 100);

state.choosed_task_time.minutes = seconds / 60;

state.choosed_task_time.seconds = seconds % 60;

log_output(14, "Расcчитать по  выбранной массе время для  задания.");

}

 

void Dispatcher::z15(bool restart)

{

if(parent->power_choose_timer != 0) {

parent->KillTimer(parent->power_choose_timer);

parent->power_choose_timer = 0;

}

 

if(restart) {

parent->power_choose_timer = parent->SetTimer(1, 2000, 0);

log_output(15, "Установить таймаут  выбора мощности.", true, true);

} else {

log_output(15, "Отменить таймаут  выбора мощности.", true, false);

}

}

 

void Dispatcher::z16(bool mode_24h)

{

if(mode_24h) {

parent->m_Content = "24 h";

log_output(16, "Показачать 24 часа.", true, true);

} else {

log_output(16, "Показачать 12 часов.", true, false);

parent->m_Content = "12 h";

}

parent->UpdateData(false);

}

 

void Dispatcher::z17(bool mode_24h)

{

state.clock_mode = mode_24h;

if(mode_24h == state.CLOCK_MODE_24H) {

log_output(17, "Установить часы  режим 24 часов.", true, true);

} else {

log_output(17, "Установить часы  режим 24 часов.", true, false);

}

}

 

void Dispatcher::z18()

{

log_output(18, "Установить выбранное  время 0:00.");

state.choosed_time.hours = 0;

state.choosed_time.minutes = 0;

state.choosed_time.seconds = 0;

}

 

void Dispatcher::z19()

{

log_output(19, "Показать выбранное  время.");

parent->m_Content.Format("%.2d:%.2d", state.choosed_time.hours,

state.choosed_time.minutes);

parent->UpdateData(false);

}

 

 

void Dispatcher::z20()

{

log_output(20, "Добавить к  выбранному времени 1 час.");

if(state.clock_mode == state.CLOCK_MODE_24H) {

state.choosed_time.hours = (state.choosed_time.hours + 1) % 24;

} else {

state.choosed_time.hours = (state.choosed_time.hours + 1) % 12;

}

}

 

void Dispatcher::z21()

{

log_output(21, "Добавить к  выбранному времени 1 минуту.");

state.choosed_time.minutes = (state.choosed_time.minutes + 1) % 60;

}

 

void Dispatcher::z22()

{

log_output(22, "Сделать выбранное время текущим.");

state.current_time = state.choosed_time;

}

 

void Dispatcher::z23(bool on)

{

if(on) {

log_output(23, "Включить лампу.", true, true);

} else {

log_output(23, "Выключить лампу.", true, false);

}

if(parent->is_door_open)

return;

if (on) {

parent->m_Image.SetBitmap(parent->turned_on);

} else {

parent->m_Image.SetBitmap(parent->turned_off);

}

}

 

void Dispatcher::z24(bool begin)

{

if(begin) {

log_output(24, "Начать выполнение заданий.", true, true);

Task next = state.task_queue.front();

state.task_queue.pop_front();

state.current_task_time = next.time;

state.current_power = next.power;

} else {

log_output(24, "Прекратить выполнение  заданий.", true, false);

if((state.current_task_time.minutes != 0) ||

(state.current_task_time.seconds != 0)) {

state.task_queue.push_front(Task(state.current_task_time, state.current_power));

}

}

}

 

void Dispatcher::z25()

{

log_output(25, "Установить ежесекундный таймер часов.");

parent->second_delay_timer = parent->SetTimer(3, 1000, 0);

}

 

void Dispatcher::z26(bool time_set)

{

if(time_set) {

log_output(26, "Показать текущеей время на часах.", true, true);

if(state.current_time.seconds % 2) {

parent->m_Content.Format("%.2d:%.2d", state.current_time.hours,

state.current_time.minutes);

} else {

parent->m_Content.Format("%.2d %.2d", state.current_time.hours,

state.current_time.minutes);

}

} else {

log_output(26, "Показать, что  часы не установлены.", true, false);

parent->m_Content = "Установите часы";

}

parent->UpdateData(false);

}

 

void Dispatcher::z27()

{

log_output(27, "Увеличить текущее время на одну секунду.");

state.current_time.seconds += 1;

state.current_time.minutes += state.current_time.seconds / 60;

state.current_time.seconds %= 60;

state.current_time.hours += state.current_time.minutes / 60;

state.current_time.minutes %=60;

if(state.clock_mode == state.CLOCK_MODE_24H) {

state.current_time.hours %= 24;

} else {

state.current_time.hours %= 12;

}

}

 

void Dispatcher::z28(bool on)

{

if(on) {

log_output(28, "Запустить ежесекундный таймер выполнения задания.", true, true);

parent->task_timer = parent->SetTimer(2, 1000, 0);

} else {

log_output(28, "Приостановить  ежесекундный таймер выполнения  задания.",

true, false);

parent->KillTimer(parent->task_timer);

parent->task_timer = 0;

}

}

 

void Dispatcher::z29()

{

log_output(29, "Показать сколько  времени до конца задания.");

parent->m_Content.Format("%.2d:%.2d", state.current_task_time.minutes,

state.current_task_time.seconds);

parent->UpdateData(false);

}

 

void Dispatcher::z30()

{

log_output(30, "Начать выполнять  следующее задание в очереди.");

Task next = state.task_queue.front();

state.task_queue.pop_front();

state.current_task_time = next.time;

state.current_power = next.power;

}

 

void Dispatcher::z31()

{

log_output(31, "Уменьшить время до конца задания на одну секунду.");

if(state.current_task_time.seconds == 0) {

state.current_task_time.seconds = 59;

state.current_task_time.minutes--;

} else {

state.current_task_time.seconds--;

}

}

 

void Dispatcher::z32()

{

log_output(31, "Добавить к времени до конца задания 30 секунд.");

state.current_task_time.seconds += 30;

state.current_task_time.minutes += state.current_task_time.seconds / 60;

state.current_task_time.seconds %= 60;