skn_rpi_helpers.h File Reference

#include "skn_common_headers.h"
#include <sys/utsname.h>
#include <wiringPi.h>
#include <pcf8574.h>
#include <mcp23008.h>
#include <mcp23017.h>
#include <wiringSerial.h>
#include <lcd.h>

Include dependency graph for skn_rpi_helpers.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
PLCDDevice	skn_device_manager_SerialPort (PDisplayManager pdm)
PLCDDevice	skn_device_manager_MCP23008 (PDisplayManager pdm)
PLCDDevice	skn_device_manager_MCP23017 (PDisplayManager pdm)
PLCDDevice	skn_device_manager_PCF8574 (PDisplayManager pdm)
PDisplayManager	skn_get_display_manager_ref ()
int	skn_display_manager_do_work (char *client_request_message)
PDisplayLine	skn_display_manager_add_line (PDisplayManager pdmx, char *client_request_message)
int	skn_scroller_scroll_lines (PDisplayLine pdl, int lcd_handle, int line)
char *	skn_scroller_pad_right (char *buffer)
char *	skn_scroller_wrap_blanks (char *buffer)
int	skn_signal_manager_startup (pthread_t *psig_thread, sigset_t *psignal_set, long *l_thread_complete)
int	skn_signal_manager_shutdown (pthread_t sig_thread, sigset_t *psignal_set, long *l_thread_complete)
void	skn_device_manager_backlight (int af_backlight, int state)
int	skn_device_manager_LCD_setup (PDisplayManager pdm, char *device_name)
int	skn_device_manager_LCD_shutdown (PDisplayManager pdm)
int	skn_handle_display_command_line (int argc, char **argv)
int	generate_rpi_model_info (char *msg)
int	generate_cpu_temps_info (char *msg)

Variables
int	gd_i_rows
int	gd_i_cols
int	gd_i_i2c_address
char *	gd_pch_serial_port
char *	gd_pch_device_name
PDisplayManager	gp_structure_pdm

Function Documentation

int generate_cpu_temps_info

(

char *

msg

)

DO NOT USE THIS IN MODULES THAT HANDLE A I2C Based LCD RPi cannot handle I2C and GetCpuTemp() without locking the process in an uniterrupted sleep; forcing a power cycle.

Definition at line 49 of file lcd_display_client.c.

References _temps::c, _temps::f, getCpuTemps(), and SZ_INFO_BUFF.

Referenced by main().

                                       {
    static CpuTemps cpuTemp;
    int mLen = 0;

    memset(&cpuTemp, 0, sizeof(CpuTemps));
    if ( getCpuTemps(&cpuTemp) != -1 ) {
        mLen = snprintf(msg, SZ_INFO_BUFF-1, "%s %s", cpuTemp.c, cpuTemp.f);
    } else {
        mLen = snprintf(msg, SZ_INFO_BUFF-1, "Temp: N/A");
    }

    return mLen;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int generate_rpi_model_info

(

char *

msg

)

Definition at line 328 of file skn_rpi_helpers.c.

References gd_ch_intfName, gd_ch_ipAddress, skn_get_number_of_cpu_cores(), and SZ_INFO_BUFF.

Referenced by skn_display_manager_do_work().

                                       {
    int model = 0, rev = 0, mem = 0, maker = 0, overVolted = 0, mLen = 0;
    char * message = "Device has an unknown model type.\n";

    piBoardId(&model, &rev, &mem, &maker, &overVolted);
    if (model == PI_MODEL_UNKNOWN) {
        mLen = snprintf(msg, SZ_INFO_BUFF -1, "%s", message);
    } else {
        mLen = snprintf(msg, SZ_INFO_BUFF -1, "Device: %s, Cpus: %ld, Rev: %s, Mem: %dMB, Maker: %s %s, %s:%s", piModelNames[model],
                        skn_get_number_of_cpu_cores(), piRevisionNames[rev], mem, piMakerNames[maker], overVolted ? "[OV]" : "", gd_ch_intfName,
                        gd_ch_ipAddress);
    }
    return mLen;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void skn_device_manager_backlight	(	int	af_backlight,
		int	state
	)

Definition at line 184 of file skn_rpi_helpers.c.

Referenced by skn_device_manager_init_i2c(), and skn_device_manager_LCD_shutdown().

                                                               {
    digitalWrite(af_backlight, state);
}

Here is the caller graph for this function:

int skn_device_manager_LCD_setup	(	PDisplayManager	pdm,
		char *	device_name
	)

Definition at line 234 of file skn_rpi_helpers.c.

References _DISPLAY_MANAGER::lcd_handle, PLATFORM_ERROR, skn_device_manager_MCP23008(), skn_device_manager_MCP23017(), skn_device_manager_PCF8574(), and skn_device_manager_SerialPort().

Referenced by skn_display_manager_do_work().

                                                                         {
    PLCDDevice rc = NULL;

    /*
     * Initial I2C Services */
    wiringPiSetupSys();

    if (strcmp(device_name, "mcp") == 0) {
        rc = skn_device_manager_MCP23008(pdm);
    } else if (strcmp(device_name, "mc7") == 0) {
        rc = skn_device_manager_MCP23017(pdm);
    } else if (strcmp(device_name, "ser") == 0) {
        rc = skn_device_manager_SerialPort(pdm);
    } else { // PCF8574
        rc = skn_device_manager_PCF8574(pdm);
    }

    if (rc == NULL) {
        return PLATFORM_ERROR;
    } else {
        return pdm->lcd_handle;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int skn_device_manager_LCD_shutdown

(

PDisplayManager

pdm

)

Definition at line 257 of file skn_rpi_helpers.c.

References _IICLCD::af_backlight, _IICLCD::af_blue, _IICLCD::af_green, _IICLCD::af_red, gd_pch_device_name, _DISPLAY_MANAGER::lcd, _DISPLAY_MANAGER::lcd_handle, and skn_device_manager_backlight().

Referenced by skn_display_manager_do_work().

                                                         {
    if (strcmp("ser", gd_pch_device_name) == 0) {
        char display_off[] = { 0xfe, 0x46 };
        char cls[]   = { 0xfe, 0x58 };

        write(pdm->lcd_handle, display_off, sizeof(display_off));
            sleep(1);
        write(pdm->lcd_handle, cls, sizeof(cls));

        serialClose(pdm->lcd_handle);
    } else {
        lcdClear(pdm->lcd_handle);
        if (strcmp(gd_pch_device_name, "mc7") == 0) {
            skn_device_manager_backlight(pdm->lcd.af_red, LOW);
            skn_device_manager_backlight(pdm->lcd.af_green, LOW);
            skn_device_manager_backlight(pdm->lcd.af_blue, LOW);
        } else {
            skn_device_manager_backlight(pdm->lcd.af_backlight, LOW);
        }
    }
    return EXIT_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PLCDDevice skn_device_manager_MCP23008

(

PDisplayManager

pdm

)

Definition at line 110 of file skn_rpi_helpers.c.

References _IICLCD::af_backlight, _IICLCD::af_base, _IICLCD::af_db4, _IICLCD::af_db5, _IICLCD::af_db6, _IICLCD::af_db7, _IICLCD::af_e, _IICLCD::af_rs, _IICLCD::af_rw, _IICLCD::cbName, gd_i_i2c_address, _IICLCD::i2c_address, _DISPLAY_MANAGER::lcd, SD_ERR, SD_NOTICE, _IICLCD::setup, skn_device_manager_init_i2c(), and SZ_CHAR_BUFF.

Referenced by skn_device_manager_LCD_setup().

                                                            {
    PLCDDevice plcd =  NULL;
    int base = 0;

    if (pdm == NULL) {
        skn_logger(SD_ERR, "DeviceManager failed to acquire needed resources. %d:%s", errno, strerror(errno));
        return NULL;
    }

    plcd = (PLCDDevice)&pdm->lcd;
    strncpy(plcd->cbName, "LCDDevice#MCP23008", SZ_CHAR_BUFF-1);
    if (gd_i_i2c_address != 0) {
        plcd->i2c_address = gd_i_i2c_address;
    } else {
        plcd->i2c_address = 0x20;
    }

    skn_logger(SD_NOTICE, "DeviceManager using device [%s](0x%02x)", plcd->cbName, plcd->i2c_address);

    base = plcd->af_base = 100;
    plcd->af_backlight = base + 7;
    plcd->af_e = base + 2;
    plcd->af_rs = base + 1;
    plcd->af_rw = base + 0;

    plcd->af_db4 = base + 3;
    plcd->af_db5 = base + 4;
    plcd->af_db6 = base + 5;
    plcd->af_db7 = base + 6;

    plcd->setup = &mcp23008Setup; //   mcp23008Setup(AF_BASE, 0x20);

    return skn_device_manager_init_i2c(pdm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PLCDDevice skn_device_manager_MCP23017

(

PDisplayManager

pdm

)

Definition at line 72 of file skn_rpi_helpers.c.

References _IICLCD::af_backlight, _IICLCD::af_base, _IICLCD::af_blue, _IICLCD::af_db4, _IICLCD::af_db5, _IICLCD::af_db6, _IICLCD::af_db7, _IICLCD::af_e, _IICLCD::af_green, _IICLCD::af_red, _IICLCD::af_rs, _IICLCD::af_rw, _IICLCD::cbName, gd_i_i2c_address, _IICLCD::i2c_address, _DISPLAY_MANAGER::lcd, SD_ERR, SD_NOTICE, _IICLCD::setup, skn_device_manager_init_i2c(), and SZ_CHAR_BUFF.

Referenced by skn_device_manager_LCD_setup().

                                                            {
    PLCDDevice plcd =  NULL;
    int base = 0;

    if (pdm == NULL) {
        skn_logger(SD_ERR, "DeviceManager failed to acquire needed resources. %d:%s", errno, strerror(errno));
        return NULL;
    }

    plcd = (PLCDDevice)&pdm->lcd;
    strncpy(plcd->cbName, "LCDDevice#MCP23017", SZ_CHAR_BUFF-1);
    if (gd_i_i2c_address != 0) {
        plcd->i2c_address = gd_i_i2c_address;
    } else {
        plcd->i2c_address = 0x20;
    }

    skn_logger(SD_NOTICE, "DeviceManager using device [%s](0x%02x)", plcd->cbName, plcd->i2c_address);

    base = plcd->af_base = 100;
    plcd->af_backlight = base + 8;
    plcd->af_red = base + 6;
    plcd->af_green = base + 7;
    plcd->af_blue = base + 8;

    plcd->af_e  = base + 13;
    plcd->af_rs = base + 15;
    plcd->af_rw = base + 14;

    plcd->af_db4 = base + 12;
    plcd->af_db5 = base + 11;
    plcd->af_db6 = base + 10;
    plcd->af_db7 = base + 9;

    plcd->setup = &mcp23017Setup; //   mcp23017Setup(AF_BASE, 0x20);

    return skn_device_manager_init_i2c(pdm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PLCDDevice skn_device_manager_PCF8574

(

PDisplayManager

pdm

)

Definition at line 145 of file skn_rpi_helpers.c.

References _IICLCD::af_backlight, _IICLCD::af_base, _IICLCD::af_db4, _IICLCD::af_db5, _IICLCD::af_db6, _IICLCD::af_db7, _IICLCD::af_e, _IICLCD::af_rs, _IICLCD::af_rw, _IICLCD::cbName, gd_i_i2c_address, _IICLCD::i2c_address, _DISPLAY_MANAGER::lcd, SD_ERR, SD_NOTICE, _IICLCD::setup, skn_device_manager_init_i2c(), and SZ_CHAR_BUFF.

Referenced by skn_device_manager_LCD_setup().

                                                           {
    PLCDDevice plcd =  NULL;
    int base = 0;

    if (pdm == NULL) {
        skn_logger(SD_ERR, "DeviceManager failed to acquire needed resources. %d:%s", errno, strerror(errno));
        return NULL;
    }

    plcd = (PLCDDevice)&pdm->lcd;
    memset(plcd, 0, sizeof(LCDDevice));
    strncpy(plcd->cbName, "LCDDevice#PCF8574", SZ_CHAR_BUFF-1);
    if (gd_i_i2c_address != 0) {
        plcd->i2c_address = gd_i_i2c_address;
    } else {
        plcd->i2c_address = 0x27;
    }

    skn_logger(SD_NOTICE, "DeviceManager using device [%s](0x%02x)", plcd->cbName, plcd->i2c_address);

    base = plcd->af_base = 100;
    plcd->af_backlight = base + 3;
    plcd->af_e = base + 2;
    plcd->af_rs = base + 0;
    plcd->af_rw = base + 1;

    plcd->af_db4 = base + 4;
    plcd->af_db5 = base + 5;
    plcd->af_db6 = base + 6;
    plcd->af_db7 = base + 7;


    plcd->setup = &pcf8574Setup; // pcf8574Setup(AF_BASE, 0x27);

    return skn_device_manager_init_i2c(pdm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PLCDDevice skn_device_manager_SerialPort

(

PDisplayManager

pdm

)

Definition at line 26 of file skn_rpi_helpers.c.

References _IICLCD::cbName, _IICLCD::ch_serial_port_name, gd_pch_serial_port, _DISPLAY_MANAGER::lcd, _IICLCD::lcd_handle, _DISPLAY_MANAGER::lcd_handle, PLATFORM_ERROR, SD_ERR, SD_NOTICE, and SZ_CHAR_BUFF.

Referenced by skn_device_manager_LCD_setup().

                                                              {
    PLCDDevice plcd =  NULL;

    if (pdm == NULL) {
        skn_logger(SD_ERR, "DeviceManager failed to acquire needed resources. %d:%s", errno, strerror(errno));
        return NULL;
    }

    plcd = (PLCDDevice)&pdm->lcd;
    strncpy(plcd->cbName, "LCDDevice#SerialPort", SZ_CHAR_BUFF-1);
    if (gd_pch_serial_port != NULL) {
        strncpy(plcd->ch_serial_port_name, gd_pch_serial_port, SZ_CHAR_BUFF-1);
    } else {
        strncpy(plcd->ch_serial_port_name, "/dev/ttyACM0", SZ_CHAR_BUFF-1);
    }

    skn_logger(SD_NOTICE, "DeviceManager using  device [%s](%s)", plcd->cbName, gd_pch_serial_port);

    pdm->lcd_handle = plcd->lcd_handle =  serialOpen (plcd->ch_serial_port_name, 9600);
    if (plcd->lcd_handle == PLATFORM_ERROR) {
        skn_logger(SD_ERR, "DeviceManager failed to acquire needed resources: SerialPort=%s %d:%s",
                   plcd->ch_serial_port_name, errno, strerror(errno));
        return NULL;
    }

    // set backlight & clear screen
    char display_on[] = { 0xfe, 0x42 };
    char  cls[]   = { 0xfe, 0x58 };
    char home[]  = { 0xfe, 0x48 };
//    char set_cols_rows[] = {0xfe, 0xd1, gd_i_cols, gd_i_rows };
    char set_contrast[] = {0xfe, 0x50, 0xdc};
    char cursor_off[] = {0xfe, 0x4B };

    write(pdm->lcd_handle, set_contrast, sizeof(set_contrast));
        sleep(1);
    write(pdm->lcd_handle, home, sizeof(home));
        sleep(1);
    write(pdm->lcd_handle, cursor_off, sizeof(cursor_off));
        sleep(1);
    write(pdm->lcd_handle, cls, sizeof(cls));
        sleep(1);
    write(pdm->lcd_handle, display_on, sizeof(display_on));
        sleep(1);

    return plcd;
}

Here is the caller graph for this function:

PDisplayLine skn_display_manager_add_line	(	PDisplayManager	pdmx,
		char *	client_request_message
	)

Definition at line 483 of file skn_rpi_helpers.c.

References _DISPLAY_LINE::active, ARY_MAX_DM_LINES, _DISPLAY_LINE::ch_display_msg, _DISPLAY_MANAGER::current_line, _DISPLAY_LINE::display_pos, gd_i_cols, _DISPLAY_LINE::msg_len, _DISPLAY_MANAGER::next_line, _DISPLAY_MANAGER::pdsp_collection, _DISPLAY_LINE::scroll_enabled, SD_DEBUG, skn_get_display_manager_ref(), skn_scroller_wrap_blanks(), and SZ_INFO_BUFF.

Referenced by skn_display_manager_do_work(), and skn_display_manager_message_consumer_thread().

                                                                                               {
    PDisplayLine pdl = NULL;
    PDisplayManager pdm = NULL;

    pdm = ((pdmx == NULL) ? skn_get_display_manager_ref() : pdmx);
    if (pdm == NULL || client_request_message == NULL) {
        return NULL;
    }

    /*
     * manage next index */
    pdl = pdm->pdsp_collection[pdm->next_line++]; // manage next index
    if (pdm->next_line == ARY_MAX_DM_LINES) {
        pdm->next_line = 0; // roll it
    }

    /*
     * load new message */
    strncpy(pdl->ch_display_msg, client_request_message, (SZ_INFO_BUFF-1));
    pdl->ch_display_msg[SZ_INFO_BUFF - 1] = 0;    // terminate string in case
    pdl->msg_len = strlen(pdl->ch_display_msg);
    pdl->active = 1;
    pdl->display_pos = 0;
    if (pdl->msg_len > gd_i_cols) {
        pdl->scroll_enabled = 1;
        skn_scroller_wrap_blanks(pdl->ch_display_msg);
        pdl->ch_display_msg[(SZ_INFO_BUFF - 1)] = 0;    // terminate string in case
        pdl->msg_len = strlen(pdl->ch_display_msg);
    } else {
        pdl->scroll_enabled = 0;
    }

    /*
     * manage current_line */
    pdm->pdsp_collection[pdm->current_line]->active = 0;
    pdm->pdsp_collection[pdm->current_line++]->msg_len = 0;
    if (pdm->current_line == ARY_MAX_DM_LINES) {
        pdm->current_line = 0;
    }

    skn_logger(SD_DEBUG, "DM Added msg=%d:%d:[%s]", ((pdm->next_line - 1) < 0 ? 0 : (pdm->next_line - 1)), pdl->msg_len, pdl->ch_display_msg);

    /* return this line's pointer */
    return pdl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int skn_display_manager_do_work

(

char *

client_request_message

)

Definition at line 531 of file skn_rpi_helpers.c.

References _DISPLAY_LINE::active, _DISPLAY_MANAGER::current_line, _DISPLAY_MANAGER::dsp_rows, gd_pch_device_name, generate_datetime_info(), generate_loadavg_info(), generate_rpi_model_info(), generate_uname_info(), gi_exit_flag, _DISPLAY_MANAGER::lcd_handle, _DISPLAY_LINE::next, _DISPLAY_MANAGER::pdsp_collection, PLATFORM_ERROR, SD_ERR, SD_NOTICE, skn_device_manager_LCD_setup(), skn_device_manager_LCD_shutdown(), skn_display_manager_add_line(), skn_display_manager_create(), skn_display_manager_destroy(), skn_display_manager_message_consumer_shutdown(), skn_display_manager_message_consumer_startup(), SKN_RUN_MODE_RUN, SKN_RUN_MODE_STOP, skn_scroller_scroll_lines(), skn_time_delay(), and SZ_INFO_BUFF.

Referenced by main().

                                                               {
    int index = 0, dsp_line_number = 0;
    PDisplayManager pdm = NULL;
    PDisplayLine pdl = NULL;
    char ch_lcd_message[4][SZ_INFO_BUFF];
    long host_update_cycle = 0;

    gp_structure_pdm = pdm = skn_display_manager_create(client_request_message);
    if (pdm == NULL) {
        gi_exit_flag = SKN_RUN_MODE_STOP;
        skn_logger(SD_ERR, "Display Manager cannot acquire needed resources. DMCreate()");
        return gi_exit_flag;
    }
    generate_datetime_info (ch_lcd_message[0]);
    generate_rpi_model_info(ch_lcd_message[1]);
//    generate_cpu_temps_info(ch_lcd_message[2]);
    generate_uname_info    (ch_lcd_message[2]);
    generate_loadavg_info  (ch_lcd_message[3]);
    skn_display_manager_add_line(pdm, ch_lcd_message[0]);
    skn_display_manager_add_line(pdm, ch_lcd_message[1]);
    skn_display_manager_add_line(pdm, ch_lcd_message[2]);
    skn_display_manager_add_line(pdm, ch_lcd_message[3]);

    if (skn_device_manager_LCD_setup(pdm, gd_pch_device_name) == PLATFORM_ERROR) {
        gi_exit_flag = SKN_RUN_MODE_STOP;
        skn_logger(SD_ERR, "Display Manager cannot acquire needed resources: lcdSetup().");
        skn_display_manager_destroy(pdm);
        return gi_exit_flag;
    }

    if (skn_display_manager_message_consumer_startup(pdm) == EXIT_FAILURE) {
        gi_exit_flag = SKN_RUN_MODE_STOP;
        skn_logger(SD_ERR, "Display Manager cannot acquire needed resources: Consumer().");
        skn_display_manager_destroy(pdm);
        return gi_exit_flag;
    }

    skn_logger(SD_NOTICE, "Application Active... ");

    /*
     *  Do the Work
     */
    while (gi_exit_flag == SKN_RUN_MODE_RUN) {
        dsp_line_number = 0;
        pdl = pdm->pdsp_collection[pdm->current_line];
    
        for (index = 0; index < pdm->dsp_rows; index++) {
            if (pdl->active == 1) {
                skn_scroller_scroll_lines(pdl, pdm->lcd_handle, dsp_line_number++);
                skn_time_delay(0.18); // delay(180);
            }
            pdl = (PDisplayLine) pdl->next;
        }

        if ((host_update_cycle++ % 900) == 0) {  // roughly every fifteen minutes
            generate_datetime_info (ch_lcd_message[0]);
//            generate_cpu_temps_info(ch_lcd_message[2]);
            generate_loadavg_info  (ch_lcd_message[3]);
            skn_display_manager_add_line(pdm, ch_lcd_message[0]);
            skn_display_manager_add_line(pdm, ch_lcd_message[1]);
            skn_display_manager_add_line(pdm, ch_lcd_message[2]);
            skn_display_manager_add_line(pdm, ch_lcd_message[3]);
            host_update_cycle = 1;
        }
    }

    skn_device_manager_LCD_shutdown(pdm);

    skn_logger(SD_NOTICE, "Application InActive...");

    /*
     * Stop UDP Listener
     */
    skn_display_manager_message_consumer_shutdown(pdm);

    skn_display_manager_destroy(pdm);
    gp_structure_pdm = pdm = NULL;

    return gi_exit_flag;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PDisplayManager skn_get_display_manager_ref

(

)

Definition at line 528 of file skn_rpi_helpers.c.

References gp_structure_pdm.

Referenced by skn_display_manager_add_line().

                                              {
    return gp_structure_pdm;
}

Here is the caller graph for this function:

int skn_handle_display_command_line	(	int	argc,
		char **	argv
	)

Definition at line 785 of file skn_rpi_helpers.c.

References gd_ch_program_name, gd_i_cols, gd_i_debug, gd_i_i2c_address, gd_i_rows, gd_pch_device_name, gd_pch_message, gd_pch_serial_port, PACKAGE_VERSION, SD_ERR, SD_WARNING, and skn_display_print_usage().

Referenced by main().

                                                           {
    int opt = 0;
    int longindex = 0;
    struct option longopts[] = {
            { "debug", 1, NULL, 'd' }, /* required param if */
            { "rows", 1, NULL, 'r' }, /* required param if */
            { "cols", 1, NULL, 'c' }, /* required param if */
            { "message", 1, NULL, 'm' }, /* required param if */
            { "i2c-address", 1, NULL, 'i' }, /* required param if */
            { "12c-chipset", 1, NULL, 't' }, /* required param if */
            { "serial-port", 1, NULL, 'p' }, /* required param if */
            { "version", 0, NULL, 'v' }, /* set true if present */
            { "help", 0, NULL, 'h' }, /* set true if present */
            { 0, 0, 0, 0 } };

    /*
     * Get commandline options
     *  longindex is the current index into longopts
     *  optind is current/last index into argv
     *  optarg is value attached(-d88) or next element(-d 88) of argv
     *  opterr flags a scanning error
     */
    while ((opt = getopt_long(argc, argv, "d:m:r:c:i:t:p:vh", longopts, &longindex)) != -1) {
        switch (opt) {
            case 'd':
                if (optarg) {
                    gd_i_debug = atoi(optarg);
                } else {
                    skn_logger(SD_ERR, "%s: input param was invalid! %c[%d:%d:%d]\n", gd_ch_program_name, (char) opt, longindex, optind,
                                    opterr);
                    return (EXIT_FAILURE);
                }
                break;
            case 'r':
                if (optarg) {
                    gd_i_rows = atoi(optarg);
                    switch (gd_i_rows) {
                        case 2:
                        case 4:
                            break;
                        default:
                            gd_i_rows = 4;
                            skn_logger(SD_WARNING, "%s: input param was invalid! (default of 4 used) %c[%d:%d:%d]\n", gd_ch_program_name,
                                            (char) opt, longindex, optind, opterr);

                    }
                } else {
                    skn_logger(SD_ERR, "%s: input param was invalid! %c[%d:%d:%d]\n", gd_ch_program_name, (char) opt, longindex, optind,
                                    opterr);
                    return (EXIT_FAILURE);
                }
                break;
            case 'c':
                if (optarg) {
                    gd_i_cols = atoi(optarg);
                    switch (gd_i_cols) {
                        case 16:
                        case 20:
                            break;
                        default:
                            gd_i_cols = 20;
                            skn_logger(SD_WARNING, "%s: input param was invalid! (default of 20 used) %c[%d:%d:%d]\n", gd_ch_program_name,
                                            (char) opt, longindex, optind, opterr);

                    }
                } else {
                    skn_logger(SD_ERR, "%s: input param was invalid! %c[%d:%d:%d]\n", gd_ch_program_name, (char) opt, longindex, optind,
                                    opterr);
                    return (EXIT_FAILURE);
                }
                break;
            case 'm':
                if (optarg) {
                    gd_pch_message = strdup(optarg);
                } else {
                    skn_logger(SD_ERR, "%s: input param was invalid! %c[%d:%d:%d]\n", gd_ch_program_name, (char) opt, longindex, optind,
                                    opterr);
                    return (EXIT_FAILURE);
                }
                break;
            case 'i':
                if (optarg) {
                    gd_i_i2c_address = atoi(optarg);
                } else {
                    skn_logger(SD_ERR, "%s: input param was invalid! %c[%d:%d:%d]\n", gd_ch_program_name, (char) opt, longindex, optind,
                                    opterr);
                    return (EXIT_FAILURE);
                }
                break;
            case 't':
                if (optarg) {
                    gd_pch_device_name = strdup(optarg);
                    if ( (strcmp(gd_pch_device_name, "mcp") != 0) &&
                         (strcmp(gd_pch_device_name, "mc7") != 0) &&
                         (strcmp(gd_pch_device_name, "pcf") != 0) &&
                         (strcmp(gd_pch_device_name, "ser") != 0)) {
                        skn_logger(SD_ERR, "%s: unsupported option was invalid! %c[%d:%d:%d] %s\n", gd_ch_program_name, (char) opt, longindex, optind, opterr, gd_pch_device_name);
                        return EXIT_FAILURE;
                    }
                } else {
                    skn_logger(SD_ERR, "%s: input param was invalid! %c[%d:%d:%d]\n", gd_ch_program_name, (char) opt, longindex, optind,
                                    opterr);
                    return (EXIT_FAILURE);
                }
                break;
            case 'p':
                if (optarg) {
                    gd_pch_serial_port = strdup(optarg);
                    if (strlen(gd_pch_serial_port) < 5) {
                        skn_logger(SD_ERR, "%s: input param was invalid! %c[%d:%d:%d]\n", gd_ch_program_name, (char) opt, longindex, optind, opterr);
                        return EXIT_FAILURE;
                    }
                } else {
                    skn_logger(SD_ERR, "%s: input param was invalid! %c[%d:%d:%d]\n", gd_ch_program_name, (char) opt, longindex, optind, opterr);
                    return (EXIT_FAILURE);
                }
                break;
            case 'v':
                skn_logger(SD_ERR, "\n\tProgram => %s\n\tVersion => %s\n\tSkoona Development\n\t<skoona@gmail.com>\n", gd_ch_program_name,
                                PACKAGE_VERSION);
                return (EXIT_FAILURE);
                break;
            case '?':
                skn_logger(SD_ERR, "%s: unknown input param! %c[%d:%d:%d]\n", gd_ch_program_name, (char) opt, longindex, optind, opterr);
                skn_display_print_usage();
                return (EXIT_FAILURE);
                break;
            default: /* help and default */
                skn_display_print_usage();
                return (EXIT_FAILURE);
                break;
        }
    }

    return EXIT_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* skn_scroller_pad_right

(

char *

buffer

)

skn_scroller_pad_right

• fills remaining with spaces and 0 terminates
• buffer message to adjust

Definition at line 367 of file skn_rpi_helpers.c.

References gd_i_cols.

Referenced by skn_scroller_scroll_lines().

                                            {
    int hIndex = 0;

    for (hIndex = strlen(buffer); hIndex < gd_i_cols; hIndex++) {
        buffer[hIndex] = ' ';
    }
    buffer[gd_i_cols] = 0;

    return buffer;
}

Here is the caller graph for this function:

int skn_scroller_scroll_lines	(	PDisplayLine	pdl,
		int	lcd_handle,
		int	line
	)

Scrolls a single line across the lcd display

• best when wrapped in column chars on each side

Definition at line 402 of file skn_rpi_helpers.c.

References _DISPLAY_LINE::ch_display_msg, _DISPLAY_LINE::display_pos, gd_i_cols, gd_pch_device_name, _DISPLAY_LINE::msg_len, skn_scroller_pad_right(), and skn_time_delay().

Referenced by skn_display_manager_do_work().

{
    char buf[40];
    signed int hAdjust = 0, mLen = 0, mfLen = 0;
    char set_col_row_position[] = {0xfe, 0x47, 0x01, 0x01};

    mLen = strlen(&(pdl->ch_display_msg[pdl->display_pos]));
    if (gd_i_cols < mLen) {
        mfLen = pdl->msg_len;
        hAdjust = (mfLen - gd_i_cols);
    }

    snprintf(buf, sizeof(buf) - 1, "%s", &(pdl->ch_display_msg[pdl->display_pos]));
    skn_scroller_pad_right(buf);

    if (strcmp("ser", gd_pch_device_name) == 0 ) {
        set_col_row_position[3] = (unsigned int)line + 1;
        write(lcd_handle, set_col_row_position, sizeof(set_col_row_position));
        skn_time_delay(0.2); // delay(200);
        write(lcd_handle, buf, gd_i_cols - 1);
    } else {
        lcdPosition(lcd_handle, 0, line);
        lcdPuts(lcd_handle, buf);
    }
    if (++pdl->display_pos > hAdjust) {
        pdl->display_pos = 0;
    }

    return pdl->display_pos;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* skn_scroller_wrap_blanks

(

char *

buffer

)

skn_scroller_wrap_blanks

• builds str with 20 chars in front, and 20 at right end

Definition at line 382 of file skn_rpi_helpers.c.

References gd_i_cols, and SZ_INFO_BUFF.

Referenced by skn_display_manager_add_line(), and skn_display_manager_create().

                                              {
    char worker[SZ_INFO_BUFF];
    char col_width_padding[16];

    if (buffer == NULL || strlen(buffer) > SZ_INFO_BUFF) {
        return NULL;
    }

    snprintf(col_width_padding, 16, "%%%ds%%s%%%ds", gd_i_cols, gd_i_cols);
    snprintf(worker, (SZ_INFO_BUFF - 1), col_width_padding, " ", buffer, " ");
    memmove(buffer, worker, SZ_INFO_BUFF-1);
    buffer[SZ_INFO_BUFF - 1] = 0;

    return buffer;
}

Here is the caller graph for this function:

int skn_signal_manager_shutdown	(	pthread_t	sig_thread,
		sigset_t *	psignal_set,
		long *	l_thread_complete
	)

Final step

• may send trapped signal to app, so requester knows it was honored

Definition at line 209 of file skn_signal_manager.c.

References gi_exit_flag, SD_NOTICE, SD_WARNING, and SKN_RUN_MODE_STOP.

Referenced by main().

                                                                                                      {
    void *trc = NULL;
    int rc = EXIT_SUCCESS;

    if (gi_exit_flag <= SKN_RUN_MODE_STOP) {
        gi_exit_flag = SKN_RUN_MODE_STOP; /* shut down the system -- work is done */
        // need to force theads down or interrupt them
        skn_logger(SD_WARNING, "shutdown caused by application!");
        sleep(1);
        if (*l_thread_complete != 0) {
            pthread_cancel(sig_thread);
            sleep(1);
        }
        skn_logger(SD_WARNING, "Collecting (cleanup) threads.");
        pthread_join(sig_thread, &trc);
    } else {
        rc = EXIT_FAILURE;
        skn_logger(SD_NOTICE, "Collecting signal thread's return code.");
        pthread_join(sig_thread, &trc);
        skn_logger(SD_NOTICE, "Signal thread was ended by a %d:%s signal.", gi_exit_flag, strsignal((int) (long int) trc));
    }
    pthread_sigmask(SIG_UNBLOCK, psignal_set, NULL);

    return rc;
}

Here is the caller graph for this function:

int skn_signal_manager_startup	(	pthread_t *	psig_thread,
		sigset_t *	psignal_set,
		long *	l_thread_complete
	)

Initialize signal manager

Definition at line 238 of file skn_signal_manager.c.

References PLATFORM_ERROR, SD_ERR, and skn_signal_manager_handler_thread().

Referenced by main().

                                                                                                       {
    int i_thread_rc = 0; // EXIT_SUCCESS

    sigfillset(psignal_set);
    pthread_sigmask(SIG_BLOCK, psignal_set, NULL);

    i_thread_rc = pthread_create(psig_thread, NULL, skn_signal_manager_handler_thread, (void*) l_thread_complete);
    if (i_thread_rc == PLATFORM_ERROR) {
        skn_logger(SD_ERR, "Create signal thread failed: %d:%s", errno, strerror(errno));
        pthread_sigmask(SIG_UNBLOCK, psignal_set, NULL);
        i_thread_rc = EXIT_FAILURE;
    }
    sleep(1); // give thread a chance to start

    return i_thread_rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

int gd_i_cols

Definition at line 12 of file skn_rpi_helpers.c.

Referenced by skn_display_manager_add_line(), skn_display_manager_create(), skn_handle_display_command_line(), skn_scroller_pad_right(), skn_scroller_scroll_lines(), and skn_scroller_wrap_blanks().

int gd_i_i2c_address

Definition at line 27 of file skn_network_helpers.c.

Referenced by main(), skn_device_manager_MCP23008(), skn_device_manager_MCP23017(), skn_device_manager_PCF8574(), skn_handle_display_command_line(), and skn_handle_locator_command_line().

int gd_i_rows

skn_rpi_helpers.c

Definition at line 11 of file skn_rpi_helpers.c.

Referenced by skn_display_manager_create(), and skn_handle_display_command_line().

char* gd_pch_device_name

Definition at line 14 of file skn_rpi_helpers.c.

Referenced by skn_device_manager_init_i2c(), skn_device_manager_LCD_shutdown(), skn_display_manager_do_work(), skn_handle_display_command_line(), and skn_scroller_scroll_lines().

char* gd_pch_serial_port

Definition at line 13 of file skn_rpi_helpers.c.

Referenced by skn_device_manager_SerialPort(), and skn_handle_display_command_line().

PDisplayManager gp_structure_pdm

Definition at line 15 of file skn_rpi_helpers.c.

Referenced by skn_get_display_manager_ref().