Getting Started with Adapnex

#pragma once

#include "adapnex.h"

class MainTask final : public Task {
public:
    // --- Interface Variables ---
    // These are simple C++ types, effectively our "Software IO".

    // Inputs
    bool button = false;         // Digital input from button
    float analog_voltage = 0.0f; // Analog input from potentiometer (0-10V)

    // Outputs
    bool blink = false;      // Digital output for LED state
    float analog_out = 0.0f; // For the visualization in the simulator

private:
    // --- Function Blocks ---
    // Instantiate a standard Square Wave Generator.
    // This block maintains its own internal timer state.
    SquareWaveGenerator generator;

    // --- The Control Loop ---
    // This function runs cyclically (e.g., every 20ms).
    void Update() override {
        // 1. Process Logic
        // Convert voltage to duration:
        // 0V -> 0ms (Fastest)
        // 10V -> 500ms (Slowest)
        const Duration t = static_cast<int>(analog_voltage * 50) * 1ms;

        // 2. Execute Generator
        // If 'button' is true, toggle 'blink' with ON/OFF time 't'.
        generator(button, t, t, blink);

        // 3. Map Output
        // For visualization, output 10V when blink is true, 0V otherwise.
        analog_out = blink ? 10.0f : 0.0f;
    }
};

#include "adapnex.h"

#include "main_task.h"

// The 'setup' function is the entry point for Adapnex applications
void setup() {
    // --- 1. Configure the Scheduler ---
    // Create a Cyclic Task Group that runs every 20ms.
    const auto main_group = Application::CreateCyclicTaskGroup(20ms, 0);

    // Instantiate our control logic task
    const auto main_task = main_group->CreateTask<MainTask>();

    // --- 2. Configure Hardware Drivers ---
    // Add the driver for the WAGO Compact Controller 100.
    const auto io_driver = main_group->CreateTask<CC100IODriver>();

    // --- 3. Wiring ---
    // The '>>' and '<<' operators represent physical signal flow.

    // Connect Inputs: Driver >> Task
    io_driver->DI1 >> main_task->button;         // Map DI1 to 'button'
    io_driver->AI1 >> main_task->analog_voltage; // Map AI1 to 'analog_voltage'

    // Connect Outputs: Driver << Task
    io_driver->DO1 << main_task->blink;          // Map 'blink' to DO1
    io_driver->AO1 << main_task->analog_out;     // Map 'analog_out' to AO1
}

cmake_minimum_required(VERSION 3.25)
project(example_blink)

# Create the executable application
# 'adapnex_executable' handles toolchains and dependencies automatically.
adapnex_executable(example_blink main.cpp)

#include "adapnex.h"

#include <gtest/gtest.h>

#include "main_task.h"

// Test Case 1: Verify logic with low voltage (Fast Blink)
TEST_F(Simulation, MainTaskFastBlink) {
    // Setup a virtual scheduler
    const auto main_group = Application::CreateCyclicTaskGroup(10ms, 0);
    const auto main_task = main_group->CreateTask<MainTask>();

    // 1. Simulate Inputs
    main_task->button = true;
    main_task->analog_voltage = 2; // 2V -> 100ms duration (Period 200ms)

    // 2. Advance time and check state
    for (int i = 0; i < 10; ++i) {
        Simulate(100ms);
        ASSERT_TRUE(main_task->blink); // Should be ON
        Simulate(100ms);
        ASSERT_FALSE(main_task->blink); // Should be OFF
    }
}

// Test Case 2: Verify logic with high voltage (Slow Blink)
TEST_F(Simulation, MainTaskSlowBlink) {
    const auto main_group = Application::CreateCyclicTaskGroup(10ms, 0);
    const auto main_task = main_group->CreateTask<MainTask>();

    main_task->button = true;
    main_task->analog_voltage = 5; // 5V -> 250ms duration (Period 500ms)

    for (int i = 0; i < 10; ++i) {
        Simulate(250ms);
        ASSERT_TRUE(main_task->blink);
        Simulate(250ms);
        ASSERT_FALSE(main_task->blink);
    }
}

# Enable unit testing for this project
enable_testing()

# Register the test suite
# This sets up the target for running automated unit tests.
adapnex_tests(example_blink_tests main_test.cpp)

adapnex test