State Machine_реализуем Embedded модель (конечный автомат) цифрового детектора с помощью паттерна State

    Применение паттерна State к программированию цифрового детектора.

То, что конечный автомат является одной из основных парадигм в программировании (автоматное программирование  ) , позволяя описать систему в отдельных ее состояниях, мы можем почерпнуть из этого источника . В нем сравнивается автомат с клеткой в живом организме, из которого мы строим “тело” embedded системы.

<...>

    Разобьем алгоритм детектирования на стадии, а точнее состояния, т.к. детектор  с применяемой в нем децимацией становится похожим на конечным автомат с состояниями и переходами (из-за применения if-else).

В виду конкретной реализации алгоритма децимации - когда мы просчитываем выход фильтра не при каждом входном отсчете, а каждый M-й отсчет (М - коэффициент децимации) -  состояниями у нас будут “каскады” детектора с разной частотой дискретизации (каждое состояние работает на своей частоте дискретизации), переходами - получение выходного отсчета фильтра-дециматора (когда фильтр-дециматор просчитал выходной прореженный отсчет, то функция, его реализующая, выдает true значение). За дополнительной информацией о децимации можно обратиться к моей статье здесь .

Алгоритм на рисунке ниже (хотя он и отличается от представленной выше реализации: сначала децимация, а уж после нахождение модуля I^2+Q^2, - но это не беда для понимания) :

   

    Паттерн State будем реализовывать по алгоритму из Simulink. Он более предпочтителен, т.к. “тяжеловесное” извлечение корня производится не на 15625 S/s , а на 3125 S/s.

    Подберем названия для состояний.

State 1.

    Согласно рисунку 2 с сайта dspLib  к квадратурному гетеродину относятся генераторы ортогональных гармонических сигналов, умножители, фильтры, (правда , это не критично что к чему относится).

    Поэтому присвоим имя:

State 1 = Quadrature_Oscillator_State

State 2.

    Основная функция состояния - слияние квадратурных I-Q каналов в один поток. Из физики мы знаем, что есть два самых фундаментальных закона: закон сохранения импульсов (кинематика) и энергии. Второй к нам применим и он гласит, что мы можем пользоваться операцией сложения для энергий в замкнутой системе. Поэтому с этих позиций термин“слияние каналов” правомерен:

State 2 = IQ_Channels_Merge_State

State 3 = Sqrt_State

State 4

Здесь выделяем составляющие огибающей и применяем первый этап SQRT-алгоритма (возведение в квадрат).

State 4 = Envelop_Components_State

State 5

    Завершающая часть SQRT алгоритма (извлечение корня после фильтрации гармоники с удвоенной частотой огибающей).

State 5 = Components_Detection_State

State 6

    Конечное состояние всего алгоритма детектора. После него начинается все заново

    Диаграмма состояний, отрисована с помощью Visual Paradigm ( В чем рисовать UML, диаграммы? бесплатный UML редактор )

   

Проектирование автомата.

В процессе разработки обычно приходится выбирать между:

• созданием объектов состояния, когда в них возникает необходимость, и уничтожением сразу после использования;
• созданием их заранее и навсегда.

Первый вариант предпочтителен, когда заранее неизвестно, в какие состояния будет попадать система, и переход по состояниям происходит сравнительно редко. При этом мы не создаем объектов, которые никогда не будут использованы, что существенно, если в объектах состояния хранится много информации.

Когда изменения состояния происходят часто, поэтому не хотелось бы уничтожать представляющие их объекты (ибо они могут очень скоро понадобиться вновь), следует воспользоваться вторым подходом.

Поэтому мы воспользуемся вторым подходом.

В разработке реализации программы цифрового детектора нам поможет паттерн проектирования State.  Этот паттерн имеет множество реализаций (об этом почитать статью The Anthology of the Finite State Machine Design Patterns , а именно: про Real-Time State Pattern). Меня же интересует Real-Time State Pattern, который описан в статье Hierarchical State Machine . На их основе постигался дзен использования данного паттерна и ваялся свой.

Машина состояний (конечный автомат) будет классом с именем  CAsyncDetector.  В паттерне применяется композиция (включение), т.е. класс CAsyncDetector будет композитным - содержать внутри себя классы состояний конечного автомата. А эти классы  мы уже реализуем посредством наследования от некого базового, интерфейсного класса. Реализация состояний путем наследования очень практична, т.к., как описано в статье “Hierarchical State Machine”, можно реализовать и иерархическую версию конечного автомата в случае большого числа состояний.

Расширение количества состояний автомата достигается объявлением в теле внешнего класса CAsyncDetector дополнительных новых состояний с указанием его родителей и переопределением виртуальных методов родителя, которые будет использовать данное новое состояние.

В моем варианте паттерна классы состояний знают друг о друге, т.к. именно в их методах реализованы переходы из одного состояния в другое. Считаю, это не беда, т.к. алгоритм работы цифрового детектора более чем детерминированный.

Есть также реализация паттерна Состояние, где переходом управляет класс Контекст, которому классы состояний передают сигнал о наступлении  события, а уж контекст на основе текущего состояния и полученного события решает куда перейти. Об этих тонких различиях почитать в State Machine — новый паттерн ООП .

Один из минусов паттерна State:

• добавление нового состояния повлечет за собой модификацию остальных классов состояний,  так как иначе переход в данное состояние не может быть осуществлен.  Таким образом,  расширение автомата,  построенного на основе паттерна State,  является проблематичным (но возможным. И если мы не каждый день изменяем состояния в конечном автомате - даже терпимо).

    Итак, Диаграмма Классов у меня получается следующей:

    Примечания к заголовочному файлу.

• По диаграмме видно - используем композицию. Классы Состояний являются вложенными в класс Машины Состояний (CAsyncDetector). Они не видны для других классов, т.к. являются закрытыми.
• Все Классы Состояний объявлены дружественными. А т.к. дружественность не наследуется, то ключевое слово friend мы указываем для всех Классов Состояний. Это никак не нарушает прицип инкапсуляции, т.к все Классы Состояний - вложенные, да и к тому же объявлены в поле действия спецификатора доступа private.
• Экземпляры Классов Состояний (Объекты состояний) обозначены как статические. Это и логично, т.к. код, который будет в этих состояниях - это код детектора, который должен существовать всегда.
• Вложенные состояния наследуются от одного базового, интерфейсного класса CUnitState. Здесь есть небольшое сходство с паттерном Strategy.
• общедоступным объявлен только метод Launch(), чтобы один раз запустить систему, которая потом будет работать в автономном режиме.
• Машина состояний хранит указатель p_current_state_ на текущее состояние. Тип указателя - это тип базового интерфейсного класса Состояния CUnitState.  В соответствии с механизмом позднего связывания реализуется полиморфизм, состоящий в том, что с помощью одного и того же обращения к методу  Behave():

p_current_state_->Behave(*this);      //обращаемся к методу

    выполняются различные действия в зависимости от типа (от того Класса Состояния), на который ссылается указатель в данный момент. Этим и реализуется внешне кажущаяся изменчивость поведения паттерна State в зависимости от текущего состояния.

• данная версия программы предназначена только для исследования и  для отладки на компьютере. Для этого в классе CUnitClass добавлено защищенное поле  counter_ и определенным образом реализованы конструкторы, а так же - вывод в консоль сообщений о том, в каком состоянии мы находимся.
• Стиль оформления программы основывался на рекомендациях  Гугла: Google C++ Style  

1. * async_detector.h */
2. #ifndef ASYNC_DETECTOR_H
3. #define ASYNC_DETECTOR_H
5. #include <iostream>
7. /**
8. @file async_detector.h
9. @author Bachinin Eugene
10. @version Version 2.0
11. @note Version 1.0 is realized as if-else statements
13. @full this is the asynchronous detector model realized
14. as the State Machine by means of State Pattern. It's only the model
15. that's why we don't use real code for realizing detector
17. */
18. class CAsyncDetector { //State Machine
19. public:
20.     void Launch();
21. protected:
22. private:
24.     class CUnitState {
25.     public:
26.                         CUnitState() : counter_( 0 ) {}
27.                         CUnitState( long num ) : counter_( num ) {}
28.         virtual            ~CUnitState() {}
29.         virtual void    Behave( CAsyncDetector &async_detector ){}
30.     protected:
31.         //только для целей моделирования переходов конечного автомата!!!
32.         //Удалить при реализации настоящего детектора (+изменить конструкторы)
33.         long counter_;
34.     };
35.     friend CUnitState;
37.     class CQuadratureOscillator : public CUnitState {
38.     public:
39.         CQuadratureOscillator() : CUnitState( 0 ) {}
40.         void Behave( CAsyncDetector &async_detector );
41.     };
42.     friend CQuadratureOscillator;    //дружественность не наследуется
44.     class CIQChannelsMerge : public CUnitState {
45.     public:
46.         CIQChannelsMerge() : CUnitState( 0 ) {}
47.         void Behave( CAsyncDetector &async_detector );
48.     };
49.     friend CIQChannelsMerge;
51.     class CSqrt : public CUnitState {
52.     public:
53.         CSqrt() : CUnitState( 0 ) {}
54.         void Behave( CAsyncDetector &async_detector );
55.     };
56.     friend CSqrt;
58.     class CEnvelopComponents : public CUnitState {
59.     public:
60.         CEnvelopComponents() : CUnitState( 0 ) {}
61.         void Behave( CAsyncDetector &async_detector );
62.     };
63.     friend CEnvelopComponents;
65.     class CComponentsDetection : public CUnitState {
66.     public:
67.         CComponentsDetection() : CUnitState( 0 ) {}
68.         void Behave( CAsyncDetector &async_detector );
69.     };
70.     friend CComponentsDetection;
72. private:
73.     static CQuadratureOscillator    quadrature_oscillator_state_;
74.     static CIQChannelsMerge            iq_channels_merge_state_;
75.     static CSqrt                    sqrt_state_;
76.     static CEnvelopComponents        envelop_components_state_;
77.     static CComponentsDetection        components_detection_state_;
78.     CUnitState *p_current_state_;
79. private:
80.     void NextState( CUnitState &ref_state );
81.     void NextStateLaunch();
85. }; //CAsyncDetector
89. #endif //ASYNC_DETECTOR_H

    Реализация поведения паттерна State и необходимые разъяснения.

• т.к. Классы Состояния объявлены, как дружественные, то в их методы (здесь он один - Behave()) мы можем передать по ссылке экземпляр нашей Машины Состояний (т.е. класса CAsyncDetector) и иметь доступ к закрытым методам и полям класса, т.е.  CAsyncDetector::NextState() и указателю p_current_state_.

1. /* async_detector.cpp */
2. #include "async_detector.h"
4. //блок объявления статических переменных
5. CAsyncDetector::CQuadratureOscillator    CAsyncDetector::quadrature_oscillator_state_;
6. CAsyncDetector::CIQChannelsMerge        CAsyncDetector::iq_channels_merge_state_;
7. CAsyncDetector::CSqrt                    CAsyncDetector::sqrt_state_;
8. CAsyncDetector::CEnvelopComponents        CAsyncDetector::envelop_components_state_;
9. CAsyncDetector::CComponentsDetection    CAsyncDetector::components_detection_state_;
11. //может быть ошибка: может лучше писать (CAsyncDetector::CUnitState &ref_state )
12. void CAsyncDetector::NextState( CUnitState &ref_state ) {
14.     p_current_state_ = &ref_state;
15. }
17. void CAsyncDetector::NextStateLaunch( ) {
19.     this->p_current_state_->Behave( *this );
20. }
22. void CAsyncDetector::Launch() {
24.     //т.к. начинаем всегда с первого состояния, то устанавливаем его явно
25.     p_current_state_ = &quadrature_oscillator_state_;
26.     //Дальше конечный автомат цифрового детектора должен сам переходить
27.     //из одного состояния в  другое
28.     //Впервый раз запускаем так
29.     p_current_state_->Behave(*this);
30.     std::cin.get();
31. }
33. void CAsyncDetector::CQuadratureOscillator::Behave( CAsyncDetector &async_detector ) {
35.     std::cout << "We are now in the: t quadrature_oscillator_state_ t Entries: " << this->counter_ << std::endl;
36.     std::cin.get();
37.     /*
38.     *
39.     Выполняем действия этого Состояния
40.     *
41.     */
43.     this->counter_++;
44.     if( (this->counter_ % 10) != 0 ) {
46.         //переход на начало
47.         async_detector.NextState( async_detector.quadrature_oscillator_state_); //????????
48.     }
49.     else {
51.         //переключаемся в следующее состояние
52.         async_detector.NextState( async_detector.iq_channels_merge_state_ );
53.     }
54.     //запускаем
55.     async_detector.NextStateLaunch();
57. }
59. void CAsyncDetector::CIQChannelsMerge::Behave( CAsyncDetector &async_detector ) {
61.     std::cout << "We are now in the: t iq_channels_merge_state_ t Entries: " << this->counter_ << std::endl;
62.     std::cin.get();
63.     /*
64.     *
65.     Выполняем действия этого Состояния
66.     *
67.     */
69.     this->counter_++;
70.     if( (this->counter_ % 5) != 0 ) {
72.         async_detector.NextState( async_detector.quadrature_oscillator_state_);
73.     }
74.     else {
76.         async_detector.NextState( async_detector.sqrt_state_ );
77.     }
78.     async_detector.NextStateLaunch();
79. }
81. void CAsyncDetector::CSqrt::Behave( CAsyncDetector &async_detector ) {
83.     std::cout << "We are now in the: t sqrt_state_ t Entries: " << this->counter_ << std::endl;
84.     std::cin.get();
85.     /*
86.     *
87.     Выполняем действия этого Состояния
88.     *
89.     */
90.     this->counter_++;
91.     if( (this->counter_ % 5) != 0 ) {
93.         async_detector.NextState( async_detector.quadrature_oscillator_state_);
94.     }
95.     else {
97.         async_detector.NextState( async_detector.envelop_components_state_ );
98.     }
99.     async_detector.NextStateLaunch();
100. }
102. void CAsyncDetector::CEnvelopComponents::Behave( CAsyncDetector &async_detector ) {
104.     std::cout << "We are now in the: t envelop_components_state_ t Entries: " << this->counter_ << std::endl;
105.     std::cin.get();
106.     /*
107.     *
108.     Выполняем действия этого Состояния
109.     *
110.     */
111.     this->counter_++;
112.     if( (this->counter_ % 5) != 0 ) {
114.         async_detector.NextState( async_detector.quadrature_oscillator_state_);
115.     }
116.     else {
118.         async_detector.NextState( async_detector.components_detection_state_ );
119.     }
120.     async_detector.NextStateLaunch();
123. }
125. void CAsyncDetector::CComponentsDetection::Behave( CAsyncDetector &async_detector ) {
127.     std::cout << "We are now in the: t components_detection_state_ t Entries: " << this->counter_  << std::endl;
128.     std::cin.get();
129.     /*
130.     *
131.     Выполняем действия этого Состояния
132.     *
133.     */
134.     //закольцовываем конечный автомат на начальное состояние
135.     async_detector.NextState( async_detector.quadrature_oscillator_state_ );
137.     //запускаем
138.     async_detector.NextStateLaunch();
140. }

Ну и главная функция:

1. #include <iostream>
2. #include "async_detector.h"
4. int main() {
6.     CAsyncDetector async_detector;
8.     async_detector.Launch();
10.     std::cin.get();
11.     return 0;
12. }

Результаты: