/*********************************************************************************
 *      Copyright:  (C) 2021 LingYun IoT System Studio
 *                  All rights reserved.
 *
 *       Filename:  relay.c
 *    Description:  This file is used to control Relay
 *
 *
 * Pin connection:
 *                 Relay Module           Raspberry Pi Board
 *                  VCC       <----->      5V
 *                   I        <----->      #Pin16(BCM GPIO23)
 *                  GND       <----->      GND
 *
 * System install:
 *                  sudo apt install -y libgpiod-dev gpiod
 *
 *
 ********************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <dirent.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <signal.h>
#include <getopt.h>
#include <libgen.h>

#include <gpiod.h>

#define DELAY     500

#define ON        1
#define OFF       0

/* relay code */
enum
{
    RELAY1 = 0,
    RELAY_CNT,
};

/* Relay hardware information */
typedef struct relay_info_s
{
    const char         *name;  /* Relay name  */
    int                 gpio;  /* Relay BCM pin number */
    int                 active;/* Relay active GPIO level: 0->low 1->high */
    struct gpiod_line  *line;  /* libgpiod line */
} relay_info_t;

static relay_info_t    relay_info[RELAY_CNT] =
{
    {"relay1",  23, 1, NULL },
};

/* Relay API context */
typedef struct relay_ctx_s
{
    struct gpiod_chip   *chip;
    relay_info_t        *relay;
    int                  count;
} relay_ctx_t;

int init_relay(relay_ctx_t *ctx);
int term_relay(relay_ctx_t *ctx);
int turn_relay(relay_ctx_t *ctx, int which, int cmd);
static inline void msleep(unsigned long ms);

static inline void banner(const char *progname)
{
    printf("%s program Version v1.0.0\n", progname);
    printf("Copyright (C) 2023 LingYun IoT System Studio.\n");
}

static void program_usage(const char *progname)
{

    printf("Usage: %s [OPTION]...\n", progname);
    printf(" This is relay control program. \n");

    printf(" -d[device  ]  Specify relay device, such as 0\n");
    printf(" -s[status  ]  Specify relay status, 0 for open, 1 for close\n");
    printf(" -h[help    ]  Display this help information\n");
    printf(" -v[version ]  Display the program version\n");

    printf("\n");
    banner(progname);
    return;
}

int main(int argc, char **argv)
{
    int             rv;
    char           *progname=NULL;
    int             which = -1;
    int             status = ON;

    relay_ctx_t     relay_ctx =
    {
        .chip  = NULL,
        .relay  = relay_info,
        .count = RELAY_CNT,
    };

    struct option long_options[] = {
        {"device", required_argument, NULL, 'd'},
        {"status", required_argument, NULL, 's'},
        {"version", no_argument, NULL, 'v'},
        {"help", no_argument, NULL, 'h'},
        {NULL, 0, NULL, 0}
    };


    progname = basename(argv[0]);

    /* Parser the command line parameters */
    while ((rv = getopt_long(argc, argv, "d:s:vh", long_options, NULL)) != -1)
    {
        switch (rv)
        {
            case 'd': /*  Set relay number, such as 0...max */
                which = atoi(optarg);
                break;

            case 's': /*  Set relay status, 0 for open and 1 for close */
                status = atoi(optarg);
                break;

            case 'v':  /* Get software version */
                banner(progname);
                return EXIT_SUCCESS;

            case 'h':  /* Get help information */
                program_usage(progname);
                return 0;

            default:
                break;
        }
    }

    if( which<0 || which>=relay_ctx.count )
    {
        printf("ERROR: Invalid relay index [%d], max=%d\n", which, relay_ctx.count-1);
        return 0;
    }


    if( (rv=init_relay(&relay_ctx)) < 0 )
    {
        printf("initial relay gpio failure, rv=%d\n", rv);
        return 1;
    }

    turn_relay(&relay_ctx, which, status);

    term_relay(&relay_ctx);
    return 0;
}

int term_relay(relay_ctx_t *ctx)
{
    int            i;
    relay_info_t  *relay;

    if( !ctx )
    {
        printf("Invalid input arguments\n");
        return -1;
    }

    if( !ctx->chip )
        return 0;

    for(i=0; i<ctx->count; i++)
    {
        relay = &ctx->relay[i];

        if( relay->line )
            gpiod_line_release(relay->line);
    }

    gpiod_chip_close(ctx->chip);
    return 0;
}


int init_relay(relay_ctx_t *ctx)
{
    int            i, rv;
    relay_info_t  *relay;

    if( !ctx )
    {
        printf("Invalid input arguments\n");
        return -1;
    }

    ctx->chip = gpiod_chip_open_by_name("gpiochip0");
    if( !ctx->chip )
    {
        printf("open gpiochip failure, maybe you need running as root\n");
        return -2;
    }


    for(i=0; i<ctx->count; i++)
    {
        relay = &ctx->relay[i];

        relay->line = gpiod_chip_get_line(ctx->chip, relay->gpio);
        if( !relay->line )
        {
            printf("open gpioline for %s[%d] failed\n", relay->name, relay->gpio);
            rv = -3;
            goto failed;
        }

        rv  = gpiod_line_request_output(relay->line, relay->name, !relay->active);
        if( rv )
        {
            printf("request gpio output for %5s[%d] failed\n", relay->name, relay->gpio);
            rv = -4;
            goto failed;
        }

        //printf("request %s[%d] for gpio output okay\n", relay->name, relay->gpio);
    }

    return 0;

failed:
    term_relay(ctx);
    return rv;
}

int turn_relay(relay_ctx_t *ctx, int which, int cmd)
{
    int            rv = 0;
    relay_info_t  *relay;

    if( !ctx || which<0 || which>=ctx->count )
    {
        printf("Invalid input arguments\n");
        return -1;
    }

    relay = &ctx->relay[which];

    if( OFF == cmd )
    {
        gpiod_line_set_value(relay->line, !relay->active);
    }
    else
    {
        gpiod_line_set_value(relay->line, relay->active);
    }

    return 0;
}

static inline void msleep(unsigned long ms)
{
    struct timespec cSleep;
    unsigned long ulTmp;

    cSleep.tv_sec = ms / 1000;
    if (cSleep.tv_sec == 0)
    {
        ulTmp = ms * 10000;
        cSleep.tv_nsec = ulTmp * 100;
    }
    else
    {
        cSleep.tv_nsec = 0;
    }

    nanosleep(&cSleep, 0);

    return ;
}