zst123
Published © GPL3+

Modular HMI with RT-Thread & Infineon Psoc6

HMI For Industrial Application. Add LCD monitoring & capacitive touch to modernize your ICS systems. Expand quickly over Modbus TCP & Wi-Fi.

IntermediateFull instructions provided24 hours121
Modular HMI with RT-Thread & Infineon Psoc6

Things used in this project

Hardware components

RT-Thread Infineon Psoc6-evaluationkit-062S2
×1
0.96" OLED 64x128 Display Module
ElectroPeak 0.96" OLED 64x128 Display Module
×1

Software apps and online services

RT-Thread IoT OS
RT-Thread IoT OS

Story

Read more

Code

myapp.c

C/C++
Main application code integrating wlan and libmodbus functions
#include <rtthread.h>
#include <rtdevice.h>
#include <stdio.h>
#include <string.h>
#include <modbus.h>
#include <sal_socket.h>

#define THREAD_PRIORITY         20
#define THREAD_STACK_SIZE       1024*32
#define THREAD_TIMESLICE        5

// Wifi Credentials
const char * ssid = "YOUR_SSID";
const char * password = "YOUR_PASSWORD";

/* Entry Function for Thread 1 */
static rt_thread_t myapp_tid = RT_NULL;

// Export variables
extern uint8_t motor;
extern uint8_t green_led;
extern uint8_t red_led;
extern uint8_t run_btn;
extern uint8_t stop_btn;
extern uint8_t alarm_switch;

uint8_t motor = 0;
uint8_t green_led = 0;
uint8_t red_led = 0;
uint8_t run_btn = 0;
uint8_t stop_btn = 0;
uint8_t alarm_switch = 0;

static void myapp_entry(void *parameter) {
    // Wait for Wifi to become stable
    rt_thread_mdelay(1000);

    // Connect to Wifi
    while(rt_wlan_connect(ssid, password) != RT_EOK) {
        rt_kprintf("Could not connect to Wifi. Retrying... \r\n");
        rt_thread_mdelay(1000 * 3);
    }
    rt_kprintf("Wifi successfully connected \r\n");

    // Wait to obtain IP address
    rt_thread_mdelay(10000);

    // Connect to modbus server
    modbus_t *ctx = RT_NULL;
    ctx = modbus_new_tcp("192.168.77.77", 502, AF_INET);
    if (ctx == NULL) {
        rt_kprintf("Unable to allocate libmodbus context\r\n");
    }
    modbus_set_debug(ctx, FALSE);
    modbus_set_slave(ctx, 1);
    modbus_set_response_timeout(ctx, 0, 1000000);

    for (int attempt = 0; attempt < 100; attempt++) {
        rt_kprintf("Modbus init %d attempt\r\n", attempt);
        int connect_status = modbus_connect(ctx);

        if(connect_status < 0) {
            rt_kprintf("Modbus connect failed, error=%d\r\n", connect_status);
        } else {
            rt_kprintf("Modbus connect success \r\n");
            while (1) {
                uint8_t coils[8] = {0};
                memset(coils, 0, 8);
                uint8_t inputs[8] = {0};
                memset(inputs, 0, 8);

                // Note: libmodbus is zero-indexed
                // Coils start at 8193 (one-indexed)
                // Inputs start at 1 (one-indexed)
                int regs = modbus_read_bits(ctx, 8192, 8, coils);
                if(regs < 0) break;

                int regs2 = modbus_read_input_bits(ctx, 0, 8, inputs);
                if(regs2 < 0) break;

                rt_kprintf("Reading modbus: \r\n");
                rt_kprintf("-------------------------------------------\r\n");
                rt_kprintf("Coils: ");
                for (int i = 0; i < 8; i++) {
                    rt_kprintf("<%d>", coils[i]);
                }
                rt_kprintf("\r\n");

                rt_kprintf("Inputs: ");
                for (int i = 0; i < 8; i++) {
                    rt_kprintf("<%d>", inputs[i]);
                }
                rt_kprintf("\r\n");
                rt_kprintf("-------------------------------------------\r\n");

                // Export to variables
                motor = coils[0];           // Q1
                red_led = coils[1];         // Q2
                green_led = coils[2];       // Q3

                run_btn = inputs[5];        // I6
                stop_btn = inputs[6];        // I7
                alarm_switch = inputs[7];    // I8

                rt_thread_mdelay(300);

            }
        }
        rt_kprintf("Modbus cleaning up \r\n");
        modbus_close(ctx);
        rt_thread_mdelay(1000);
    }
    modbus_free(ctx);
}

int myapp_begin(void) {
    myapp_tid = rt_thread_create("myapp_thread",
            myapp_entry, RT_NULL,
            THREAD_STACK_SIZE,
            THREAD_PRIORITY,
            THREAD_TIMESLICE);
    if (myapp_tid != RT_NULL) {
        rt_thread_startup(myapp_tid);
    }
}

INIT_APP_EXPORT(myapp_begin);

myoled.c

C/C++
OLED display code
#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>
#include <string.h>
#include <stdio.h>
#include "ssd1306.h"

#define THREAD_PRIORITY         20
#define THREAD_STACK_SIZE       1024*64
#define THREAD_TIMESLICE        5

/* Entry Function for Thread 1 */
static rt_thread_t myoled_tid = RT_NULL;

extern uint8_t motor;
extern uint8_t green_led;
extern uint8_t red_led;
extern uint8_t run_btn;
extern uint8_t stop_btn;
extern uint8_t alarm_switch;


void myoled_entry() {
    do {
        ssd1306_Fill(Black);
        ssd1306_SetCursor(2, 18*0);
        ssd1306_WriteString("Connecting", Font_11x18, White);
        ssd1306_SetCursor(2, 18*1);
        ssd1306_WriteString("to Modbus", Font_11x18, White);
        ssd1306_UpdateScreen();
        rt_thread_mdelay(200);
    } while (!motor && !green_led && !red_led && !run_btn && !stop_btn && !alarm_switch);

    while (1) {
        ssd1306_Fill(Black);
        ssd1306_SetCursor(2, 20*0);
        if (green_led) {
            ssd1306_WriteString("Motor On", Font_11x18, White);
        } else if (red_led) {
            ssd1306_WriteString("Motor Off", Font_11x18, White);
        }

        ssd1306_SetCursor(2, 20*1);
        if (run_btn) {
            ssd1306_WriteString("Run", Font_11x18, White);
        } else if (stop_btn) {
            ssd1306_WriteString("Stop", Font_11x18, White);
        }

        ssd1306_SetCursor(2, 20*2);
        if (alarm_switch) {
            ssd1306_WriteString("Alarm!", Font_11x18, White);
        }

        ssd1306_UpdateScreen();
        rt_thread_mdelay(500);
    }

}

int myoled_begin(void) {
    rt_pin_mode(P10_2, PIN_MODE_OUTPUT);
    rt_pin_write(P10_2, PIN_LOW);

    rt_pin_mode(P10_3, PIN_MODE_OUTPUT);
    rt_pin_write(P10_3, PIN_HIGH);

    ssd1306_Init();

    myoled_tid = rt_thread_create("myoled_thread",
            myoled_entry, RT_NULL,
            THREAD_STACK_SIZE,
            THREAD_PRIORITY,
            THREAD_TIMESLICE);
    if (myoled_tid != RT_NULL) {
        rt_thread_startup(myoled_tid);
    }
}

INIT_APP_EXPORT(myoled_begin);

Credits

zst123
14 projects • 34 followers
An infocomm and electronics enthusiast. https://www.manzelseet.com
Contact

Comments

Please log in or sign up to comment.

Related channels and tags
  • ElectroPeak
  • Internet of Things
  • Internet of Things
  • RT-Thread