LEDviaApp.ino

/*.$file${.::LEDviaApp.ino} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
/*
* Model: LEDviaApp.qm
* File:  ${.::LEDviaApp.ino}
*
* This code has been generated by QM 5.0.0 <www.state-machine.com/qm/>.
* DO NOT EDIT THIS FILE MANUALLY. All your changes will be lost.
*
* This program is open source software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License as published
* by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details.
*/
/*.$endhead${.::LEDviaApp.ino} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
#include "qpn.h"                       // QP-nano framework

#include <NeoPixels_SPI.h>             // from Nick Gammon, Pin 11 = MOSI

//============================================================================
// declare all AO classes...
/*.$declare${AOs::LEDviaApp} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
/*.${AOs::LEDviaApp} .......................................................*/
typedef struct LEDviaApp {
/* protected: */
    QActive super;

/* private: */
    uint8_t value;
    uint8_t red;
    uint8_t green;
    uint8_t blue;
    uint8_t program;
    uint16_t led_index;
    uint8_t brightness;
    uint8_t dim_up;
    uint8_t rain_x;
    uint8_t splash_x;
    uint16_t run_x;
    uint8_t run_bwd;
    uint8_t run_nr;
    uint8_t run_nr_index;
    uint8_t com_counter;
} LEDviaApp;

/* protected: */
static QState LEDviaApp_initial(LEDviaApp * const me);
static QState LEDviaApp_LEDcontrol(LEDviaApp * const me);
static QState LEDviaApp_colour(LEDviaApp * const me);
static QState LEDviaApp_dim_up(LEDviaApp * const me);
static QState LEDviaApp_dim_down(LEDviaApp * const me);
static QState LEDviaApp_rainbow(LEDviaApp * const me);
static QState LEDviaApp_flash(LEDviaApp * const me);
static QState LEDviaApp_splash(LEDviaApp * const me);
static QState LEDviaApp_snow(LEDviaApp * const me);
static QState LEDviaApp_run_fwd(LEDviaApp * const me);
static QState LEDviaApp_run_bwd(LEDviaApp * const me);
static QState LEDviaApp_communication(LEDviaApp * const me);
static QState LEDviaApp_process_data(LEDviaApp * const me);
/*.$enddecl${AOs::LEDviaApp} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
//...

// AO instances and event queue buffers for them...
LEDviaApp AO_LEDviaApp;
static QEvt l_ledviaappQSto[10];       // Event queue storage for LEDviaApp
//...

//============================================================================
// QF_active[] array defines all active object control blocks ----------------
QActiveCB const Q_ROM QF_active[] = {
    { (QActive *)0,             (QEvt *)0,       0U                     },
    { (QActive *)&AO_LEDviaApp, l_ledviaappQSto, Q_DIM(l_ledviaappQSto) }
};

//============================================================================
// various constants for the application...
enum {
// number of system clock ticks in one second
    BSP_TICKS_PER_SEC      = 100U,

// handshake and program timing = 100 ms
    COMMUNICATION_TICK     = BSP_TICKS_PER_SEC / 10U,

// max 256 PIXELS possible, else some Class Attribute types has to be adjusted
    PIXELS = 120,                      // number of LEDs in the stripe
//    PIXELS = 8U,                       // number of LED in the stick

// shift 0 to 'zero' for never calculating below 0
    zero = PIXELS + 1U,                // shift 0 to avoid coming below 0
    pixels = 2U * PIXELS + 1U,         // has also to be shifted

    BLUETOOTH_POWER = 4,               // pin of the transistor base

    DEBUG_L = 9                        // pin of debug LED
};

// various signals for the application...
enum {
    STOP_SIG            = Q_USER_SIG,  // end of data
    COMMUNICATION_SIG,                 // communication request
    COLOUR_SIG,                        // display colour
    DIM_SIG,                           // dim animation
    RAINBOW_SIG,                       // rainbow animation
    FLASH_SIG,                         // colour flash animation
    SPLASH_SIG,                        // colour splash animation
    SNOW_SIG,                          // snow animation
    RUN_SIG                            // run light animation
};

// store the rainbow in memory (from Nick Gammon)
// WARNING! 3 bytes per pixel - take care you don't exceed available RAM
colour pixelArray [PIXELS];

//............................................................................
void setup() {
    // initialize the QF-nano framework
    QF_init(Q_DIM(QF_active));

    // initialize all AOs...
    QActive_ctor(&AO_LEDviaApp.super, Q_STATE_CAST(&LEDviaApp_initial));

    // initialize the hardware used in this sketch...
    pinMode(DEBUG_L, OUTPUT);          // set the DEBUG_LED pin to output

    pinMode(BLUETOOTH_POWER, OUTPUT);  // pin mode of the transistor control
    delay(3000);                       // switch on delay for program upload
    digitalWrite(BLUETOOTH_POWER, HIGH); // switch on the Bluetooth module

    // set the highest standard baud rate of 115200 bps
    Serial.begin(115200);

    ledsetup();                        // setup SPI
    showColor(PIXELS, 0U, 0U, 0U);     // all LED off
}

//............................................................................
void loop() {
    QF_run(); // run the QF-nano framework
}

//============================================================================
// interrupts...
ISR(TIMER2_COMPA_vect) {
    QF_tickXISR(0U); // process time events for tick rate 0
}

//============================================================================
// QF callbacks...
void QF_onStartup(void) {
    // set Timer2 in CTC mode, 1/1024 prescaler, start the timer ticking...
    TCCR2A = (1U << WGM21) | (0U << WGM20);
    TCCR2B = (1U << CS22 ) | (1U << CS21) | (1U << CS20); // 1/2^10
    ASSR  &= ~(1U << AS2);
    TIMSK2 = (1U << OCIE2A); // enable TIMER2 compare Interrupt
    TCNT2  = 0U;

    // set the output-compare register based on the desired tick frequency
    OCR2A  = (F_CPU / BSP_TICKS_PER_SEC / 1024U) - 1U;
}

//............................................................................
void QV_onIdle(void) { // called with interrupts DISABLED
    // Put the CPU and peripherals to the low-power mode. You might
    // need to customize the clock management for your application,
    // see the datasheet for your particular AVR MCU.
    SMCR = (0 << SM0) | (1 << SE); // idle mode, adjust to your project
    QV_CPU_SLEEP(); // atomically go to sleep and enable interrupts
}

//............................................................................
void Q_onAssert(char const Q_ROM * const file, int line) {
    // implement the error-handling policy for your application!!!
    QF_INT_DISABLE(); // disable all interrupts
    QF_RESET(); // reset the CPU
}

//============================================================================
// define all AO classes (state machine)...
/*.$skip${QP_VERSION} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
/*. Check for the minimum required QP version */
#if (QP_VERSION < 670U) || (QP_VERSION != ((QP_RELEASE^4294967295U) % 0x3E8U))
#error qpn version 6.7.0 or higher required
#endif
/*.$endskip${QP_VERSION} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
/*.$define${AOs::LEDviaApp} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
/*.${AOs::LEDviaApp} .......................................................*/
/*.${AOs::LEDviaApp::SM} ...................................................*/
static QState LEDviaApp_initial(LEDviaApp * const me) {
    /*.${AOs::LEDviaApp::SM::initial} */
    me->run_nr = 1U;
    me->run_x = zero;
    return Q_TRAN(&LEDviaApp_LEDcontrol);
}
/*.${AOs::LEDviaApp::SM::LEDcontrol} .......................................*/
static QState LEDviaApp_LEDcontrol(LEDviaApp * const me) {
    QState status_;
    switch (Q_SIG(me)) {
        /*.${AOs::LEDviaApp::SM::LEDcontrol} */
        case Q_ENTRY_SIG: {
            if (Serial.read() == 'R') {
                Serial.print(F("T"));
                QACTIVE_POST((QActive *)me, COMMUNICATION_SIG, 0U);
            }
            else {
                if (me->program == 1U)
                    QACTIVE_POST((QActive *)me, COLOUR_SIG, 0U);
                else if (me->program == 2U)
                    QACTIVE_POST((QActive *)me, DIM_SIG, 0U);
                else if (me->program == 3U)
                    QACTIVE_POST((QActive *)me, RAINBOW_SIG, 0U);
                else if (me->program == 4U)
                    QACTIVE_POST((QActive *)me, FLASH_SIG, 0U);
                else if (me->program == 5U)
                    QACTIVE_POST((QActive *)me, SPLASH_SIG, 0U);
                else if (me->program == 6U)
                    QACTIVE_POST((QActive *)me, SNOW_SIG, 0U);
                else if (me->program == 7U)
                    QACTIVE_POST((QActive *)me, RUN_SIG, 0U);
                else if (me->program == 8U) {
                    if (me->run_nr > 1U) { // never 0
                        me->run_nr--;
                    }
                    me->program = 7U;
                    QACTIVE_POST((QActive *)me, RUN_SIG, 0U);
                }
                else if (me->program == 9U) {
                    if (me->run_nr < PIXELS) { // never beyond PIXELS
                        me->run_nr++;
                    }
                    me->program = 7U;
                    QACTIVE_POST((QActive *)me, RUN_SIG, 0U);
                }
            }

            QActive_armX((QActive *)me, 0U, COMMUNICATION_TICK, 0U);
            status_ = Q_HANDLED();
            break;
        }
        /*.${AOs::LEDviaApp::SM::LEDcontrol} */
        case Q_EXIT_SIG: {
            QActive_disarmX((QActive *)me, 0U);
            status_ = Q_HANDLED();
            break;
        }
        /*.${AOs::LEDviaApp::SM::LEDcontrol::COMMUNICATION} */
        case COMMUNICATION_SIG: {
            me->com_counter = 0U;
            status_ = Q_TRAN(&LEDviaApp_communication);
            break;
        }
        /*.${AOs::LEDviaApp::SM::LEDcontrol::COLOUR} */
        case COLOUR_SIG: {
            status_ = Q_TRAN(&LEDviaApp_colour);
            break;
        }
        /*.${AOs::LEDviaApp::SM::LEDcontrol::DIM} */
        case DIM_SIG: {
            /*.${AOs::LEDviaApp::SM::LEDcontrol::DIM::[up]} */
            if (!me->dim_up) {
                status_ = Q_TRAN(&LEDviaApp_dim_up);
            }
            /*.${AOs::LEDviaApp::SM::LEDcontrol::DIM::[down]} */
            else {
                status_ = Q_TRAN(&LEDviaApp_dim_down);
            }
            break;
        }
        /*.${AOs::LEDviaApp::SM::LEDcontrol::RAINBOW} */
        case RAINBOW_SIG: {
            status_ = Q_TRAN(&LEDviaApp_rainbow);
            break;
        }
        /*.${AOs::LEDviaApp::SM::LEDcontrol::FLASH} */
        case FLASH_SIG: {
            status_ = Q_TRAN(&LEDviaApp_flash);
            break;
        }
        /*.${AOs::LEDviaApp::SM::LEDcontrol::SPLASH} */
        case SPLASH_SIG: {
            status_ = Q_TRAN(&LEDviaApp_splash);
            break;
        }
        /*.${AOs::LEDviaApp::SM::LEDcontrol::SNOW} */
        case SNOW_SIG: {
            status_ = Q_TRAN(&LEDviaApp_snow);
            break;
        }
        /*.${AOs::LEDviaApp::SM::LEDcontrol::RUN} */
        case RUN_SIG: {
            /*.${AOs::LEDviaApp::SM::LEDcontrol::RUN::[fwd]} */
            if (!me->run_bwd) {
                status_ = Q_TRAN(&LEDviaApp_run_fwd);
            }
            /*.${AOs::LEDviaApp::SM::LEDcontrol::RUN::[bwd]} */
            else {
                status_ = Q_TRAN(&LEDviaApp_run_bwd);
            }
            break;
        }
        /*.${AOs::LEDviaApp::SM::LEDcontrol::Q_TIMEOUT} */
        case Q_TIMEOUT_SIG: {
            status_ = Q_TRAN(&LEDviaApp_LEDcontrol);
            break;
        }
        default: {
            status_ = Q_SUPER(&QHsm_top);
            break;
        }
    }
    return status_;
}
/*.${AOs::LEDviaApp::SM::LEDcontrol::colour} ...............................*/
static QState LEDviaApp_colour(LEDviaApp * const me) {
    QState status_;
    switch (Q_SIG(me)) {
        /*.${AOs::LEDviaApp::SM::LEDcontrol::colour} */
        case Q_ENTRY_SIG: {
            showColor(PIXELS, me->red, me->green, me->blue);
            status_ = Q_HANDLED();
            break;
        }
        default: {
            status_ = Q_SUPER(&LEDviaApp_LEDcontrol);
            break;
        }
    }
    return status_;
}
/*.${AOs::LEDviaApp::SM::LEDcontrol::dim_up} ...............................*/
static QState LEDviaApp_dim_up(LEDviaApp * const me) {
    QState status_;
    switch (Q_SIG(me)) {
        /*.${AOs::LEDviaApp::SM::LEDcontrol::dim_up} */
        case Q_ENTRY_SIG: {
            showColor(PIXELS,
                me->red / 255.0 * me->brightness,
                me->green / 255.0 * me->brightness,
                me->blue / 255.0 * me->brightness
            );
            status_ = Q_HANDLED();
            break;
        }
        /*.${AOs::LEDviaApp::SM::LEDcontrol::dim_up} */
        case Q_EXIT_SIG: {
            me->brightness = me->brightness + 8U;

            if (me->brightness > 246U) {
                me->dim_up = 1U;
            }
            status_ = Q_HANDLED();
            break;
        }
        default: {
            status_ = Q_SUPER(&LEDviaApp_LEDcontrol);
            break;
        }
    }
    return status_;
}
/*.${AOs::LEDviaApp::SM::LEDcontrol::dim_down} .............................*/
static QState LEDviaApp_dim_down(LEDviaApp * const me) {
    QState status_;
    switch (Q_SIG(me)) {
        /*.${AOs::LEDviaApp::SM::LEDcontrol::dim_down} */
        case Q_ENTRY_SIG: {
            showColor(PIXELS,
                me->red / 255.0 * me->brightness,
                me->green / 255.0 * me->brightness,
                me->blue / 255.0 * me->brightness
            );
            status_ = Q_HANDLED();
            break;
        }
        /*.${AOs::LEDviaApp::SM::LEDcontrol::dim_down} */
        case Q_EXIT_SIG: {
            me->brightness = me->brightness - 8U;

            if (me->brightness < 10U) {
                me->dim_up = 0U;
            }
            status_ = Q_HANDLED();
            break;
        }
        default: {
            status_ = Q_SUPER(&LEDviaApp_LEDcontrol);
            break;
        }
    }
    return status_;
}
/*.${AOs::LEDviaApp::SM::LEDcontrol::rainbow} ..............................*/
static QState LEDviaApp_rainbow(LEDviaApp * const me) {
    QState status_;
    switch (Q_SIG(me)) {
        /*.${AOs::LEDviaApp::SM::LEDcontrol::rainbow} */
        case Q_ENTRY_SIG: {
            // cycle the starting point
            if (me->rain_x == 255U) {
                me->rain_x = 0U;
            }
            else {
                me->rain_x++;
            }

            /* build into in-memory array, as these calculations take too long
            to do on the fly */
            for (me->led_index = 0U; me->led_index < PIXELS; me->led_index++) {
                byte r, g, b;
                Wheel((me->led_index + me->rain_x) & 255U, r, g, b);
                pixelArray[me->led_index].r = r;
                pixelArray[me->led_index].g = g;
                pixelArray[me->led_index].b = b;
            }

            // now show results
            QF_INT_DISABLE();
            for (me->led_index = 0U; me->led_index < PIXELS; me->led_index++) {
                sendPixel(pixelArray[me->led_index].r,
                    pixelArray[me->led_index].g,
                    pixelArray[me->led_index].b);
            }
            QF_INT_ENABLE();

            show();
            // end of for each cycle
            status_ = Q_HANDLED();
            break;
        }
        default: {
            status_ = Q_SUPER(&LEDviaApp_LEDcontrol);
            break;
        }
    }
    return status_;
}
/*.${AOs::LEDviaApp::SM::LEDcontrol::flash} ................................*/
static QState LEDviaApp_flash(LEDviaApp * const me) {
    QState status_;
    switch (Q_SIG(me)) {
        /*.${AOs::LEDviaApp::SM::LEDcontrol::flash} */
        case Q_ENTRY_SIG: {
            // calculate first
            me->red = random(255U);
            me->green = random(255U);
            me->blue = random(255U);

            // then show results
            showColor(PIXELS, me->red, me->green, me->blue);
            status_ = Q_HANDLED();
            break;
        }
        default: {
            status_ = Q_SUPER(&LEDviaApp_LEDcontrol);
            break;
        }
    }
    return status_;
}
/*.${AOs::LEDviaApp::SM::LEDcontrol::splash} ...............................*/
static QState LEDviaApp_splash(LEDviaApp * const me) {
    QState status_;
    switch (Q_SIG(me)) {
        /*.${AOs::LEDviaApp::SM::LEDcontrol::splash} */
        case Q_ENTRY_SIG: {
            me->splash_x = random(PIXELS - 1U);

            /* build into in-memory array, as these calculations take too long
            to do on the fly */
            for (me->led_index = 0U; me->led_index < PIXELS; me->led_index++) {
                if (me->led_index == me->splash_x) {
                    pixelArray[me->led_index].r = random(255U);
                    pixelArray[me->led_index].g = random(255U);
                    pixelArray[me->led_index].b = random(255U);
                }
                else {
                    pixelArray[me->led_index].r = 0U;
                    pixelArray[me->led_index].g = 0U;
                    pixelArray[me->led_index].b = 0U;
                }
            }

            // now show results
            QF_INT_DISABLE();
            for (me->led_index = 0U; me->led_index < PIXELS; me->led_index++) {
                sendPixel(pixelArray[me->led_index].r,
                    pixelArray[me->led_index].g,
                    pixelArray[me->led_index].b);
            }
            QF_INT_ENABLE();

            show();
            status_ = Q_HANDLED();
            break;
        }
        default: {
            status_ = Q_SUPER(&LEDviaApp_LEDcontrol);
            break;
        }
    }
    return status_;
}
/*.${AOs::LEDviaApp::SM::LEDcontrol::snow} .................................*/
static QState LEDviaApp_snow(LEDviaApp * const me) {
    QState status_;
    switch (Q_SIG(me)) {
        /*.${AOs::LEDviaApp::SM::LEDcontrol::snow} */
        case Q_ENTRY_SIG: {
            /* build into in-memory array, as these calculations take too long
            to do on the fly */
            for (me->led_index = random(0U, PIXELS);
                    me->led_index < PIXELS;
                    me->led_index = me->led_index + random(2U, 4U)) {
                        pixelArray[me->led_index].r = 100U;
                        pixelArray[me->led_index].g = 100U;
                        pixelArray[me->led_index].b = random(100U, 255U);
            }

            // now show results
            QF_INT_DISABLE();
            for (me->led_index = 0U; me->led_index < PIXELS; me->led_index++) {
                sendPixel(pixelArray[me->led_index].r,
                    pixelArray[me->led_index].g,
                    pixelArray[me->led_index].b);
            }
            QF_INT_ENABLE();

            show();

            for (me->led_index = 0U; me->led_index < PIXELS; me->led_index++) {
                pixelArray[me->led_index].r = 0U;
                pixelArray[me->led_index].g = 0U;
                pixelArray[me->led_index].b = 0U;
            }
            status_ = Q_HANDLED();
            break;
        }
        default: {
            status_ = Q_SUPER(&LEDviaApp_LEDcontrol);
            break;
        }
    }
    return status_;
}
/*.${AOs::LEDviaApp::SM::LEDcontrol::run_fwd} ..............................*/
static QState LEDviaApp_run_fwd(LEDviaApp * const me) {
    QState status_;
    switch (Q_SIG(me)) {
        /*.${AOs::LEDviaApp::SM::LEDcontrol::run_fwd} */
        case Q_ENTRY_SIG: {
            /* build into in-memory array, as these calculations take too long
            to do on the fly */
            // calculate with shifted 0 and PIXELS
            for (me->led_index = zero;
                me->led_index <= (uint16_t)pixels - me->run_nr; me->led_index++) {
            /* compiler warning: "comparison between signed and unsigned
            integer expressions", if pixels isn't casted */
                if (me->led_index == me->run_x) {
                    for (me->run_nr_index = 0U; me->run_nr_index < me->run_nr;
                        me->run_nr_index++, me->led_index++) {
                            // address the absolute, not shifted LED
                            pixelArray[me->led_index - PIXELS - 1U].r = me->red;
                            pixelArray[me->led_index - PIXELS - 1U].g = me->green;
                            pixelArray[me->led_index - PIXELS - 1U].b = me->blue;
                    }
                    me->led_index--;
                    // otherwise led_index would be two times counted
                }
                else {
                    // address the absolute, not shifted LED
                    pixelArray[me->led_index - PIXELS - 1U].r = 0U;
                    pixelArray[me->led_index - PIXELS - 1U].g = 0U;
                    pixelArray[me->led_index - PIXELS - 1U].b = 0U;
                }
            }

            // now show results
            QF_INT_DISABLE();
            // address the absolute, not shifted LED
            for (me->led_index = 0U; me->led_index < PIXELS; me->led_index++) {
                sendPixel(pixelArray[me->led_index].r,
                    pixelArray [me->led_index].g,
                    pixelArray [me->led_index].b);
            }
            QF_INT_ENABLE();

            show();
            status_ = Q_HANDLED();
            break;
        }
        /*.${AOs::LEDviaApp::SM::LEDcontrol::run_fwd} */
        case Q_EXIT_SIG: {
            if (me->run_x < (uint16_t)pixels - me->run_nr) {
            /* compiler warning: "comparison between signed and unsigned
            integer expressions", if pixels isn't casted */
                me->run_x++;
            }
            else {
                me->run_bwd = 1U;
                me->run_x = pixels; // initialization for run_bwd
            }
            status_ = Q_HANDLED();
            break;
        }
        default: {
            status_ = Q_SUPER(&LEDviaApp_LEDcontrol);
            break;
        }
    }
    return status_;
}
/*.${AOs::LEDviaApp::SM::LEDcontrol::run_bwd} ..............................*/
static QState LEDviaApp_run_bwd(LEDviaApp * const me) {
    QState status_;
    switch (Q_SIG(me)) {
        /*.${AOs::LEDviaApp::SM::LEDcontrol::run_bwd} */
        case Q_ENTRY_SIG: {
            /* build into in-memory array, as these calculations take too long
            to do on the fly */
            // calculate with shifted 0 and PIXELS
            for (me->led_index = pixels;
                me->led_index >= me->run_nr + (uint16_t)zero; me->led_index--) {
            /* compiler warning: "comparison between signed and unsigned
            integer expressions", if zero isn't casted */
                if (me->led_index == me->run_x) {
                    for (me->run_nr_index = me->run_nr;  me->run_nr_index > 0U;
                        me->run_nr_index--, me->led_index--) {
                            // address the absolute, not shifted LED
                            pixelArray[me->led_index - PIXELS - 2U].r = me->red;
                            pixelArray[me->led_index - PIXELS - 2U].g = me->green;
                            pixelArray[me->led_index - PIXELS - 2U].b = me->blue;
                    }
                    me->led_index++;
                    // otherwise led_index would be two times counted
                }
                else {
                    // address the absolute, not shifted LED
                    pixelArray[me->led_index - PIXELS - 2U].r = 0U;
                    pixelArray[me->led_index - PIXELS - 2U].g = 0U;
                    pixelArray[me->led_index - PIXELS - 2U].b = 0U;
                }
            }

            // now show results
            QF_INT_DISABLE();
            // address the absolute, not shifted LED
            for (me->led_index = 0U; me->led_index < PIXELS; me->led_index++) {
                sendPixel(pixelArray[me->led_index].r,
                    pixelArray [me->led_index].g,
                    pixelArray [me->led_index].b);
            }
            QF_INT_ENABLE();

            show();
            status_ = Q_HANDLED();
            break;
        }
        /*.${AOs::LEDviaApp::SM::LEDcontrol::run_bwd} */
        case Q_EXIT_SIG: {
            if (me->run_x > me->run_nr + (uint16_t)zero) {
            /* compiler warning: "comparison between signed and unsigned
            integer expressions", if zero isn't casted */
                me->run_x--;
            }
            else {
                me->run_bwd = 0U;
                me->run_x = zero; // initialization for run_fwd
            }
            status_ = Q_HANDLED();
            break;
        }
        default: {
            status_ = Q_SUPER(&LEDviaApp_LEDcontrol);
            break;
        }
    }
    return status_;
}
/*.${AOs::LEDviaApp::SM::communication} ....................................*/
static QState LEDviaApp_communication(LEDviaApp * const me) {
    QState status_;
    switch (Q_SIG(me)) {
        /*.${AOs::LEDviaApp::SM::communication} */
        case Q_ENTRY_SIG: {
            QActive_armX((QActive *)me, 0U, COMMUNICATION_TICK, 0U);
            status_ = Q_HANDLED();
            break;
        }
        /*.${AOs::LEDviaApp::SM::communication} */
        case Q_EXIT_SIG: {
            QActive_disarmX((QActive *)me, 0U);
            status_ = Q_HANDLED();
            break;
        }
        /*.${AOs::LEDviaApp::SM::communication::Q_TIMEOUT} */
        case Q_TIMEOUT_SIG: {
            me->com_counter++;
            /*.${AOs::LEDviaApp::SM::communication::Q_TIMEOUT::[detect_start_sign]} */
            if (Serial.read() == '<') {
                me->value = 0U;
                status_ = Q_TRAN(&LEDviaApp_process_data);
            }
            /*.${AOs::LEDviaApp::SM::communication::Q_TIMEOUT::[else]} */
            else {
                /*.${AOs::LEDviaApp::SM::communication::Q_TIMEOUT::[else]::[check_communication]} */
                if (me->com_counter > 10U) {
                    QACTIVE_POST((QActive *)me, STOP_SIG, 0U);
                    digitalWrite(DEBUG_L, HIGH);
                    status_ = Q_HANDLED();
                }
                /*.${AOs::LEDviaApp::SM::communication::Q_TIMEOUT::[else]::[else]} */
                else {
                    status_ = Q_TRAN(&LEDviaApp_communication);
                }
            }
            break;
        }
        /*.${AOs::LEDviaApp::SM::communication::STOP} */
        case STOP_SIG: {
            status_ = Q_TRAN(&LEDviaApp_LEDcontrol);
            break;
        }
        default: {
            status_ = Q_SUPER(&QHsm_top);
            break;
        }
    }
    return status_;
}
/*.${AOs::LEDviaApp::SM::communication::process_data} ......................*/
static QState LEDviaApp_process_data(LEDviaApp * const me) {
    QState status_;
    switch (Q_SIG(me)) {
        /*.${AOs::LEDviaApp::SM::communication::process_data} */
        case Q_ENTRY_SIG: {
            while (Serial.available()) {
                uint8_t data = Serial.read();
                switch (data) {
                    case '0' ... '9':
                        me->value *= 10U;
                        me->value += data - '0';
                        break;
                    case 'r':
                        me->red = me->value;
                        break;
                    case 'g':
                        me->green = me->value;
                        break;
                    case 'b':
                        me->blue = me->value;
                        break;
                    case 'p':
                        me->program = me->value;
                        break;
                    case '>':
                        QACTIVE_POST((QActive *)me, STOP_SIG, 0U);
                        break;
                }
            }
            status_ = Q_HANDLED();
            break;
        }
        /*.${AOs::LEDviaApp::SM::communication::process_data} */
        case Q_EXIT_SIG: {
            Serial.print(F("A"));
            status_ = Q_HANDLED();
            break;
        }
        default: {
            status_ = Q_SUPER(&LEDviaApp_communication);
            break;
        }
    }
    return status_;
}
/*.$enddef${AOs::LEDviaApp} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
//...