shellmatta/example/main.c

/*
 * main.c
 *
 *  Created on: Jun 10, 2019
 *      Author: stefan
 */


#include "shellmatta.h"
#include <stdint.h>
#include <stdio.h>
#include <ncurses.h>
#include <stdbool.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <string.h>
#include <errno.h>


static bool exitRequest = false;
int f;
shellmatta_handle_t handle;

void set_blocking (int fd, int should_block)
{
        struct termios tty;
        memset (&tty, 0, sizeof tty);
        if (tcgetattr (fd, &tty) != 0)
        {
                printf ("error %d from tggetattr", errno);
                return;
        }

        tty.c_cc[VMIN]  = should_block ? 1 : 0;
        tty.c_cc[VTIME] = 5;            // 0.5 seconds read timeout

        if (tcsetattr (fd, TCSANOW, &tty) != 0)
            printf ("error %d setting term attributes", errno);
}


static shellmatta_retCode_t doSomething(shellmatta_handle_t handle, const char *arguments, uint32_t length)
{
    shellmatta_printf(handle, "%s - length: %u", arguments, length);
    return SHELLMATTA_OK;
}
shellmatta_cmd_t doSomethingCmd = {"doSomething", "do", "Function does something", "use me, please", doSomething, NULL};

static shellmatta_retCode_t doSome(shellmatta_handle_t handle, const char *arguments, uint32_t length)
{

    shellmatta_write(handle, "blubb\r\n", 7u);

    shellmatta_configure(handle, SHELLMATTA_MODE_INSERT, false, '\r');

    (void)arguments;
    (void)length;

    return SHELLMATTA_OK;
}
shellmatta_cmd_t doSomeCmd = {"adoSome2", "adof2", "Function does something", "use me, please", doSome, NULL};

static shellmatta_retCode_t removeCmdFct(shellmatta_handle_t handle, const char *arguments, uint32_t length)
{
    shellmatta_printf(handle, "removing command: %s\r\n", doSomeCmd.cmd);

    shellmatta_removeCmd(handle, &doSomeCmd);

    (void)arguments;
    (void)length;

    return SHELLMATTA_OK;
}
shellmatta_cmd_t removeCommand = {"remove", "r", "Function removes a command", "", removeCmdFct, NULL};


static shellmatta_retCode_t quit(shellmatta_handle_t handle, const char *arguments, uint32_t length)
{
    exitRequest = true;

    (void)handle;
    (void)arguments;
    (void)length;

    return SHELLMATTA_OK;
}
shellmatta_cmd_t quitCommand = {"quit", "q", "Function quits the shell", "", quit, NULL};

static shellmatta_retCode_t empty(shellmatta_handle_t handle, const char *arguments, uint32_t length)
{
    (void)arguments;
    (void)length;

    shellmatta_printf(handle, "empty function called\r\n");
    shellmatta_configure(handle, SHELLMATTA_MODE_OVERWRITE, true, '\r');

    return SHELLMATTA_OK;
}
shellmatta_cmd_t emptyCommand = {"empty", NULL, NULL, NULL, empty, NULL};

static shellmatta_retCode_t reset(shellmatta_handle_t handle, const char *arguments, uint32_t length)
{
    (void)arguments;
    (void)length;

    if(0 == strncmp(arguments, "prompt", length))
    {
        shellmatta_resetShell(handle, true);
    }
    else
    {
        shellmatta_resetShell(handle, false);
    }

    shellmatta_configure(handle, SHELLMATTA_MODE_INSERT, true, '\r');

    return SHELLMATTA_OK;
}
shellmatta_cmd_t resetCommand = {"reset", NULL, "resets the shellmatta instance", "reset [prompt]", reset, NULL};

static shellmatta_retCode_t continuous(shellmatta_handle_t handle, const char *arguments, uint32_t length)
{
    (void)arguments;
    (void)length;

    shellmatta_retCode_t ret = SHELLMATTA_CONTINUE;
    uint32_t stdinLength;
    char *stdinData;

    shellmatta_read(handle, &stdinData, &stdinLength);
    if(NULL != stdinData)
    {
        if('x' == stdinData[0u])
        {
            ret = SHELLMATTA_OK;
        }

        stdinData[0u] ++;
        shellmatta_write(handle, stdinData, stdinLength);
    }
    return ret;
}
shellmatta_cmd_t continuousCommand = {"continuous", "cont", "prints continously all input bytes", "continuous", continuous, NULL};


shellmatta_retCode_t writeFct(const char* data, uint32_t length)
{
    write(f, data, length);

    return SHELLMATTA_OK;
}

int main(int argc, char **argv)
{
    static char buffer[1024];
    static char historyBuffer[4096];
    static shellmatta_instance_t instance;

    if(2 != argc)
    {
        printf("%s <serial device>\n", argv[0u]);
        return -1;
    }

    f = open(argv[1u], O_RDWR | O_SYNC);

    if (f < 0)
    {
        printf("failure opening device %s %d\n", argv[1u], errno);
        return f;
    }

    set_blocking (f, 1);

    shellmatta_doInit(  &instance,
                        &handle,
                        buffer,
                        sizeof(buffer),
                        historyBuffer,
                        sizeof(historyBuffer),
                        "shellmatta->",
                        NULL,
                        writeFct);
    shellmatta_addCmd(handle, &doSomethingCmd);
    shellmatta_addCmd(handle, &doSomeCmd);
    shellmatta_addCmd(handle, &quitCommand);
    shellmatta_addCmd(handle, &removeCommand);
    shellmatta_addCmd(handle, &emptyCommand);
    shellmatta_addCmd(handle, &resetCommand);
    shellmatta_addCmd(handle, &continuousCommand);

    while(exitRequest == false)
    {
        char c;

        int res = 0;
        res = read (f, &c, 1);

        fprintf(stdout, "0x%02x \n", c);
        fflush(stdout);

        shellmatta_processData(handle, &c, res);
    }

    close(f);

    return 0;
}