Return to set.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / libaitpelco / src

Annotation of libaitpelco/src/set.c, revision 1.1.1.1

1.1       misho       1: /*************************************************************************
                      2: * (C) 2010 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
                      3: *  by Michael Pounov <misho@openbsd-bg.org>
                      4: *
                      5: * $Author: misho $
                      6: * $Id: aitcrc.h,v 1.1.1.1.2.1 2008/11/05 17:29:19 misho Exp $
                      7: *
                      8: *************************************************************************/
                      9: #include "global.h"
                     10: 
                     11: 
                     12: /*
                     13:  * pelco_D_fromCmd() Convert from Pelco D commands
                     14:  * @cmd1 = Input typecasted commands 1
                     15:  * @cmd2 = Input typecasted commands 2
                     16:  * @cmd[2] = Output Commands 1 & 2
                     17:  * return: 0xFF - error, 0 - ok
                     18:  */
                     19: inline u_char pelco_D_fromCmd(struct bitD_Cmd1 cmd1, struct bitD_Cmd2 cmd2, 
                     20:                u_char * __restrict cmd)
                     21: {
                     22:        u_char ret = 0;
                     23: 
                     24:        if (!cmd) {
                     25:                pelcoSetErr(EINVAL, "Error:: invalid argument!\n");
                     26:                return 0xFF;
                     27:        }
                     28: 
                     29:        memcpy(&cmd[0], &cmd1, 1);
                     30:        memcpy(&cmd[1], &cmd2, 1);
                     31: 
                     32:        return ret;
                     33: }
                     34: 
                     35: /*
                     36:  * pelco_P_fromCmd() Convert from Pelco P commands
                     37:  * @cmd1 = Input typecasted commands 1
                     38:  * @cmd2 = Input typecasted commands 2
                     39:  * @cmd[2] = Output Commands 1 & 2
                     40:  * return: 0xFF - error, 0 - ok
                     41:  */
                     42: inline u_char pelco_P_fromCmd(struct bitP_Cmd1 cmd1, struct bitP_Cmd2 cmd2, 
                     43:                u_char * __restrict cmd)
                     44: {
                     45:        u_char ret = 0;
                     46: 
                     47:        if (!cmd) {
                     48:                pelcoSetErr(EINVAL, "Error:: invalid argument!\n");
                     49:                return 0xFF;
                     50:        }
                     51: 
                     52:        memcpy(&cmd[0], &cmd1, 1);
                     53:        memcpy(&cmd[1], &cmd2, 1);
                     54: 
                     55:        return ret;
                     56: }
                     57: 
                     58: /*
                     59:  * pelco_SetCamCmdData() Set Camera commands and datas
                     60:  * @ver = Input Pelco (d | p) version
                     61:  * @cam = Input camera number
                     62:  * @cmd[2] = Input Commands 1 & 2
                     63:  * @data[2] = Input Data for commands 1 & 2
                     64:  * @p = Output Packet structure
                     65:  * return: 0xFF - error, 0 - ok
                     66:  */
                     67: inline u_char pelco_SetCamCmdData(u_char ver, u_char __restrict cam, 
                     68:                u_char * __restrict cmd, u_char * __restrict data, void * __restrict p)
                     69: {
                     70:        u_char ret = 0;
                     71:        pelco_d_t *pd = (pelco_d_t*) p;
                     72:        pelco_p_t *pp = (pelco_p_t*) p;
                     73: 
                     74:        if (!p) {
                     75:                pelcoSetErr(EINVAL, "Error:: invalid argument!\n");
                     76:                return 0xFF;
                     77:        }
                     78: 
                     79:        switch (ver) {
                     80:                case 'D':
                     81:                case 'd':
                     82:                        memset(pd, 0, sizeof(pelco_d_t));
                     83:                        pd->d_sync = VER_D_SYNC;
                     84:                        pd->d_cam = cam;
                     85:                        if (cmd)
                     86:                                memcpy(&pd->d_cmd1, cmd, 2);
                     87:                        if (data)
                     88:                                memcpy(&pd->d_data, data, 2);
                     89:                        pd->d_crc = crcPelco(ver, p);
                     90:                        break;
                     91:                case 'P':
                     92:                case 'p':
                     93:                        memset(pp, 0, sizeof(pelco_p_t));
                     94:                        pp->p_stx = VER_P_STX;
                     95:                        pp->p_cam = !cam ? cam : cam - 1;
                     96:                        if (cmd)
                     97:                                memcpy(&pp->p_cmd1, cmd, 2);
                     98:                        if (data)
                     99:                                memcpy(&pp->p_data, data, 2);
                    100:                        pp->p_etx = VER_P_ETX;
                    101:                        pp->p_crc = crcPelco(ver, p);
                    102:                        break;
                    103:                default:
                    104:                        pelcoSetErr(ENOEXEC, "Error:: Invalid protocol!\n");
                    105:                        return 0xFF;
                    106:        }
                    107: 
                    108:        return ret;
                    109: }