Return to get.c CVS log

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

Annotation of libaitpelco/src/get.c, revision 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_GetVersion() Return Pelco protocol version
        !            14:  * @p = Packet structure
        !            15:  * return: 'd' - PelcoD, 'p' - PelcoP, 0 - unknown or bad packet
        !            16:  */
        !            17: inline u_char pelco_GetVersion(void * __restrict p)
        !            18: {
        !            19:        u_char *ptr = (u_char *) p;
        !            20: 
        !            21:        if (!p) {
        !            22:                pelcoSetErr(EINVAL, "Error:: invalid argument!\n");
        !            23:                return 0;
        !            24:        }
        !            25: 
        !            26:        switch (*ptr) {
        !            27:                case VER_D_SYNC:
        !            28:                        return 'd';
        !            29:                case VER_P_STX:
        !            30:                        if (VER_P_ETX == ptr[6])
        !            31:                                return 'p';
        !            32:                        pelcoSetErr(ENOEXEC, "Error:: broken Pelco P packet ...\n");
        !            33:                        break;
        !            34:                default:
        !            35:                        pelcoSetErr(ENOEXEC, "Error:: unsupported Pelco protocol version!\n");
        !            36:        }
        !            37: 
        !            38:        return 0;
        !            39: }
        !            40: 
        !            41: /*
        !            42:  * pelco_GetCamNo() Get Camera number and check for valid packet
        !            43:  * @p = Packet structure
        !            44:  * return: 0xFF and pelco_GetErrno() == ENOEXEC - error, 
        !            45:        any number is camera address
        !            46:  */
        !            47: inline u_char pelco_GetCamNo(void * __restrict p)
        !            48: {
        !            49:        u_char ver;
        !            50:        u_char *ptr = (u_char *) p;
        !            51: 
        !            52:        if (!p) {
        !            53:                pelcoSetErr(EINVAL, "Error:: invalid argument!\n");
        !            54:                return 0;
        !            55:        }
        !            56: 
        !            57:        ver = pelco_GetVersion(p);
        !            58:        switch (ver) {
        !            59:                case 'd':
        !            60:                        if (crcPelco(ver, p) == ptr[6])
        !            61:                                return ptr[1];
        !            62: 
        !            63:                        pelcoSetErr(ENOEXEC, "Error:: broken Pelco D packet!!!\n");
        !            64:                        break;
        !            65:                case 'p':
        !            66:                        if (crcPelco(ver, p) == ptr[7])
        !            67:                                return ptr[1] + 1;
        !            68: 
        !            69:                        pelcoSetErr(ENOEXEC, "Error:: broken Pelco P packet!!!\n");
        !            70:                        break;
        !            71:        }
        !            72: 
        !            73:        return 0xFF;
        !            74: }
        !            75: 
        !            76: /*
        !            77:  * pelco_GetCamCmdData() Get from Camera commands and datas with verify packet
        !            78:  * @p = Input Packet structure
        !            79:  * @cam = Output camera number
        !            80:  * @cmd[2] = Output Commands 1 & 2
        !            81:  * @data[2] = Output Data for commands 1 & 2
        !            82:  * return: 'd' - PelcoD, 'p' - PelcoP, 0 - unknown or bad packet
        !            83:  */
        !            84: inline u_char pelco_GetCamCmdData(void * __restrict p, u_char * __restrict cam, 
        !            85:                u_char * __restrict cmd, u_char * __restrict data)
        !            86: {
        !            87:        u_char ret;
        !            88:        u_char *ptr = (u_char *) p;
        !            89: 
        !            90:        if (!p) {
        !            91:                pelcoSetErr(EINVAL, "Error:: invalid argument!\n");
        !            92:                return 0;
        !            93:        }
        !            94: 
        !            95:        ret = pelco_GetVersion(p);
        !            96:        switch (ret) {
        !            97:                case 'd':
        !            98:                        if (crcPelco(ret, p) != ptr[6]) {
        !            99:                                pelcoSetErr(ENOEXEC, "Error:: broken Pelco D packet!!!\n");
        !           100:                                return 0;
        !           101:                        }
        !           102: 
        !           103:                        if (cam)
        !           104:                                *cam = ptr[1];
        !           105:                        break;
        !           106:                case 'p':
        !           107:                        if (crcPelco(ret, p) != ptr[7]) {
        !           108:                                pelcoSetErr(ENOEXEC, "Error:: broken Pelco P packet!!!\n");
        !           109:                                return 0;
        !           110:                        }
        !           111: 
        !           112:                        if (cam)
        !           113:                                *cam = ptr[1] + 1;
        !           114:                        break;
        !           115:        }
        !           116: 
        !           117:        if (cmd)
        !           118:                memcpy(cmd, ptr + 2, 2);
        !           119:        if (data)
        !           120:                memcpy(data, ptr + 4, 2);
        !           121:        return ret;
        !           122: }
        !           123: 
        !           124: /*
        !           125:  * pelco_D_toCmd() Convert to Pelco D commands
        !           126:  * @cmd[2] = Input Commands 1 & 2
        !           127:  * @cmd1 = Output typecasted commands 1
        !           128:  * @cmd2 = Output typecasted commands 2
        !           129:  * return: 0xFF - error, !=0 return number arguments
        !           130:  */
        !           131: inline u_char pelco_D_toCmd(u_char * __restrict cmd, 
        !           132:                struct bitD_Cmd1 * __restrict cmd1, struct bitD_Cmd2 * __restrict cmd2)
        !           133: {
        !           134:        u_char ret = 0;
        !           135: 
        !           136:        if (!cmd) {
        !           137:                pelcoSetErr(EINVAL, "Error:: invalid argument!\n");
        !           138:                return 0xFF;
        !           139:        }
        !           140: 
        !           141:        if (cmd1) {
        !           142:                cmd1 = (struct bitD_Cmd1*) &cmd[0];
        !           143:                ret++;
        !           144:        }
        !           145:        if (cmd2) {
        !           146:                cmd2 = (struct bitD_Cmd2*) &cmd[1];
        !           147:                ret++;
        !           148:        }
        !           149: 
        !           150:        return ret;
        !           151: }
        !           152: 
        !           153: /*
        !           154:  * pelco_P_toCmd() Convert to Pelco P commands
        !           155:  * @cmd[2] = Input Commands 1 & 2
        !           156:  * @cmd1 = Output typecasted commands 1
        !           157:  * @cmd2 = Output typecasted commands 2
        !           158:  * return: 0xFF - error, !=0 return number arguments
        !           159:  */
        !           160: inline u_char pelco_P_toCmd(u_char * __restrict cmd, 
        !           161:                struct bitP_Cmd1 * __restrict cmd1, struct bitP_Cmd2 * __restrict cmd2)
        !           162: {
        !           163:        u_char ret = 0;
        !           164: 
        !           165:        if (!cmd) {
        !           166:                pelcoSetErr(EINVAL, "Error:: invalid argument!\n");
        !           167:                return 0xFF;
        !           168:        }
        !           169: 
        !           170:        if (cmd1) {
        !           171:                cmd1 = (struct bitP_Cmd1*) &cmd[0];
        !           172:                ret++;
        !           173:        }
        !           174:        if (cmd2) {
        !           175:                cmd2 = (struct bitP_Cmd2*) &cmd[1];
        !           176:                ret++;
        !           177:        }
        !           178: 
        !           179:        return ret;
        !           180: }