Commit 2eb71ce1 authored by captainwong's avatar captainwong

building

parent 65bd44e9
# Ademco Change Log
## 2.7.0 2024-6-4 15:24:15
- shrink `ademco_packet_t` size
- add config option for `time`
- add config option `ADEMCO_USE_STATIC_BUF, ADEMCO_USE_UNIQUE_BUF` for embedded systems
- add `ademco_append_data3` and `ademco_make_hb_packet3` for inplace make
- add `ademco_is_valid_password`
- remove `grinwich` related functions, they are shit due to doc lacking, machine's timer is UTC+0
- event 1384 changed to `EVENT_POWER_EXCEPTION`, 3384 changed to `EVENT_POWER_EXCEPTION_RECOVER`
## 2.6.0 2024-4-20 00:58:15
## 2.5.1 2024-4-19 23:39:51
- `ARM_STAY` related functions
......@@ -81,7 +96,7 @@
- add `hb_com_zone_lost_data_iter_t`, `hb_com_zone_lost_data_iter_init` and `hb_com_zone_lost_data_iter_next`
- add `ADEMCO_PACKET_PWD_MIN_LEN`, `ADEMCO_PACKET_PWD_MAX_LEN`
- code styles changed
- when parse returns `ADEMCO_PARSE_RESULT_ERROR`, `*ate` will contains length to ignore, caller must drop `*ate` bytes of data
- when parse returns `ADEMCO_PARSE_RESULT_ERROR`, `*ate` will contains length to ignore, caller must drop `*ate` bytes of dat
## 1.5.1
......
......@@ -12,6 +12,25 @@
#include <stdlib.h>
#include <string.h>
#if ADEMCO_USE_UNIQUE_BUF
static char buf[ADEMCO_PACKET_MAX_LEN];
#endif
#ifdef __C51__
#include <stdarg.h>
#ifndef UNUSED
#define UNUSED(x) ((x) = (x))
#endif
int snprintf(char* str, size_t size, const char* format, ...) {
va_list args;
UNUSED(size);
va_start(args, format);
vsprintf(str, format, args);
va_end(args);
return strlen(str);
}
#endif
#define ADEMCO_STRINGIFY(v) ADEMCO_STRINGIFY_HELPER(v)
#define ADEMCO_STRINGIFY_HELPER(v) #v
......@@ -27,9 +46,11 @@ uint32_t ademco_version(void) {
return ADEMCO_VERSION_HEX;
}
#if ADEMCO_ENABLE_TO_STRING
const char* ademco_version_string(void) {
return ADEMCO_VERSION_STRING;
}
#endif
static uint8_t hex2char(uint8_t h) {
h &= 0x0F;
......@@ -64,11 +85,11 @@ void ademco_print(const ademco_char_t* p, size_t len) {
uint8_t ademco_encode_signal_strength(uint8_t strength) {
if (strength > ADEMCO_SIGNAL_STRENGTH_MAX)
strength = ADEMCO_SIGNAL_STRENGTH_MAX;
return ((strength / 10) << 4) | (strength % 10);
return bcd_encode(strength);
}
uint8_t ademco_decode_signal_strength(uint8_t code) {
uint8_t strength = ((code >> 4) & 0x0F) * 10 + (code & 0x0F);
uint8_t ademco_decode_signal_strength(uint8_t bcd_strength) {
uint8_t strength = bcd_decode(bcd_strength);
if (strength > ADEMCO_SIGNAL_STRENGTH_MAX)
strength = ADEMCO_SIGNAL_STRENGTH_MAX;
return strength;
......@@ -92,6 +113,19 @@ int ademco_is_valid_account(const char* acct) {
(ishex ? len == ADEMCO_PACKET_ACCT_MAC_LEN : (len >= ADEMCO_PACKET_ACCT_MIN_LEN));
}
int ademco_is_valid_password(const char* pwd) {
size_t len = 0;
while (*pwd && len < ADEMCO_PACKET_PWD_MAX_LEN) {
if (isdigit(*pwd)) {
len++;
} else {
return 0;
}
pwd++;
}
return *pwd == '\0' && len >= ADEMCO_PACKET_PWD_MIN_LEN;
}
int ademco_is_machine_status_event(ademco_event_t ademco_event) {
return ademco_event == EVENT_ARM_AWAY ||
ademco_event == EVENT_ARM_STAY ||
......@@ -138,8 +172,8 @@ ademco_event_t ademco_get_exception_event_by_recover_event(ademco_event_t recove
return EVENT_SUB_MACHINE_POWER_EXCEPTION;
case EVENT_LOW_BATTERY_RECOVER:
return EVENT_LOW_BATTERY;
case EVENT_BATTERY_EXCEPTION_RECOVER:
return EVENT_BATTERY_EXCEPTION;
case EVENT_POWER_EXCEPTION_RECOVER:
return EVENT_POWER_EXCEPTION;
case EVENT_OTHER_EXCEPTION_RECOVER:
return EVENT_OTHER_EXCEPTION;
case EVENT_AC_RECOVER:
......@@ -169,7 +203,7 @@ ademco_event_level_t ademco_get_event_level(ademco_event_t ademco_event) {
case EVENT_SUB_MACHINE_SENSOR_RECOVER:
case EVENT_SUB_MACHINE_POWER_RECOVER:
case EVENT_LOW_BATTERY_RECOVER:
case EVENT_BATTERY_EXCEPTION_RECOVER:
case EVENT_POWER_EXCEPTION_RECOVER:
case EVENT_OTHER_EXCEPTION_RECOVER:
case EVENT_SOLAR_DISTURB_RECOVER:
return EVENT_LEVEL_EXCEPTION_RECOVER;
......@@ -182,7 +216,7 @@ ademco_event_level_t ademco_get_event_level(ademco_event_t ademco_event) {
case EVENT_LOST:
case EVENT_SUB_MACHINE_SENSOR_EXCEPTION:
case EVENT_SUB_MACHINE_POWER_EXCEPTION:
case EVENT_BATTERY_EXCEPTION:
case EVENT_POWER_EXCEPTION:
case EVENT_OTHER_EXCEPTION:
return EVENT_LEVEL_EXCEPTION;
......@@ -202,6 +236,7 @@ ademco_event_level_t ademco_get_event_level(ademco_event_t ademco_event) {
}
}
#if ADEMCO_ENABLE_TO_STRING
const char* ademco_event_to_string(ademco_event_t ademco_event) {
switch (ademco_event) {
#define XX(name, code, zh) \
......@@ -222,6 +257,7 @@ const char* ademco_event_to_string(ademco_event_t ademco_event) {
return "Undefined ademco_event_t";
}
}
#endif
#if ADEMCO_ENABLE_CHINESE
const char* ademco_event_to_string_chinese(ademco_event_t ademco_event) {
......@@ -282,16 +318,16 @@ static const uint16_t crc16Table[256] = {
0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040, // 0xF8
};
uint16_t ademco_crc16(const ademco_char_t* buff, size_t len) {
uint16_t ademco_crc16(const ademco_char_t* buf, size_t len) {
uint16_t crc = 0;
while (len--)
crc = (crc >> 8) ^ crc16Table[(crc ^ *buff++) & 0xFF];
crc = (crc >> 8) ^ crc16Table[(crc ^ *buf++) & 0xFF];
return crc;
}
size_t ademco_append_data(ademco_char_t* buff, const char* acct, ademco_id_t ademco_id,
size_t ademco_append_data(ademco_char_t* buf, const char* acct, ademco_id_t ademco_id,
ademco_event_t ademco_event, ademco_gg_t gg, ademco_zone_t zone) {
char* p = (char*)buff;
char* p = (char*)buf;
if (ademco_event == EVENT_INVALID_EVENT) {
*p++ = '[';
*p++ = ']';
......@@ -332,11 +368,11 @@ size_t ademco_append_data(ademco_char_t* buff, const char* acct, ademco_id_t ade
*p++ = ']';
// assert(p - (char*)buff == ADEMCO_PACKET_DATA_SEGMENT_FULL_LEN);
// assert(p - (char*)buf == ADEMCO_PACKET_DATA_SEGMENT_FULL_LEN);
*p = '\0'; // for debug convenience
return p - (char*)buff;
return p - (char*)buf;
}
}
......@@ -352,6 +388,56 @@ size_t ademco_append_data2(ademco_data_t* ademco_data, const char* acct,
ademco_event, gg, zone);
}
size_t ademco_append_data3(ademco_data_t* ademco_data, const char* acct) {
char* p = (char*)ademco_data->raw;
if (ademco_data->ademco_event == EVENT_INVALID_EVENT) {
*p++ = '[';
*p++ = ']';
return ademco_data->raw_len = ADEMCO_PACKET_DATA_SEGMENT_EMPTY_LEN;
} else {
*p++ = '[';
*p++ = '#';
if (acct && ademco_data->ademco_id == 0) {
p += snprintf(p, 20, "%s", acct);
} else {
snprintf(p, 6 + 1, "%06X", ademco_data->ademco_id % ADEMCO_ID_SENTINEL);
p += 6;
}
*p++ = '|';
snprintf(p, 4 + 1, "%04d", ademco_data->ademco_event % ADEMCO_EVENT_SENTINEL);
p += 4;
*p++ = ' ';
if (ademco_data->gg == 0xEE) {
*p++ = 'E';
*p++ = 'E';
} else if (ademco_data->gg == 0xCC) {
*p++ = 'C';
*p++ = 'C';
} else {
*p++ = ((ademco_data->gg / 10) & 0x0F) + '0';
*p++ = ((ademco_data->gg % 10) & 0x0F) + '0';
}
*p++ = ' ';
snprintf(p, 3 + 1, "%03d", ademco_data->zone % ADEMCO_ZONE_SENTINEL);
p += 3;
*p++ = ']';
// assert(p - (char*)buf == ADEMCO_PACKET_DATA_SEGMENT_FULL_LEN);
*p = '\0'; // for debug convenience
return ademco_data->raw_len = p - (char*)ademco_data->raw;
}
}
ademco_parse_result_t ademco_parse_data(const ademco_char_t* packet, size_t packet_len,
ademco_data_t* ademco_data,
ademco_parse_error_t* err) {
......@@ -366,6 +452,13 @@ ademco_parse_result_t ademco_parse_data(const ademco_char_t* packet, size_t pack
packet[packet_len - 1] == ']') { // [#000000|1400 00 000]
const char* p = packet + 2;
size_t acct_len = packet_len - 15;
#if !ADEMCO_USE_UNIQUE_BUF
#if ADEMCO_USE_STATIC_BUF
static
#endif
char buf[ADEMCO_PACKET_DATA_SEGMENT_FULL_LEN_MAX] = {0};
#endif
if (acct_len < 6) {
ADEMCO_FILL_PARSE_ERROR(err, p - packet, "acct_len < 6");
return ADEMCO_PARSE_RESULT_ERROR;
......@@ -374,19 +467,18 @@ ademco_parse_result_t ademco_parse_data(const ademco_char_t* packet, size_t pack
return ADEMCO_PARSE_RESULT_ERROR;
}
char temp[ADEMCO_PACKET_DATA_SEGMENT_FULL_LEN_MAX] = {0};
strncpy(temp, (const char*)p, acct_len);
temp[acct_len] = '\0';
ademco_data->ademco_id = (ademco_id_t)strtoul(temp, NULL, 16);
strncpy(buf, (const char*)p, acct_len);
buf[acct_len] = '\0';
ademco_data->ademco_id = (ademco_id_t)strtoul(buf, NULL, 16);
p += acct_len;
if (*p++ != '|') {
ADEMCO_FILL_PARSE_ERROR(err, p - packet, "*p++ != '|'");
return ADEMCO_PARSE_RESULT_ERROR;
}
strncpy(temp, (const char*)p, 4);
temp[4] = '\0';
ademco_data->ademco_event = (ademco_event_t)(atoi(temp));
strncpy(buf, (const char*)p, 4);
buf[4] = '\0';
ademco_data->ademco_event = (ademco_event_t)(atoi(buf));
p += 4;
if (*p++ != ' ') {
......@@ -406,9 +498,9 @@ ademco_parse_result_t ademco_parse_data(const ademco_char_t* packet, size_t pack
ADEMCO_FILL_PARSE_ERROR(err, p - packet, "*p++ != ' '");
return ADEMCO_PARSE_RESULT_ERROR;
}
strncpy(temp, (const char*)p, 3);
temp[3] = '\0';
ademco_data->zone = (ademco_zone_t)atoi(temp);
strncpy(buf, (const char*)p, 3);
buf[3] = '\0';
ademco_data->zone = (ademco_zone_t)atoi(buf);
if (ademco_data->raw != packet) {
memcpy(ademco_data->raw, packet, packet_len);
......@@ -429,9 +521,10 @@ size_t ademco_data_to_congwin_fe100(ademco_char_t* fe100, size_t fe100_len,
fe100[1] = '\r';
return 2;
} else if (ademco_data->raw_len >= ADEMCO_PACKET_DATA_SEGMENT_FULL_LEN) {
char* p;
if (fe100_len < CONGWIN_FE100_PACKET_LEN) return 0;
char* p = fe100;
p = fe100;
*p++ = '\n';
*p++ = ' ';
......@@ -496,39 +589,45 @@ size_t ademco_data_to_congwin_fe100(ademco_char_t* fe100, size_t fe100_len,
return 0;
}
void ademco_xdata_init(ademco_xdata_t* xdata) {
memset(xdata, 0, sizeof *xdata);
void ademco_xdata_init(ademco_xdata_t* xdat) {
memset(xdat, 0, sizeof *xdat);
}
int ademco_xdata_convert(ademco_xdata_t* xdata,
int ademco_xdata_convert(ademco_xdata_t* xdat,
ademco_xdata_length_format_t xlf) {
if (!xdata) {
#if !ADEMCO_USE_UNIQUE_BUF
#if ADEMCO_USE_STATIC_BUF
static
#endif
char buf[ADEMCO_PACKET_XDATA_MAX_LEN];
#endif
size_t len;
if (!xdat) {
return ADEMCO_ERR;
}
if (xdata->lenghFormat == xlf) {
if (xdat->lenghFormat == xlf) {
return ADEMCO_OK;
}
size_t len = ademco_xdata_get_valid_content_len(xdata);
char raw[ADEMCO_PACKET_XDATA_MAX_LEN];
len = ademco_xdata_get_valid_content_len(xdat);
if (xlf == ADEMCO_XDATA_LENGTH_FMT_TWO_HEX) {
if (len + 6 > ADEMCO_PACKET_XDATA_MAX_LEN)
return ADEMCO_ERR;
xdata->raw[5 + ademco_xdata_get_valid_content_len(xdata)] = '\0';
len = ademco_hex_str_to_array((uint8_t*)raw,
ademco_xdata_get_valid_content_addr(xdata),
xdat->raw[5 + ademco_xdata_get_valid_content_len(xdat)] = '\0';
len = ademco_hex_str_to_array((uint8_t*)buf,
ademco_xdata_get_valid_content_addr(xdat),
0x0F);
ademco_make_xdata(xdata,
ademco_make_xdata(xdat,
ADEMCO_XDATA_LENGTH_FMT_TWO_HEX,
ADEMCO_XDATA_TRANSFORM_AS_IS,
raw, len);
buf, len);
} else {
memcpy(raw, ademco_xdata_get_valid_content_addr(xdata), len);
ademco_make_xdata(xdata,
memcpy(buf, ademco_xdata_get_valid_content_addr(xdat), len);
ademco_make_xdata(xdat,
ADEMCO_XDATA_LENGTH_FMT_FOUR_DECIMAL,
ADEMCO_XDATA_TRANSFORM_TO_ASCII,
raw, len);
buf, len);
}
return ADEMCO_OK;
}
......@@ -536,32 +635,34 @@ int ademco_xdata_convert(ademco_xdata_t* xdata,
#ifdef SWIG
static
#endif
const char* ademco_xdata_get_valid_content_addr(const ademco_xdata_t* xdata) {
if (xdata->lenghFormat == ADEMCO_XDATA_LENGTH_FMT_TWO_HEX &&
xdata->raw_len > 4)
return xdata->raw + 3;
else if (xdata->lenghFormat == ADEMCO_XDATA_LENGTH_FMT_FOUR_DECIMAL &&
xdata->raw_len > 6)
return xdata->raw + 5;
const char* ademco_xdata_get_valid_content_addr(const ademco_xdata_t* xdat) {
if (xdat->lenghFormat == ADEMCO_XDATA_LENGTH_FMT_TWO_HEX &&
xdat->raw_len > 4)
return xdat->raw + 3;
else if (xdat->lenghFormat == ADEMCO_XDATA_LENGTH_FMT_FOUR_DECIMAL &&
xdat->raw_len > 6)
return xdat->raw + 5;
else
return NULL;
}
int ademco_xdata_memcmp(const ademco_xdata_t* xdata,
int ademco_xdata_memcmp(const ademco_xdata_t* xdat,
const void* buf, size_t buf_len) {
if (ademco_xdata_get_valid_content_len(xdata) != buf_len) return 0;
const void* p = ademco_xdata_get_valid_content_addr(xdata);
const void* p;
if (ademco_xdata_get_valid_content_len(xdat) != buf_len) return 0;
p = ademco_xdata_get_valid_content_addr(xdat);
if (!p) return 0;
return memcmp(p, buf, buf_len);
}
size_t ademco_xdata_get_valid_content_len(const ademco_xdata_t* xdata) {
if (xdata->lenghFormat == ADEMCO_XDATA_LENGTH_FMT_TWO_HEX &&
xdata->raw_len > 4)
return xdata->raw_len - 4;
else if (xdata->lenghFormat == ADEMCO_XDATA_LENGTH_FMT_FOUR_DECIMAL &&
xdata->raw_len > 6)
return xdata->raw_len - 6;
size_t ademco_xdata_get_valid_content_len(const ademco_xdata_t* xdat) {
if (!xdat) return 0;
if (xdat->lenghFormat == ADEMCO_XDATA_LENGTH_FMT_TWO_HEX &&
xdat->raw_len > 4)
return xdat->raw_len - 4;
else if (xdat->lenghFormat == ADEMCO_XDATA_LENGTH_FMT_FOUR_DECIMAL &&
xdat->raw_len > 6)
return xdat->raw_len - 6;
else
return 0;
}
......@@ -574,48 +675,53 @@ size_t ademco_xdata_copy(ademco_xdata_t* dst, const ademco_xdata_t* src) {
return 0;
}
int ademco_make_xdata(ademco_xdata_t* xdata,
int ademco_make_xdata(ademco_xdata_t* xdat,
ademco_xdata_length_format_t xlf,
ademco_xdata_transform_t xtr,
const ademco_char_t* content, size_t len) {
char transformed[ADEMCO_PACKET_XDATA_MAX_LEN];
#if !ADEMCO_USE_UNIQUE_BUF
#if ADEMCO_USE_STATIC_BUF
static
#endif
char buf[ADEMCO_PACKET_XDATA_MAX_LEN];
#endif
size_t translen;
len &= 0xFFFF;
translen = len & 0xFFFF;
if (xtr == ADEMCO_XDATA_TRANSFORM_AS_IS)
memcpy(transformed, content, len);
memcpy(buf, content, len);
else if (len * 2 < ADEMCO_PACKET_XDATA_MAX_LEN)
translen = ademco_hex_array_to_str(transformed,
translen = ademco_hex_array_to_str(buf,
(const uint8_t*)content, len) &
0xFFFF;
else
return ADEMCO_ERR;
xdata->lenghFormat = xlf;
xdat->lenghFormat = xlf;
if (xlf == ADEMCO_XDATA_LENGTH_FMT_TWO_HEX &&
translen + 4 < ADEMCO_PACKET_XDATA_MAX_LEN) {
ademco_char_t* p = xdata->raw;
ademco_char_t* p = xdat->raw;
*p++ = '[';
*p++ = (translen & 0xFFFF) >> 8;
*p++ = (translen & 0xFFFF) & 0xFF;
memcpy(p, transformed, translen);
memcpy(p, buf, translen);
p += translen;
*p++ = ']';
xdata->raw_len = p - xdata->raw;
xdat->raw_len = p - xdat->raw;
return ADEMCO_OK;
} else if (xlf == ADEMCO_XDATA_LENGTH_FMT_FOUR_DECIMAL &&
translen + 6 < ADEMCO_PACKET_XDATA_MAX_LEN) {
ademco_char_t* p = xdata->raw;
*p++ = '[';
ademco_char_t* p = xdat->raw;
char temp[5];
*p++ = '[';
snprintf(temp, sizeof(temp), "%04zX", translen & 0xFFFF);
memcpy(p, temp, 4);
p += 4;
memcpy(p, transformed, translen);
memcpy(p, buf, translen);
p += translen;
*p++ = ']';
xdata->raw_len = p - xdata->raw;
xdat->raw_len = p - xdat->raw;
return ADEMCO_OK;
} else
return ADEMCO_ERR;
......@@ -639,7 +745,8 @@ static const char* const ids[AID_COUNT] = {
};
ademco_packet_id_t ademco_packet_id_from_string(const char* id, size_t len) {
for (int i = 0; i < AID_COUNT; i++)
uint8_t i;
for (i = 0; i < AID_COUNT; i++)
if (ademco_is_valid_packet_id(ids[i], id, len))
return (ademco_packet_id_t)(i);
return AID_INVALID;
......@@ -652,34 +759,64 @@ const char* ademco_packet_id_to_string(ademco_packet_id_t id) {
return "Unkown ademco_packet_id_t";
}
static void getNowTimestamp(char* buff) {
static void getNowTimestamp(char* buf) {
#ifdef ADEMCO_USE_CUSTOM_TIME_T
time_t now = ademco_get_time_t(NULL);
#else
time_t now = time(NULL);
#endif
#ifdef __ARMCC_VERSION
struct tm tm = {0};
_localtime_r(&now, &tm);
snprintf(buf, ADEMCO_PACKET_TIMESTAMP_LEN + 1,
"_%02d:%02d:%02d,%02d-%02d-%04d",
tm.tm_hour, tm.tm_min, tm.tm_sec,
tm.tm_mon + 1, tm.tm_mday, tm.tm_year + 1900);
#else
struct tm* tm = localtime(&now);
snprintf(buff, ADEMCO_PACKET_TIMESTAMP_LEN + 1,
snprintf(buf, ADEMCO_PACKET_TIMESTAMP_LEN + 1,
"_%02d:%02d:%02d,%02d-%02d-%04d",
tm->tm_hour, tm->tm_min, tm->tm_sec,
tm->tm_mon + 1, tm->tm_mday, tm->tm_year + 1900);
#endif
}
static void getGmtTimestamp(char* buff) {
static void getGmtTimestamp(char* buf) {
#ifdef ADEMCO_DISABLE_GMTIME
getNowTimestamp(buf);
#else
#ifdef ADEMCO_USE_CUSTOM_TIME_T
time_t now = ademco_get_time_t(NULL);
#else
time_t now = time(NULL);
#endif
struct tm* tm = gmtime(&now);
snprintf(buff, ADEMCO_PACKET_TIMESTAMP_LEN + 1,
snprintf(buf, ADEMCO_PACKET_TIMESTAMP_LEN + 1,
"_%02d:%02d:%02d,%02d-%02d-%04d",
tm->tm_hour, tm->tm_min, tm->tm_sec,
tm->tm_mon + 1, tm->tm_mday, tm->tm_year + 1900);
#endif
}
size_t ademco_make_empty_data_packet(ademco_char_t* dst_buff, size_t len,
const char* id, uint16_t seq,
const char* acct, ademco_id_t ademco_id) {
char buff[ADEMCO_PACKET_MAX_LEN];
char* p = buff;
char* pcrc = buff + 1;
char* plen = buff + 5;
char* pid = buff + 9;
#if !ADEMCO_USE_UNIQUE_BUF
#if ADEMCO_USE_STATIC_BUF
static
#endif
char buf[ADEMCO_PACKET_MAX_LEN];
#endif
char* p = buf;
char* pcrc = buf + 1;
char* plen = buf + 5;
char* pid = buf + 9;
char temp[5];
uint16_t crc;
size_t packet_len, ademco_len;
buff[0] = ADEMCO_PACKET_PREFIX;
buf[0] = ADEMCO_PACKET_PREFIX;
memcpy(pid, id, strlen(id));
p = pid + strlen(id);
snprintf((char*)p, 5, "%04d", seq);
......@@ -702,18 +839,17 @@ size_t ademco_make_empty_data_packet(ademco_char_t* dst_buff, size_t len,
p += ADEMCO_PACKET_TIMESTAMP_LEN;
*p++ = ADEMCO_PACKET_SUFIX;
char temp[5];
size_t packet_len = p - buff;
// \n crc len \r
size_t ademco_len = packet_len - 1 - 4 - 4 - 1;
packet_len = p - buf;
// \n crc len \r
ademco_len = packet_len - 1 - 4 - 4 - 1;
snprintf(temp, 5, "%04zX", ademco_len);
memcpy(plen, temp, 4);
uint16_t crc = ademco_crc16(pid, ademco_len);
crc = ademco_crc16(pid, ademco_len);
snprintf(temp, 5, "%04X", crc);
memcpy(pcrc, temp, 4);
if (dst_buff != NULL && len > packet_len) {
memcpy(dst_buff, buff, packet_len);
memcpy(dst_buff, buf, packet_len);
dst_buff[packet_len] = '\0'; // for debug convenience
return packet_len;
} else
......@@ -723,13 +859,21 @@ size_t ademco_make_empty_data_packet(ademco_char_t* dst_buff, size_t len,
size_t ademco_make_adm_empty_data_packet(ademco_char_t* dst_buff, size_t len,
const char* id, uint16_t seq,
const char* acct, ademco_id_t ademco_id) {
char buff[ADEMCO_PACKET_MAX_LEN];
char* p = buff;
char* pcrc = buff + 1;
char* plen = buff + 5;
char* pid = buff + 9;
#if !ADEMCO_USE_UNIQUE_BUF
#if ADEMCO_USE_STATIC_BUF
static
#endif
char buf[ADEMCO_PACKET_MAX_LEN];
#endif
char* p = buf;
char* pcrc = buf + 1;
char* plen = buf + 5;
char* pid = buf + 9;
char temp[5];
uint16_t crc;
size_t packet_len, ademco_len;
buff[0] = ADEMCO_PACKET_PREFIX;
buf[0] = ADEMCO_PACKET_PREFIX;
memcpy(pid, id, strlen(id));
p = pid + strlen(id);
snprintf((char*)p, 5, "%04d", seq);
......@@ -752,44 +896,43 @@ size_t ademco_make_adm_empty_data_packet(ademco_char_t* dst_buff, size_t len,
p += ADEMCO_PACKET_TIMESTAMP_LEN;
*p++ = ADEMCO_PACKET_SUFIX;
char temp[5];
size_t packet_len = p - buff;
// \n crc len \r
size_t ademco_len = packet_len - 1 - 4 - 4 - 1;
packet_len = p - buf;
// \n crc len \r
ademco_len = packet_len - 1 - 4 - 4 - 1;
snprintf(temp, 5, "%04zX", ademco_len);
memcpy(plen, temp, 4);
uint16_t crc = ademco_crc16(pid, ademco_len);
crc = ademco_crc16(pid, ademco_len);
snprintf(temp, 5, "%04X", crc);
memcpy(pcrc, temp, 4);
if (dst_buff != NULL && len > packet_len) {
memcpy(dst_buff, buff, packet_len);
memcpy(dst_buff, buf, packet_len);
dst_buff[packet_len] = '\0'; // for debug convenience
return packet_len;
} else
return 0;
}
size_t ademco_make_null_packet(ademco_char_t* buff, size_t len,
size_t ademco_make_null_packet(ademco_char_t* buf, size_t len,
uint16_t seq, const char* acct,
ademco_id_t ademco_id) {
return ademco_make_empty_data_packet(buff, len,
return ademco_make_empty_data_packet(buf, len,
ADEMCO_PACKET_ID_NULL,
seq, acct, ademco_id);
}
size_t ademco_make_ack_packet(ademco_char_t* buff, size_t len,
size_t ademco_make_ack_packet(ademco_char_t* buf, size_t len,
uint16_t seq, const char* acct,
ademco_id_t ademco_id) {
return ademco_make_empty_data_packet(buff, len,
return ademco_make_empty_data_packet(buf, len,
ADEMCO_PACKET_ID_ACK,
seq, acct, ademco_id);
}
size_t ademco_make_nak_packet(ademco_char_t* buff, size_t len,
size_t ademco_make_nak_packet(ademco_char_t* buf, size_t len,
uint16_t seq, const char* acct,
ademco_id_t ademco_id) {
return ademco_make_empty_data_packet(buff, len,
return ademco_make_empty_data_packet(buf, len,
ADEMCO_PACKET_ID_NAK,
seq, acct, ademco_id);
}
......@@ -798,14 +941,22 @@ size_t ademco_make_hb_packet(ademco_char_t* dst_buff, size_t len,
uint16_t seq, const char* acct,
ademco_id_t ademco_id, ademco_event_t ademco_event,
ademco_gg_t gg, ademco_zone_t zone,
const ademco_xdata_t* xdata) {
char buff[ADEMCO_PACKET_MAX_LEN];
char* p = buff;
char* pcrc = buff + 1;
char* plen = buff + 5;
char* pid = buff + 9;
buff[0] = ADEMCO_PACKET_PREFIX;
const ademco_xdata_t* xdat) {
#if !ADEMCO_USE_UNIQUE_BUF
#if ADEMCO_USE_STATIC_BUF
static
#endif
char buf[ADEMCO_PACKET_MAX_LEN];
#endif
char* p = buf;
char* pcrc = buf + 1;
char* plen = buf + 5;
char* pid = buf + 9;
char temp[5];
uint16_t crc;
size_t packet_len, ademco_len;
buf[0] = ADEMCO_PACKET_PREFIX;
memcpy(pid, ADEMCO_PACKET_ID_HB, strlen(ADEMCO_PACKET_ID_HB));
p = pid + strlen(ADEMCO_PACKET_ID_HB);
snprintf((char*)p, 5, "%04d", seq);
......@@ -823,26 +974,25 @@ size_t ademco_make_hb_packet(ademco_char_t* dst_buff, size_t len,
p += 6;
}
p += ademco_append_data(p, acct, ademco_id, ademco_event, gg, zone);
if (xdata && xdata->raw_len > 0) {
memcpy(p, xdata->raw, xdata->raw_len);
p += xdata->raw_len;
if (xdat && xdat->raw_len > 0) {
memcpy(p, xdat->raw, xdat->raw_len);
p += xdat->raw_len;
}
getNowTimestamp(p);
p += ADEMCO_PACKET_TIMESTAMP_LEN;
*p++ = ADEMCO_PACKET_SUFIX;
char temp[5];
size_t packet_len = p - buff;
// \n crc len \r
size_t ademco_len = packet_len - 1 - 4 - 4 - 1;
packet_len = p - buf;
// \n crc len \r
ademco_len = packet_len - 1 - 4 - 4 - 1;
snprintf(temp, 5, "%04zX", ademco_len);
memcpy(plen, temp, 4);
uint16_t crc = ademco_crc16(pid, ademco_len);
crc = ademco_crc16(pid, ademco_len);
snprintf(temp, 5, "%04X", crc);
memcpy(pcrc, temp, 4);
if (dst_buff != NULL && len > packet_len) {
memcpy(dst_buff, buff, packet_len);
memcpy(dst_buff, buf, packet_len);
dst_buff[packet_len] = '\0'; // for debug convenience
return packet_len;
}
......@@ -854,14 +1004,22 @@ size_t ademco_make_adm_packet(ademco_char_t* dst_buff, size_t len,
ademco_id_t ademco_id,
ademco_event_t ademco_event,
ademco_gg_t gg, ademco_zone_t zone,
const ademco_xdata_t* xdata) {
char buff[ADEMCO_PACKET_MAX_LEN];
char* p = buff;
char* pcrc = buff + 1;
char* plen = buff + 5;
char* pid = buff + 9;
buff[0] = ADEMCO_PACKET_PREFIX;
const ademco_xdata_t* xdat) {
#if !ADEMCO_USE_UNIQUE_BUF
#if ADEMCO_USE_STATIC_BUF
static
#endif
char buf[ADEMCO_PACKET_MAX_LEN];
#endif
char* p = buf;
char* pcrc = buf + 1;
char* plen = buf + 5;
char* pid = buf + 9;
char temp[5];
uint16_t crc;
size_t packet_len, ademco_len;
buf[0] = ADEMCO_PACKET_PREFIX;
memcpy(pid, ADEMCO_PACKET_ID_ADM_CID, strlen(ADEMCO_PACKET_ID_ADM_CID));
p = pid + strlen(ADEMCO_PACKET_ID_ADM_CID);
snprintf((char*)p, 5, "%04d", seq);
......@@ -879,26 +1037,25 @@ size_t ademco_make_adm_packet(ademco_char_t* dst_buff, size_t len,
p += 6;
}
p += ademco_append_data(p, acct, ademco_id, ademco_event, gg, zone);
if (xdata && xdata->raw_len > 0) {
memcpy(p, xdata->raw, xdata->raw_len);
p += xdata->raw_len;
if (xdat && xdat->raw_len > 0) {
memcpy(p, xdat->raw, xdat->raw_len);
p += xdat->raw_len;
}
getGmtTimestamp(p);
p += ADEMCO_PACKET_TIMESTAMP_LEN;
*p++ = ADEMCO_PACKET_SUFIX;
char temp[5];
size_t packet_len = p - buff;
// \n crc len \r
size_t ademco_len = packet_len - 1 - 4 - 4 - 1;
packet_len = p - buf;
// \n crc len \r
ademco_len = packet_len - 1 - 4 - 4 - 1;
snprintf(temp, 5, "%04zX", ademco_len);
memcpy(plen, temp, 4);
uint16_t crc = ademco_crc16(pid, ademco_len);
crc = ademco_crc16(pid, ademco_len);
snprintf(temp, 5, "%04X", crc);
memcpy(pcrc, temp, 4);
if (dst_buff != NULL && len > packet_len) {
memcpy(dst_buff, buff, packet_len);
memcpy(dst_buff, buf, packet_len);
dst_buff[packet_len] = '\0'; // for debug convenience
return packet_len;
}
......@@ -920,7 +1077,7 @@ size_t ademco_make_null_packet2(ademco_packet_t* pkt, uint16_t seq,
const char* acct, ademco_id_t ademco_id) {
pkt->seq = seq;
copyAcct2AdemcoPacket(pkt, acct);
pkt->data.ademco_id = ademco_id;
pkt->dat.ademco_id = ademco_id;
pkt->id = AID_NULL;
return pkt->raw_len = ademco_make_null_packet(pkt->raw, sizeof(pkt->raw),
seq, acct, ademco_id);
......@@ -930,7 +1087,7 @@ size_t ademco_make_ack_packet2(ademco_packet_t* pkt, uint16_t seq,
const char* acct, ademco_id_t ademco_id) {
pkt->seq = seq;
copyAcct2AdemcoPacket(pkt, acct);
pkt->data.ademco_id = ademco_id;
pkt->dat.ademco_id = ademco_id;
pkt->id = AID_ACK;
return pkt->raw_len = ademco_make_ack_packet(pkt->raw, sizeof(pkt->raw),
seq, acct, ademco_id);
......@@ -940,7 +1097,7 @@ size_t ademco_make_nak_packet2(ademco_packet_t* pkt, uint16_t seq,
const char* acct, ademco_id_t ademco_id) {
pkt->seq = seq;
copyAcct2AdemcoPacket(pkt, acct);
pkt->data.ademco_id = ademco_id;
pkt->dat.ademco_id = ademco_id;
pkt->id = AID_NAK;
return pkt->raw_len = ademco_make_nak_packet(pkt->raw, sizeof(pkt->raw),
seq, acct, ademco_id);
......@@ -950,50 +1107,108 @@ size_t ademco_make_hb_packet2(ademco_packet_t* pkt, uint16_t seq,
const char* acct, ademco_id_t ademco_id,
ademco_event_t ademco_event, ademco_gg_t gg,
ademco_zone_t zone,
const ademco_xdata_t* xdata) {
const ademco_xdata_t* xdat) {
pkt->seq = seq;
copyAcct2AdemcoPacket(pkt, acct);
ademco_append_data2(&pkt->data, acct, ademco_id, ademco_event, gg, zone);
if (xdata && xdata->raw_len > 0) {
pkt->xdata.lenghFormat = xdata->lenghFormat;
memcpy(pkt->xdata.raw, xdata->raw, xdata->raw_len);
pkt->xdata.raw_len = xdata->raw_len;
ademco_append_data2(&pkt->dat, acct, ademco_id, ademco_event, gg, zone);
if (xdat && xdat->raw_len > 0) {
pkt->xdat.lenghFormat = xdat->lenghFormat;
memcpy(pkt->xdat.raw, xdat->raw, xdat->raw_len);
pkt->xdat.raw_len = xdat->raw_len;
} else
memset(&pkt->xdata, 0, sizeof(*xdata));
memset(&pkt->xdat, 0, sizeof(*xdat));
pkt->id = AID_HB;
return pkt->raw_len = ademco_make_hb_packet(pkt->raw, sizeof(pkt->raw),
seq, acct, ademco_id,
ademco_event,
gg, zone, xdata);
gg, zone, xdat);
}
size_t ademco_make_hb_packet3(ademco_packet_t* pkt) {
#if !ADEMCO_USE_UNIQUE_BUF
#if ADEMCO_USE_STATIC_BUF
static
#endif
char buf[ADEMCO_PACKET_MAX_LEN];
#endif
char* p = buf;
char* pcrc = buf + 1;
char* plen = buf + 5;
char* pid = buf + 9;
char temp[5];
uint16_t crc;
size_t packet_len, ademco_len;
buf[0] = ADEMCO_PACKET_PREFIX;
memcpy(pid, ADEMCO_PACKET_ID_HB, strlen(ADEMCO_PACKET_ID_HB));
p = pid + strlen(ADEMCO_PACKET_ID_HB);
snprintf((char*)p, 5, "%04d", pkt->seq);
p += 4;
memcpy(p, ADEMCO_RRCVR_DEFAULT, strlen(ADEMCO_RRCVR_DEFAULT));
p += strlen(ADEMCO_RRCVR_DEFAULT);
memcpy(p, ADEMCO_LPREF_DEFAULT, strlen(ADEMCO_LPREF_DEFAULT));
p += strlen(ADEMCO_LPREF_DEFAULT);
*p++ = '#';
if (pkt->acct[0] != '\0') {
memcpy(p, pkt->acct, strlen(pkt->acct));
p += strlen(pkt->acct);
} else {
snprintf(p, 7, "%06X", pkt->dat.ademco_id);
p += 6;
}
ademco_append_data3(&pkt->dat, pkt->acct);
memcpy(p, pkt->dat.raw, pkt->dat.raw_len);
p += pkt->dat.raw_len;
if (pkt->xdat.raw_len > 0) {
memcpy(p, pkt->xdat.raw, pkt->xdat.raw_len);
p += pkt->xdat.raw_len;
}
getNowTimestamp(p);
p += ADEMCO_PACKET_TIMESTAMP_LEN;
*p++ = ADEMCO_PACKET_SUFIX;
packet_len = p - buf;
// \n crc len \r
ademco_len = packet_len - 1 - 4 - 4 - 1;
snprintf(temp, 5, "%04zX", ademco_len);
memcpy(plen, temp, 4);
crc = ademco_crc16(pid, ademco_len);
snprintf(temp, 5, "%04X", crc);
memcpy(pcrc, temp, 4);
memcpy(pkt->raw, buf, packet_len);
pkt->raw[packet_len] = '\0'; // for debug convenience
return pkt->raw_len = packet_len;
}
size_t ademco_make_adm_packet2(ademco_packet_t* pkt, uint16_t seq,
const char* acct, ademco_id_t ademco_id,
ademco_event_t ademco_event, ademco_gg_t gg,
ademco_zone_t zone,
const ademco_xdata_t* xdata) {
const ademco_xdata_t* xdat) {
pkt->seq = seq;
copyAcct2AdemcoPacket(pkt, acct);
ademco_append_data2(&pkt->data, acct, ademco_id, ademco_event, gg, zone);
if (xdata && xdata->raw_len > 0) {
pkt->xdata.lenghFormat = xdata->lenghFormat;
memcpy(pkt->xdata.raw, xdata->raw, xdata->raw_len);
pkt->xdata.raw_len = xdata->raw_len;
ademco_append_data2(&pkt->dat, acct, ademco_id, ademco_event, gg, zone);
if (xdat && xdat->raw_len > 0) {
pkt->xdat.lenghFormat = xdat->lenghFormat;
memcpy(pkt->xdat.raw, xdat->raw, xdat->raw_len);
pkt->xdat.raw_len = xdat->raw_len;
} else
memset(&pkt->xdata, 0, sizeof(*xdata));
memset(&pkt->xdat, 0, sizeof(*xdat));
pkt->id = AID_ADM_CID;
return pkt->raw_len = ademco_make_adm_packet(pkt->raw, sizeof(pkt->raw),
seq, acct, ademco_id,
ademco_event,
gg, zone, xdata);
gg, zone, xdat);
}
ademco_parse_result_t ademco_parse_packet(const ademco_char_t* buff,
ademco_parse_result_t ademco_parse_packet(const ademco_char_t* buf,
size_t len,
ademco_packet_t* pkt,
size_t* cb_commited,
ademco_parse_error_t* err) {
const char *p, *q, *pid, *pend, *pacct, *pdata;
const char *p, *q, *pid, *pend, *pacct, *pdat;
uint8_t h;
uint16_t crc;
size_t len_needed;
......@@ -1003,8 +1218,8 @@ ademco_parse_result_t ademco_parse_packet(const ademco_char_t* buff,
}
*cb_commited = 0;
while (*buff != ADEMCO_PACKET_PREFIX && len > 0) {
buff++;
while (*buf != ADEMCO_PACKET_PREFIX && len > 0) {
buf++;
len--;
(*cb_commited)++;
}
......@@ -1014,20 +1229,20 @@ ademco_parse_result_t ademco_parse_packet(const ademco_char_t* buff,
return ADEMCO_PARSE_RESULT_ERROR;
}
p = buff;
p = buf;
if (*p++ != ADEMCO_PACKET_PREFIX) {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "fixed prefix not found");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "fixed prefix not found");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
// crc
crc = 0;
for (q = p; p - q < 4; p++) {
uint8_t h = char2hex(*p);
h = char2hex(*p);
if (h == 0xFF) {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "crc contains non-hex characters");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "crc contains non-hex characters");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
crc = (crc << 4) | h;
......@@ -1036,50 +1251,50 @@ ademco_parse_result_t ademco_parse_packet(const ademco_char_t* buff,
// len
pkt->len = 0;
for (q = p; p - q < 4; p++) {
uint8_t h = char2hex(*p);
h = char2hex(*p);
if (h == 0xFF) {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "len contains non-hex characters");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "len contains non-hex characters");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
pkt->len = (pkt->len << 4) | h;
}
len_needed = 9 + pkt->len + 1;
if (len < len_needed) {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "ADEMCO_PARSE_RESULT_NOT_ENOUGH");
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "ADEMCO_PARSE_RESULT_NOT_ENOUGH");
return ADEMCO_PARSE_RESULT_NOT_ENOUGH;
} else if (len_needed >= ADEMCO_PACKET_MAX_LEN) {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "len_needed >= ADEMCO_PACKET_MAX_LEN");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "len_needed >= ADEMCO_PACKET_MAX_LEN");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
pid = p;
pend = pid + pkt->len;
if (pend > buff + len) {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "suffix out of range");
*cb_commited += p - buff;
if (pend > buf + len) {
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "suffix out of range");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
if (*pend != ADEMCO_PACKET_SUFIX) {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "suffix not found");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "suffix not found");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
pkt->crc = ademco_crc16(pid, pkt->len);
if (pkt->crc != crc) {
ADEMCO_FILL_PARSE_ERROR(err, 1, "crc error");
*cb_commited += p - buff;
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
// id
if (*pid != '\"') {
ADEMCO_FILL_PARSE_ERROR(err, pid - buff, "left \" of id not found");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, pid - buf, "left \" of id not found");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
p = pid + 1;
......@@ -1087,14 +1302,14 @@ ademco_parse_result_t ademco_parse_packet(const ademco_char_t* buff,
p++;
}
if (p >= pend || *p != '\"') {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "right \" of id not found");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "right \" of id not found");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
pkt->id = ademco_packet_id_from_string((const char*)pid, ++p - pid);
if (pkt->id == AID_INVALID) {
ADEMCO_FILL_PARSE_ERROR(err, pid - buff, "unknown ademco id");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, pid - buf, "unknown ademco id");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
......@@ -1104,7 +1319,7 @@ ademco_parse_result_t ademco_parse_packet(const ademco_char_t* buff,
if ('0' <= *p && *p <= '9') {
pkt->seq = (pkt->seq * 10) + (*p - '0');
} else {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "seq contains non-digit characters");
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "seq contains non-digit characters");
// some apps use FFFF, wtf
// return ADEMCO_PARSE_RESULT_ERROR;
}
......@@ -1120,23 +1335,23 @@ ademco_parse_result_t ademco_parse_packet(const ademco_char_t* buff,
p++;
}
if (p >= pend || (*p != 'L' && *p != '#')) {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "p >= pend || (*p != 'L' && *p != '#')");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "p >= pend || (*p != 'L' && *p != '#')");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
// only check if format is correct, ignore it's content
} else if (*p == 'L') { // rrcvr not exits
// pass
} else {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "both LPREF and RRCVR not found");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "both LPREF and RRCVR not found");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
// lpref
if (*p != 'L') {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "LPREF not found");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "LPREF not found");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
while (p < pend && *p != '#') {
......@@ -1144,8 +1359,8 @@ ademco_parse_result_t ademco_parse_packet(const ademco_char_t* buff,
}
// only check if format is correct, ignore it's content
if (p >= pend || *p != '#') {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "# not found");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "# not found");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
// lpref passed
......@@ -1154,46 +1369,47 @@ ademco_parse_result_t ademco_parse_packet(const ademco_char_t* buff,
pacct = ++p;
while (p - pacct < ADEMCO_PACKET_ACCT_MAX_LEN && *p != '[') {
if (!isxdigit(*p)) {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "acct contains non-hex characters");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "acct contains non-hex characters");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
p++;
}
if (*p != '[') {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "acct too long");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "acct too long");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
strncpy(pkt->acct, (const char*)pacct, p - pacct);
pkt->acct[p - pacct] = '\0';
// data
pdata = p;
// dat
pdat = p;
if (*p != '[') {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "data's [ not found");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "dat's [ not found");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
while (p < pend && *p != ']') {
p++;
}
if (p >= pend || *p != ']') {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "data's ] not found");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "dat's ] not found");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
if (ademco_parse_data(pdata, ++p - pdata, &pkt->data, err) != ADEMCO_PARSE_RESULT_OK) {
*cb_commited += p - buff;
if (ademco_parse_data(pdat, ++p - pdat, &pkt->dat, err) != ADEMCO_PARSE_RESULT_OK) {
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
// *xdata
if (*p == '[') { // xdata exists
// *xdat
if (*p == '[') { // xdat exists
const char* pxdata = p++;
ademco_xdata_length_format_t xlf = ADEMCO_XDATA_LENGTH_FMT_FOUR_DECIMAL;
size_t valid_len = 0;
for (int i = 0; i < 4; i++)
uint8_t i;
for (i = 0; i < 4; i++)
if (!isxdigit(*(uint8_t*)(p + i)))
xlf = ADEMCO_XDATA_LENGTH_FMT_TWO_HEX;
......@@ -1209,15 +1425,15 @@ ademco_parse_result_t ademco_parse_packet(const ademco_char_t* buff,
}
if (p >= pend || *p != ']' || *(p + 1) != '_') {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "xdata's ] not found or next char is not _");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "xdat's ] not found or next char is not _");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
pkt->xdata.lenghFormat = xlf;
pkt->xdata.raw_len = ++p - pxdata;
memcpy(pkt->xdata.raw, pxdata, pkt->xdata.raw_len);
pkt->xdat.lenghFormat = xlf;
pkt->xdat.raw_len = ++p - pxdata;
memcpy(pkt->xdat.raw, pxdata, pkt->xdat.raw_len);
} else {
pkt->xdata.raw_len = 0;
pkt->xdat.raw_len = 0;
}
// timestamp, _%02d:%02d:%02d,%02d-%02d-%04d
......@@ -1271,29 +1487,34 @@ ademco_parse_result_t ademco_parse_packet(const ademco_char_t* buff,
} while (0);
if (pkt->timestamp <= 0) { // use local time instead
#ifdef ADEMCO_USE_CUSTOM_TIME_T
pkt->timestamp = ademco_get_time_t(NULL);
#else
pkt->timestamp = time(NULL);
#endif
p = pend;
}
} else {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "timestamp length not correct");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "timestamp length not correct");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
if (p++ != pend) {
ADEMCO_FILL_PARSE_ERROR(err, p - buff, "packet length not correct");
*cb_commited += p - buff;
ADEMCO_FILL_PARSE_ERROR(err, p - buf, "packet length not correct");
*cb_commited += p - buf;
return ADEMCO_PARSE_RESULT_ERROR;
}
pkt->raw_len = *cb_commited = p - buff;
if (pkt->raw != buff)
memcpy(pkt->raw, buff, pkt->raw_len);
pkt->raw_len = *cb_commited = p - buf;
if (pkt->raw != buf)
memcpy(pkt->raw, buf, pkt->raw_len);
return ADEMCO_PARSE_RESULT_OK;
}
size_t ademco_hilo_array_to_dec_str(ademco_char_t* str, const uint8_t* arr, size_t len) {
char* p = str;
for (size_t i = 0; i < len; i++) {
size_t i;
for (i = 0; i < len; i++) {
char c = (arr[i] >> 4) & 0x0F;
if (c > 9) {
return p - str;
......@@ -1310,7 +1531,8 @@ size_t ademco_hilo_array_to_dec_str(ademco_char_t* str, const uint8_t* arr, size
size_t ademco_hilo_array_to_hex_str(ademco_char_t* str, const uint8_t* arr, size_t len) {
char* p = str;
for (size_t i = 0; i < len; i++) {
size_t i;
for (i = 0; i < len; i++) {
char c = (arr[i] >> 4) & 0x0F;
if (c > 9) {
if (i < 6) {
......@@ -1338,10 +1560,11 @@ size_t ademco_hilo_array_to_hex_str(ademco_char_t* str, const uint8_t* arr, size
size_t ademco_dec_str_to_hilo_array(uint8_t* arr, size_t len, const char* str) {
char* p = (char*)arr;
size_t i;
size_t slen = str ? strlen(str) : 0;
if (slen > len * 2)
slen = len * 2;
for (size_t i = 0; i < slen; i += 2) {
for (i = 0; i < slen; i += 2) {
char hi = str[i];
if ('0' <= hi && hi <= '9') {
if (i + 1 < slen) {
......@@ -1366,10 +1589,11 @@ size_t ademco_dec_str_to_hilo_array(uint8_t* arr, size_t len, const char* str) {
size_t ademco_hex_str_to_hilo_array(uint8_t* arr, size_t len, const char* str) {
char* p = (char*)arr;
size_t i;
size_t slen = str ? strlen(str) : 0;
if (slen > len * 2)
slen = len * 2;
for (size_t i = 0; i < slen; i += 2) {
for (i = 0; i < slen; i += 2) {
char hi = str[i];
if (isxdigit(hi)) {
if (i + 1 < slen) {
......@@ -1395,7 +1619,8 @@ size_t ademco_hex_str_to_hilo_array(uint8_t* arr, size_t len, const char* str) {
size_t ademco_hex_array_to_str(char* str, const uint8_t* arr, size_t len) {
char* p = str;
for (size_t i = 0; i < len; i++) {
size_t i;
for (i = 0; i < len; i++) {
*p++ = hex2char((arr[i] >> 4) & 0x0F);
*p++ = hex2char(arr[i] & 0x0F);
}
......@@ -1405,9 +1630,10 @@ size_t ademco_hex_array_to_str(char* str, const uint8_t* arr, size_t len) {
size_t ademco_hex_str_to_array(uint8_t* arr, const char* str, uint8_t padding) {
uint8_t* p = arr;
uint8_t hi = 0, lo = 0;
size_t i;
size_t slen = str ? strlen(str) : 0;
padding &= 0x0F;
for (size_t i = 0; i < slen / 2; i++) {
for (i = 0; i < slen / 2; i++) {
char c = str[i * 2];
if ((hi = char2hex(c)) == 0xFF)
return 0;
......@@ -1426,8 +1652,9 @@ size_t ademco_hex_str_to_array_n(uint8_t* arr, const char* str,
size_t len, uint8_t padding) {
uint8_t* p = arr;
uint8_t hi = 0, lo = 0;
size_t i;
padding &= 0x0F;
for (size_t i = 0; i < len / 2; i++) {
for (i = 0; i < len / 2; i++) {
char c = str[i * 2];
if ((hi = char2hex(c)) == 0xFF)
return 0;
......@@ -1448,8 +1675,9 @@ size_t ademco_hex_str_to_array_n_allow_non_hex_str(uint8_t* arr,
uint8_t padding) {
uint8_t* p = arr;
uint8_t hi = 0, lo = 0;
size_t i;
padding &= 0x0F;
for (size_t i = 0; i < len / 2; i++) {
for (i = 0; i < len / 2; i++) {
char c = str[i * 2];
if ((hi = char2hex(c)) == 0xFF)
hi = padding;
......
#ifndef __ADEMCO_H__
#define __ADEMCO_H__
#pragma once
#include <stdint.h>
#include <time.h>
......@@ -28,11 +26,11 @@ typedef uint16_t ademco_zone_t;
#define ADEMCO_PACKET_PWD_MAX_LEN 8 // 主机密码最大长度
#define ADEMCO_PACKET_DATA_SEGMENT_EMPTY_LEN 2 // 空data段[]长度
#define ADEMCO_PACKET_DATA_SEGMENT_FULL_LEN 21 // 非空data段长度,acct长度6
#define ADEMCO_PACKET_DATA_SEGMENT_FULL_LEN_MAX 64 // 非空data段长度,acct长度未知
#define ADEMCO_PACKET_MAX_LEN 512 // 安定宝协议最大长度,包括前缀、后缀、data段、xdata段
#define ADEMCO_PACKET_DATA_SEGMENT_FULL_LEN_MAX 32 // 非空data段长度,acct长度未知
#define ADEMCO_PACKET_MAX_LEN 256 // 安定宝协议最大长度,包括前缀、后缀、data段、xdata段
#define CONGWIN_FE100_PACKET_LEN 31 // 丛文FE100协议长度
#define ADEMCO_PACKET_TIMESTAMP_LEN 20 // 时间戳长度
#define ADEMCO_PACKET_XDATA_MAX_LEN 128 // xdata段最大长度
#define ADEMCO_PACKET_XDATA_MAX_LEN 64 // xdata段最大长度
// 安定宝ID范围
#define ADEMCO_ID_INVALID 0
......@@ -103,26 +101,26 @@ typedef uint16_t ademco_zone_t;
XX(BYPASS_RECOVER, 3570, "解除旁路")
// 防区异常
#define ADEMCO_EXEPTION_EVENTS_MAP(XX) \
XX(AC_BROKE, 1301, "主机AC掉电") \
XX(LOW_BATTERY, 1302, "低电") \
XX(BAD_BATTERY, 1311, "坏电") \
XX(SOLAR_DISTURB, 1387, "光扰") \
XX(DISCONNECT, 1381, "失效") \
XX(LOST, 1393, "失联") \
XX(BATTERY_EXCEPTION, 1384, "电源故障") \
#define ADEMCO_EXEPTION_EVENTS_MAP(XX) \
XX(AC_BROKE, 1301, "主机AC掉电") \
XX(LOW_BATTERY, 1302, "低电") \
XX(BAD_BATTERY, 1311, "坏电") \
XX(SOLAR_DISTURB, 1387, "光扰") \
XX(DISCONNECT, 1381, "失效") \
XX(LOST, 1393, "失联") \
XX(POWER_EXCEPTION, 1384, "电源故障") \
XX(OTHER_EXCEPTION, 1380, "其他故障")
// 防区异常恢复
#define ADEMCO_EXEPTION_RECOVER_EVENTS_MAP(XX) \
XX(AC_RECOVER, 3301, "主机AC复电") \
XX(LOW_BATTERY_RECOVER, 3302, "低电恢复") \
XX(BAD_BATTERY_RECOVER, 3311, "坏电恢复") \
XX(SOLAR_DISTURB_RECOVER, 3387, "光扰恢复") \
XX(DISCONNECT_RECOVER, 3381, "失效恢复") \
XX(LOST_RECOVER, 3393, "失联恢复") \
XX(BATTERY_EXCEPTION_RECOVER, 3384, "电源故障恢复") \
XX(OTHER_EXCEPTION_RECOVER, 3380, "其他故障恢复") \
#define ADEMCO_EXEPTION_RECOVER_EVENTS_MAP(XX) \
XX(AC_RECOVER, 3301, "主机AC复电") \
XX(LOW_BATTERY_RECOVER, 3302, "低电恢复") \
XX(BAD_BATTERY_RECOVER, 3311, "坏电恢复") \
XX(SOLAR_DISTURB_RECOVER, 3387, "光扰恢复") \
XX(DISCONNECT_RECOVER, 3381, "失效恢复") \
XX(LOST_RECOVER, 3393, "失联恢复") \
XX(POWER_EXCEPTION_RECOVER, 3384, "电源故障恢复") \
XX(OTHER_EXCEPTION_RECOVER, 3380, "其他故障恢复") \
XX(CLEAR_EXCPTION, 3100, "清除异常指示")
// 恒博自定义安定宝事件码
......@@ -278,8 +276,8 @@ typedef struct ademco_packet_t {
uint16_t seq;
// +1 for '\0'
char acct[ADEMCO_PACKET_ACCT_MAX_LEN + 1];
ademco_data_t data;
ademco_xdata_t xdata;
ademco_data_t dat;
ademco_xdata_t xdat;
time_t timestamp;
ademco_char_t raw[ADEMCO_PACKET_MAX_LEN];
......@@ -324,27 +322,38 @@ typedef enum ademco_control_source_t {
#undef XX
} ademco_control_source_t;
//////////////////// bcd ////////////////////
#define bcd_encode(x) (((x) / 10) << 4 | ((x) % 10))
#define bcd_decode(x) (((x) >> 4) * 10 + ((x) & 0x0F))
//////////////////////// Functions ////////////////////////
ADEMCO_EXPORT_SYMBOL
uint32_t ademco_version(void);
#if ADEMCO_ENABLE_TO_STRING
ADEMCO_EXPORT_SYMBOL
const char* ademco_version_string(void);
#endif
ADEMCO_EXPORT_SYMBOL
void ademco_print(const ademco_char_t* buff, size_t len);
void ademco_print(const ademco_char_t* buf, size_t len);
ADEMCO_EXPORT_SYMBOL
uint8_t ademco_encode_signal_strength(uint8_t strength);
ADEMCO_EXPORT_SYMBOL
uint8_t ademco_decode_signal_strength(uint8_t code);
uint8_t ademco_decode_signal_strength(uint8_t bcd_strength);
// 是否合法主机账号
ADEMCO_EXPORT_SYMBOL
int ademco_is_valid_account(const char* acct);
// 是否合法主机密码
ADEMCO_EXPORT_SYMBOL
int ademco_is_valid_password(const char* pwd);
//////////////////////// ademco_event_t functions ////////////////////////
// 是否主机状态事件
......@@ -367,8 +376,10 @@ ademco_event_level_t ademco_get_event_level(ademco_event_t ademco_event);
ADEMCO_EXPORT_SYMBOL
ademco_event_t ademco_get_exception_event_by_recover_event(ademco_event_t recover_event);
#if ADEMCO_ENABLE_TO_STRING
ADEMCO_EXPORT_SYMBOL
const char* ademco_event_to_string(ademco_event_t ademco_event);
#endif
#if ADEMCO_ENABLE_CHINESE
ADEMCO_EXPORT_SYMBOL
......@@ -395,6 +406,10 @@ size_t ademco_append_data2(ademco_data_t* ademco_data,
ademco_gg_t gg,
ademco_zone_t zone);
// inplace make a `DATA` packet and store to `ademco_data`, return length
ADEMCO_EXPORT_SYMBOL
size_t ademco_append_data3(ademco_data_t* ademco_data, const char* acct);
// parse `DATA` packet, if ok, `ademco_data`'s members will be useful
// err can be NULL; caller should only check err on got ADEMCO_PARSE_RESULT_ERROR
ADEMCO_EXPORT_SYMBOL
......@@ -411,38 +426,38 @@ size_t ademco_data_to_congwin_fe100(ademco_char_t* fe100,
//////////////////////// ademco_xdata_t functions ////////////////////////
// init a empty xdata
// init a empty xdat
ADEMCO_EXPORT_SYMBOL
void ademco_xdata_init(ademco_xdata_t* xdata);
void ademco_xdata_init(ademco_xdata_t* xdat);
// return ADEMCO_OK for success, ADEMCO_ERR for failed
ADEMCO_EXPORT_SYMBOL
int ademco_xdata_convert(ademco_xdata_t* xdata, ademco_xdata_length_format_t xlf);
int ademco_xdata_convert(ademco_xdata_t* xdat, ademco_xdata_length_format_t xlf);
#ifndef SWIG
// get valid content address of xdata (except [len])
// get valid content address of xdat (except [len])
ADEMCO_EXPORT_SYMBOL
const char* ademco_xdata_get_valid_content_addr(const ademco_xdata_t* xdata);
const char* ademco_xdata_get_valid_content_addr(const ademco_xdata_t* xdat);
#endif
// get valid content length of xdata (except [len])
// get valid content length of xdat (except [len])
ADEMCO_EXPORT_SYMBOL
size_t ademco_xdata_get_valid_content_len(const ademco_xdata_t* xdata);
size_t ademco_xdata_get_valid_content_len(const ademco_xdata_t* xdat);
// return 0 if xdata's valid content is exactly the same as [buf, buf+buf_len)
// return 0 if xdat's valid content is exactly the same as [buf, buf+buf_len)
ADEMCO_EXPORT_SYMBOL
int ademco_xdata_memcmp(const ademco_xdata_t* xdata,
int ademco_xdata_memcmp(const ademco_xdata_t* xdat,
const void* buf,
size_t buf_len);
// copy xdata content from src to dst, return copied length = src.raw_len
// copy xdat content from src to dst, return copied length = src.raw_len
ADEMCO_EXPORT_SYMBOL
size_t ademco_xdata_copy(ademco_xdata_t* dst,
const ademco_xdata_t* src);
// return ADEMCO_OK for success, return ADEMCO_ERR for len is too long
ADEMCO_EXPORT_SYMBOL
int ademco_make_xdata(ademco_xdata_t* xdata,
int ademco_make_xdata(ademco_xdata_t* xdat,
ademco_xdata_length_format_t xlf,
ademco_xdata_transform_t xtr,
const ademco_char_t* content,
......@@ -464,7 +479,7 @@ const char* ademco_packet_id_to_string(ademco_packet_id_t id);
/*
* ademcoMake*Packet functions
* if buff != NULL and len >= length needed, return length used and copy data to buff
* if buf != NULL and len >= length needed, return length used and copy dat to buf
* otherwise return 0
*/
......@@ -485,28 +500,28 @@ size_t ademco_make_adm_empty_data_packet(ademco_char_t* dst_buff,
ademco_id_t ademco_id);
ADEMCO_EXPORT_SYMBOL
size_t ademco_make_null_packet(ademco_char_t* buff,
size_t ademco_make_null_packet(ademco_char_t* buf,
size_t len,
uint16_t seq,
const char* acct,
ademco_id_t ademco_id);
ADEMCO_EXPORT_SYMBOL
size_t ademco_make_ack_packet(ademco_char_t* buff,
size_t ademco_make_ack_packet(ademco_char_t* buf,
size_t len,
uint16_t seq,
const char* acct,
ademco_id_t ademco_id);
ADEMCO_EXPORT_SYMBOL
size_t ademco_make_nak_packet(ademco_char_t* buff,
size_t ademco_make_nak_packet(ademco_char_t* buf,
size_t len,
uint16_t seq,
const char* acct,
ademco_id_t ademco_id);
ADEMCO_EXPORT_SYMBOL
size_t ademco_make_hb_packet(ademco_char_t* buff,
size_t ademco_make_hb_packet(ademco_char_t* buf,
size_t len,
uint16_t seq,
const char* acct,
......@@ -514,10 +529,10 @@ size_t ademco_make_hb_packet(ademco_char_t* buff,
ademco_event_t ademco_event,
ademco_gg_t gg,
ademco_zone_t zone,
const ademco_xdata_t* xdata);
const ademco_xdata_t* xdat);
ADEMCO_EXPORT_SYMBOL
size_t ademco_make_adm_packet(ademco_char_t* buff,
size_t ademco_make_adm_packet(ademco_char_t* buf,
size_t len,
uint16_t seq,
const char* acct,
......@@ -525,9 +540,9 @@ size_t ademco_make_adm_packet(ademco_char_t* buff,
ademco_event_t ademco_event,
ademco_gg_t gg,
ademco_zone_t zone,
const ademco_xdata_t* xdata);
const ademco_xdata_t* xdat);
// like upper funcs, store buff and len to pkt->raw, pkt->raw_len
// like upper funcs, store buf and len to pkt->raw, pkt->raw_len
ADEMCO_EXPORT_SYMBOL
size_t ademco_make_null_packet2(ademco_packet_t* pkt,
uint16_t seq,
......@@ -554,7 +569,11 @@ size_t ademco_make_hb_packet2(ademco_packet_t* pkt,
ademco_event_t ademco_event,
ademco_gg_t gg,
ademco_zone_t zone,
const ademco_xdata_t* xdata);
const ademco_xdata_t* xdat);
// inplace make from pkt and to pkt
ADEMCO_EXPORT_SYMBOL
size_t ademco_make_hb_packet3(ademco_packet_t* pkt);
ADEMCO_EXPORT_SYMBOL
size_t ademco_make_adm_packet2(ademco_packet_t* pkt,
......@@ -564,12 +583,12 @@ size_t ademco_make_adm_packet2(ademco_packet_t* pkt,
ademco_event_t ademco_event,
ademco_gg_t gg,
ademco_zone_t zone,
const ademco_xdata_t* xdata);
const ademco_xdata_t* xdat);
// parse a ademco packet, if everything is OK, cb_commited is the packet length
// err can be NULL; caller should only check err on got ADEMCO_PARSE_RESULT_ERROR
ADEMCO_EXPORT_SYMBOL
ademco_parse_result_t ademco_parse_packet(const ademco_char_t* buff,
ademco_parse_result_t ademco_parse_packet(const ademco_char_t* buf,
size_t len,
ademco_packet_t* pkt,
size_t* cb_commited,
......@@ -587,7 +606,7 @@ ademco_parse_result_t ademco_parse_packet(const ademco_char_t* buff,
* Output for "123456789" : 0xBB3D
*/
ADEMCO_EXPORT_SYMBOL
uint16_t ademco_crc16(const ademco_char_t* buff, size_t len);
uint16_t ademco_crc16(const ademco_char_t* buf, size_t len);
// 将一串以高低字节表示的十六进制数组转换为10进制数字符串
// 每个字节的高四位和低四位若不大于9,将该四位表示的数字以10进制ascii码填入str,否则停止
......
#ifndef __ADEMCO_CONFIG_H__
#define __ADEMCO_CONFIG_H__
#pragma once
#ifdef ADEMCO_EXPORTS
#if defined __GNUC__
......@@ -25,9 +23,18 @@ typedef uint8_t ademco_char_t;
typedef char ademco_char_t;
#endif
#ifndef ADEMCO_ENABLE_TO_STRING
#define ADEMCO_ENABLE_TO_STRING 1
#endif
#if ADEMCO_ENABLE_TO_STRING
#ifndef ADEMCO_ENABLE_CHINESE
#define ADEMCO_ENABLE_CHINESE 1
#endif
#else
#undef ADEMCO_ENABLE_CHINESE
#define ADEMCO_ENABLE_CHINESE 0
#endif
#ifndef ADEMCO_ENABLE_PARSE_ERROR
#define ADEMCO_ENABLE_PARSE_ERROR 1
......@@ -47,4 +54,22 @@ typedef char ademco_char_t;
#define ADEMCO_FILL_PARSE_ERROR(err, offset_, msg_)
#endif // ADEMCO_ENABLE_PARSE_ERROR
#ifdef ADEMCO_USE_CUSTOM_TIME_T
extern time_t ademco_get_time_t(time_t* t);
#endif // ADEMCO_USE_CUSTOM_TIME_T
// armclang v6 `gmtime` always return NULL
#ifndef ADEMCO_DISABLE_GMTIME
#define ADEMCO_DISABLE_GMTIME 0
#endif
// embedded system may not have enough stack space
#ifndef ADEMCO_USE_STATIC_BUF
#define ADEMCO_USE_STATIC_BUF 0
#endif
#ifndef ADEMCO_USE_UNIQUE_BUF
#define ADEMCO_USE_UNIQUE_BUF 0
#endif
#endif
......@@ -7,8 +7,8 @@
*/
#define ADEMCO_VERSION_MAJOR 2
#define ADEMCO_VERSION_MINOR 5
#define ADEMCO_VERSION_PATCH 1
#define ADEMCO_VERSION_MINOR 7
#define ADEMCO_VERSION_PATCH 0
#define ADEMCO_VERSION_IS_RELEASE 1
#define ADEMCO_VERSION_SUFFIX ""
......
......@@ -86,7 +86,7 @@
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;WIN32;_DEBUG;ADEMCO_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;ADEMCO_EXPORTS;HB_EXPORTS;WIN32;_DEBUG;ADEMCO_EXPORTS;HB_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
......@@ -104,7 +104,7 @@
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;WIN32;NDEBUG;ADEMCO_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;ADEMCO_EXPORTS;HB_EXPORTS;WIN32;NDEBUG;ADEMCO_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
......@@ -122,7 +122,7 @@
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;_DEBUG;ADEMCO_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;ADEMCO_EXPORTS;HB_EXPORTS;_DEBUG;ADEMCO_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
......@@ -140,7 +140,7 @@
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;NDEBUG;ADEMCO_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;ADEMCO_EXPORTS;HB_EXPORTS;NDEBUG;ADEMCO_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
......@@ -157,11 +157,18 @@
<ItemGroup>
<ClCompile Include="..\..\ademco.c" />
<ClCompile Include="..\..\hb_core.c" />
<ClCompile Include="dllmain.cpp" />
<ClCompile Include="..\..\hb_core_ademco.c" />
<ClCompile Include="..\..\hb_rf.c" />
<ClCompile Include="dllmain.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\ademco.h" />
<ClInclude Include="..\..\ademco_config.h" />
<ClInclude Include="..\..\ademco_version.h" />
<ClInclude Include="..\..\hb_config.h" />
<ClInclude Include="..\..\hb_core.h" />
<ClInclude Include="..\..\hb_core_ademco.h" />
<ClInclude Include="..\..\hb_rf.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
......
......@@ -15,7 +15,7 @@
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="dllmain.cpp">
<ClCompile Include="dllmain.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\ademco.c">
......@@ -24,6 +24,12 @@
<ClCompile Include="..\..\hb_core.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\hb_core_ademco.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\hb_rf.c">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\ademco.h">
......@@ -32,5 +38,20 @@
<ClInclude Include="..\..\hb_core.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\ademco_config.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\ademco_version.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\hb_config.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\hb_core_ademco.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\hb_rf.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
</Project>
\ No newline at end of file
// dllmain.cpp : Defines the entry point for the DLL application.
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
// Windows Header Files
#include <windows.h>
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
// dllmain.cpp : Defines the entry point for the DLL application.
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
// Windows Header Files
#include <windows.h>
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.30114.105
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "server_demo", "server_demo\server_demo.vcxproj", "{EA5A04AA-EE49-4059-81A0-765402A210E7}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gen_event_md", "gen_event_md\gen_event_md.vcxproj", "{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ademco", "ademco\ademco.vcxproj", "{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ademco_static", "ademco_static\ademco_static.vcxproj", "{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ademco_static_mt", "ademco_static_mt\ademco_static_mt.vcxproj", "{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "httprelay", "httprelay\httprelay.vcxproj", "{3E0F1766-91F4-4218-A970-667F6345AF99}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Debug|ARM = Debug|ARM
Debug|ARM64 = Debug|ARM64
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|Any CPU = Release|Any CPU
Release|ARM = Release|ARM
Release|ARM64 = Release|ARM64
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Debug|Any CPU.ActiveCfg = Debug|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Debug|ARM.ActiveCfg = Debug|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Debug|ARM64.ActiveCfg = Debug|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Debug|x64.ActiveCfg = Debug|x64
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Debug|x64.Build.0 = Debug|x64
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Debug|x86.ActiveCfg = Debug|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Debug|x86.Build.0 = Debug|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Release|Any CPU.ActiveCfg = Release|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Release|ARM.ActiveCfg = Release|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Release|ARM64.ActiveCfg = Release|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Release|x64.ActiveCfg = Release|x64
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Release|x64.Build.0 = Release|x64
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Release|x86.ActiveCfg = Release|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Release|x86.Build.0 = Release|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Debug|Any CPU.ActiveCfg = Debug|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Debug|ARM.ActiveCfg = Debug|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Debug|ARM64.ActiveCfg = Debug|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Debug|x64.ActiveCfg = Debug|x64
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Debug|x64.Build.0 = Debug|x64
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Debug|x86.ActiveCfg = Debug|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Debug|x86.Build.0 = Debug|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Release|Any CPU.ActiveCfg = Release|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Release|ARM.ActiveCfg = Release|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Release|ARM64.ActiveCfg = Release|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Release|x64.ActiveCfg = Release|x64
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Release|x64.Build.0 = Release|x64
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Release|x86.ActiveCfg = Release|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Release|x86.Build.0 = Release|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Debug|Any CPU.ActiveCfg = Debug|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Debug|ARM.ActiveCfg = Debug|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Debug|ARM64.ActiveCfg = Debug|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Debug|x64.ActiveCfg = Debug|x64
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Debug|x64.Build.0 = Debug|x64
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Debug|x86.ActiveCfg = Debug|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Debug|x86.Build.0 = Debug|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Release|Any CPU.ActiveCfg = Release|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Release|ARM.ActiveCfg = Release|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Release|ARM64.ActiveCfg = Release|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Release|x64.ActiveCfg = Release|x64
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Release|x64.Build.0 = Release|x64
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Release|x86.ActiveCfg = Release|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Release|x86.Build.0 = Release|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Debug|Any CPU.ActiveCfg = Debug|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Debug|ARM.ActiveCfg = Debug|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Debug|ARM64.ActiveCfg = Debug|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Debug|x64.ActiveCfg = Debug|x64
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Debug|x64.Build.0 = Debug|x64
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Debug|x86.ActiveCfg = Debug|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Debug|x86.Build.0 = Debug|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Release|Any CPU.ActiveCfg = Release|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Release|ARM.ActiveCfg = Release|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Release|ARM64.ActiveCfg = Release|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Release|x64.ActiveCfg = Release|x64
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Release|x64.Build.0 = Release|x64
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Release|x86.ActiveCfg = Release|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Release|x86.Build.0 = Release|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Debug|Any CPU.ActiveCfg = Debug|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Debug|ARM.ActiveCfg = Debug|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Debug|ARM64.ActiveCfg = Debug|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Debug|x64.ActiveCfg = Debug|x64
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Debug|x64.Build.0 = Debug|x64
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Debug|x86.ActiveCfg = Debug|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Debug|x86.Build.0 = Debug|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Release|Any CPU.ActiveCfg = Release|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Release|ARM.ActiveCfg = Release|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Release|ARM64.ActiveCfg = Release|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Release|x64.ActiveCfg = Release|x64
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Release|x64.Build.0 = Release|x64
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Release|x86.ActiveCfg = Release|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Release|x86.Build.0 = Release|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Debug|Any CPU.ActiveCfg = Debug|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Debug|ARM.ActiveCfg = Debug|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Debug|ARM64.ActiveCfg = Debug|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Debug|x64.ActiveCfg = Debug|x64
{3E0F1766-91F4-4218-A970-667F6345AF99}.Debug|x64.Build.0 = Debug|x64
{3E0F1766-91F4-4218-A970-667F6345AF99}.Debug|x86.ActiveCfg = Debug|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Debug|x86.Build.0 = Debug|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Release|Any CPU.ActiveCfg = Release|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Release|ARM.ActiveCfg = Release|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Release|ARM64.ActiveCfg = Release|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Release|x64.ActiveCfg = Release|x64
{3E0F1766-91F4-4218-A970-667F6345AF99}.Release|x64.Build.0 = Release|x64
{3E0F1766-91F4-4218-A970-667F6345AF99}.Release|x86.ActiveCfg = Release|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {C2F989C3-AE4A-4946-98BE-18AD5AD2C12E}
EndGlobalSection
EndGlobal

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.30114.105
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "server_demo", "server_demo\server_demo.vcxproj", "{EA5A04AA-EE49-4059-81A0-765402A210E7}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gen_event_md", "gen_event_md\gen_event_md.vcxproj", "{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}"
ProjectSection(ProjectDependencies) = postProject
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A} = {0757EA7C-9E3F-4F2F-8544-B1E649C9749A}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ademco", "ademco\ademco.vcxproj", "{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ademco_static", "ademco_static\ademco_static.vcxproj", "{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ademco_static_mt", "ademco_static_mt\ademco_static_mt.vcxproj", "{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "httprelay", "httprelay\httprelay.vcxproj", "{3E0F1766-91F4-4218-A970-667F6345AF99}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Debug|ARM = Debug|ARM
Debug|ARM64 = Debug|ARM64
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|Any CPU = Release|Any CPU
Release|ARM = Release|ARM
Release|ARM64 = Release|ARM64
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Debug|Any CPU.ActiveCfg = Debug|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Debug|ARM.ActiveCfg = Debug|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Debug|ARM64.ActiveCfg = Debug|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Debug|x64.ActiveCfg = Debug|x64
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Debug|x64.Build.0 = Debug|x64
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Debug|x86.ActiveCfg = Debug|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Debug|x86.Build.0 = Debug|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Release|Any CPU.ActiveCfg = Release|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Release|ARM.ActiveCfg = Release|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Release|ARM64.ActiveCfg = Release|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Release|x64.ActiveCfg = Release|x64
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Release|x64.Build.0 = Release|x64
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Release|x86.ActiveCfg = Release|Win32
{EA5A04AA-EE49-4059-81A0-765402A210E7}.Release|x86.Build.0 = Release|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Debug|Any CPU.ActiveCfg = Debug|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Debug|ARM.ActiveCfg = Debug|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Debug|ARM64.ActiveCfg = Debug|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Debug|x64.ActiveCfg = Debug|x64
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Debug|x64.Build.0 = Debug|x64
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Debug|x86.ActiveCfg = Debug|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Debug|x86.Build.0 = Debug|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Release|Any CPU.ActiveCfg = Release|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Release|ARM.ActiveCfg = Release|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Release|ARM64.ActiveCfg = Release|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Release|x64.ActiveCfg = Release|x64
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Release|x64.Build.0 = Release|x64
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Release|x86.ActiveCfg = Release|Win32
{FED919A9-19E0-4D4A-972F-DDF537F5DEFE}.Release|x86.Build.0 = Release|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Debug|Any CPU.ActiveCfg = Debug|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Debug|ARM.ActiveCfg = Debug|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Debug|ARM64.ActiveCfg = Debug|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Debug|x64.ActiveCfg = Debug|x64
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Debug|x64.Build.0 = Debug|x64
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Debug|x86.ActiveCfg = Debug|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Debug|x86.Build.0 = Debug|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Release|Any CPU.ActiveCfg = Release|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Release|ARM.ActiveCfg = Release|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Release|ARM64.ActiveCfg = Release|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Release|x64.ActiveCfg = Release|x64
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Release|x64.Build.0 = Release|x64
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Release|x86.ActiveCfg = Release|Win32
{0757EA7C-9E3F-4F2F-8544-B1E649C9749A}.Release|x86.Build.0 = Release|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Debug|Any CPU.ActiveCfg = Debug|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Debug|ARM.ActiveCfg = Debug|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Debug|ARM64.ActiveCfg = Debug|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Debug|x64.ActiveCfg = Debug|x64
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Debug|x64.Build.0 = Debug|x64
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Debug|x86.ActiveCfg = Debug|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Debug|x86.Build.0 = Debug|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Release|Any CPU.ActiveCfg = Release|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Release|ARM.ActiveCfg = Release|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Release|ARM64.ActiveCfg = Release|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Release|x64.ActiveCfg = Release|x64
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Release|x64.Build.0 = Release|x64
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Release|x86.ActiveCfg = Release|Win32
{3A477FA2-F84E-40E5-9767-0FFBD35BC57A}.Release|x86.Build.0 = Release|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Debug|Any CPU.ActiveCfg = Debug|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Debug|ARM.ActiveCfg = Debug|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Debug|ARM64.ActiveCfg = Debug|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Debug|x64.ActiveCfg = Debug|x64
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Debug|x64.Build.0 = Debug|x64
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Debug|x86.ActiveCfg = Debug|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Debug|x86.Build.0 = Debug|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Release|Any CPU.ActiveCfg = Release|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Release|ARM.ActiveCfg = Release|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Release|ARM64.ActiveCfg = Release|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Release|x64.ActiveCfg = Release|x64
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Release|x64.Build.0 = Release|x64
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Release|x86.ActiveCfg = Release|Win32
{0AA93A45-37CE-40DE-A0E9-7163941DFB2A}.Release|x86.Build.0 = Release|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Debug|Any CPU.ActiveCfg = Debug|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Debug|ARM.ActiveCfg = Debug|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Debug|ARM64.ActiveCfg = Debug|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Debug|x64.ActiveCfg = Debug|x64
{3E0F1766-91F4-4218-A970-667F6345AF99}.Debug|x64.Build.0 = Debug|x64
{3E0F1766-91F4-4218-A970-667F6345AF99}.Debug|x86.ActiveCfg = Debug|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Debug|x86.Build.0 = Debug|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Release|Any CPU.ActiveCfg = Release|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Release|ARM.ActiveCfg = Release|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Release|ARM64.ActiveCfg = Release|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Release|x64.ActiveCfg = Release|x64
{3E0F1766-91F4-4218-A970-667F6345AF99}.Release|x64.Build.0 = Release|x64
{3E0F1766-91F4-4218-A970-667F6345AF99}.Release|x86.ActiveCfg = Release|Win32
{3E0F1766-91F4-4218-A970-667F6345AF99}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {C2F989C3-AE4A-4946-98BE-18AD5AD2C12E}
EndGlobalSection
EndGlobal
......@@ -21,6 +21,8 @@
<ItemGroup>
<ClCompile Include="..\..\ademco.c" />
<ClCompile Include="..\..\hb_core.c" />
<ClCompile Include="..\..\hb_core_ademco.c" />
<ClCompile Include="..\..\hb_rf.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\ademco.h" />
......@@ -94,7 +96,7 @@
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;ADEMCO_EXPORTS;HB_EXPORTS;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
......@@ -112,7 +114,7 @@
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;ADEMCO_EXPORTS;HB_EXPORTS;WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
......@@ -130,7 +132,7 @@
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;ADEMCO_EXPORTS;HB_EXPORTS;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
......@@ -148,7 +150,7 @@
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;ADEMCO_EXPORTS;HB_EXPORTS;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
......
......@@ -21,6 +21,12 @@
<ClCompile Include="..\..\hb_core.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\hb_core_ademco.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\hb_rf.c">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\ademco.h">
......
......@@ -21,6 +21,8 @@
<ItemGroup>
<ClCompile Include="..\..\ademco.c" />
<ClCompile Include="..\..\hb_core.c" />
<ClCompile Include="..\..\hb_core_ademco.c" />
<ClCompile Include="..\..\hb_rf.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\ademco.h" />
......@@ -94,7 +96,7 @@
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;ADEMCO_EXPORTS;HB_EXPORTS;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
......@@ -113,7 +115,7 @@
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;ADEMCO_EXPORTS;HB_EXPORTS;WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
......@@ -132,7 +134,7 @@
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;ADEMCO_EXPORTS;HB_EXPORTS;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
......@@ -151,7 +153,7 @@
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;ADEMCO_ENABLE_CHINESE;ADEMCO_EXPORTS;HB_EXPORTS;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
......
......@@ -21,6 +21,12 @@
<ClCompile Include="..\..\hb_core.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\hb_core_ademco.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\hb_rf.c">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\ademco.h">
......
#include "../../ademco.h"
#include "../../hb_core.h"
#include "../../hb_core_ademco.h"
#include <jlib/win32/UnicodeTool.h>
#include <jlib/win32/path_op.h>
#include <jlib/util/std_util.h>
#include <map>
#ifdef _WIN64
#ifdef _DEBUG
#pragma comment(lib, "../x64/Debug/ademco.lib")
......
#include <curl/curl.h>
#include <stdio.h>
#include "../../hb_core.h"
#include <string.h>
#include "../../hb_core_ademco.h"
#include "cJSON/cJSON.h"
#include "uvlib/uv_log.h"
#include "uvlib/uv_tcpserver.h"
#include "cJSON/cJSON.h"
#include <curl/curl.h>
#include <string.h>
typedef struct machine_info_s {
char acct[ADEMCO_PACKET_ACCT_MAX_LEN + 1];
ademco_id_t ademco_id;
hb_machine_type_t type;
hb_machine_status_t status;
}machine_info_t;
char acct[ADEMCO_PACKET_ACCT_MAX_LEN + 1];
ademco_id_t ademco_id;
hb_machine_type_t type;
hb_machine_status_t status;
} machine_info_t;
struct {
uv_loop_t* loop;
uv_tcpserver_t* tcpd;
const char* uri;
}context;
uv_loop_t* loop;
uv_tcpserver_t* tcpd;
const char* uri;
} context;
size_t on_write(void* buffer, size_t size, size_t nmemb, void* user) {
mybuf_t* buf = user;
mybuf_append(buf, buffer, size * nmemb);
return size * nmemb;
mybuf_t* buf = user;
mybuf_append(buf, buffer, size * nmemb);
return size * nmemb;
}
int post(const char* json) {
CURLcode res;
CURL* curl = curl_easy_init();
struct curl_slist* headers = NULL;
mybuf_t resp;
long http_status, header_size;
mybuf_init(&resp);
do {
if (!curl) {
res = CURLE_FAILED_INIT;
uvlog_error("curl_easy_init failed");
break;
}
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_HEADER, 1);
curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
curl_easy_setopt(curl, CURLOPT_POST, 1);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &resp);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, on_write);
curl_easy_setopt(curl, CURLOPT_URL, context.uri);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json);
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, strlen(json));
curl_easy_setopt(curl, CURLOPT_TIMEOUT, 3);
res = curl_easy_perform(curl);
if (res == CURLE_OK || res == CURLE_GOT_NOTHING) {
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_status);
curl_easy_getinfo(curl, CURLINFO_HEADER_SIZE, &header_size);
}
mybuf_reserve(&resp, resp.size + 1);
resp.buf[resp.size] = '\0';
uvlog_debug("RESP: %d %s\n"
"%s\n",
res, curl_easy_strerror(res),
resp.buf);
} while (0);
if (curl)
curl_easy_cleanup(curl);
if (headers) {
curl_slist_free_all(headers);
headers = NULL;
}
return 0;
CURLcode res;
CURL* curl = curl_easy_init();
struct curl_slist* headers = NULL;
mybuf_t resp;
long http_status, header_size;
mybuf_init(&resp);
do {
if (!curl) {
res = CURLE_FAILED_INIT;
uvlog_error("curl_easy_init failed");
break;
}
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_HEADER, 1);
curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
curl_easy_setopt(curl, CURLOPT_POST, 1);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &resp);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, on_write);
curl_easy_setopt(curl, CURLOPT_URL, context.uri);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json);
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, strlen(json));
curl_easy_setopt(curl, CURLOPT_TIMEOUT, 3);
res = curl_easy_perform(curl);
if (res == CURLE_OK || res == CURLE_GOT_NOTHING) {
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_status);
curl_easy_getinfo(curl, CURLINFO_HEADER_SIZE, &header_size);
}
mybuf_reserve(&resp, resp.size + 1);
resp.buf[resp.size] = '\0';
uvlog_debug(
"RESP: %d %s\n"
"%s\n",
res, curl_easy_strerror(res),
resp.buf);
} while (0);
if (curl)
curl_easy_cleanup(curl);
if (headers) {
curl_slist_free_all(headers);
headers = NULL;
}
return 0;
}
int relay(const char* acct, ademco_event_t ademco_event, ademco_zone_t zone, ademco_gg_t gg) {
cJSON* json = NULL;
char* string = NULL;
int r = 0;
json = cJSON_CreateObject();
fatal_if_null(json);
if (cJSON_AddStringToObject(json, "acct", acct) == NULL) goto end;
if (cJSON_AddNumberToObject(json, "ademco_event", ademco_event) == NULL) goto end;
if (cJSON_AddNumberToObject(json, "zone", zone) == NULL) goto end;
if (cJSON_AddNumberToObject(json, "gg", gg) == NULL) goto end;
string = cJSON_Print(json);
if (string == NULL) goto end;
uvlog_debug("OUT:\n%s\n", string);
r = post(string);
cJSON* json = NULL;
char* string = NULL;
int r = 0;
json = cJSON_CreateObject();
fatal_if_null(json);
if (cJSON_AddStringToObject(json, "acct", acct) == NULL) goto end;
if (cJSON_AddNumberToObject(json, "ademco_event", ademco_event) == NULL) goto end;
if (cJSON_AddNumberToObject(json, "zone", zone) == NULL) goto end;
if (cJSON_AddNumberToObject(json, "gg", gg) == NULL) goto end;
string = cJSON_Print(json);
if (string == NULL) goto end;
uvlog_debug("OUT:\n%s\n", string);
r = post(string);
end:
if (json)
cJSON_Delete(json);
if (string)
free(string);
return r;
if (json)
cJSON_Delete(json);
if (string)
free(string);
return r;
}
void on_tcp_connection(uv_tcpserver_client_context_t* client, int connected) {
if (connected) {
machine_info_t* machine = malloc(sizeof(machine_info_t));
memset(machine->acct, '\0', sizeof(machine->acct));
machine->ademco_id = 0;
machine->type = HMT_INVALID;
machine->status = HMS_INVALID;
client->data = machine;
} else if(client->data) {
if (((machine_info_t*)(client->data))->acct[0] != '\0') {
relay(((machine_info_t*)(client->data))->acct, EVENT_OFFLINE, 0, 0);
}
free(client->data);
}
if (connected) {
machine_info_t* machine = malloc(sizeof(machine_info_t));
memset(machine->acct, '\0', sizeof(machine->acct));
machine->ademco_id = 0;
machine->type = HMT_INVALID;
machine->status = HMS_INVALID;
client->data = machine;
} else if (client->data) {
if (((machine_info_t*)(client->data))->acct[0] != '\0') {
relay(((machine_info_t*)(client->data))->acct, EVENT_OFFLINE, 0, 0);
}
free(client->data);
}
}
uv_tcp_parse_result_t on_tcp_parse(uv_tcpserver_client_context_t* client, const char* buf, size_t len, size_t* ate) {
ademco_packet_t pkt;
ademco_parse_result_t res = ademco_parse_packet(buf, len, &pkt, ate, NULL);
switch (res) {
case ADEMCO_PARSE_RESULT_OK:
switch (pkt.id) {
case AID_NULL:
case AID_HB:
case AID_ADM_CID:
printf("C:");
ademco_print(pkt.raw, pkt.raw_len);
if (((machine_info_t*)(client->data))->acct[0] == '\0') {
strcpy(((machine_info_t*)(client->data))->acct, pkt.acct);
relay(pkt.acct, EVENT_ONLINE, 0, 0);
}
if (pkt.data.ademco_id) {
((machine_info_t*)(client->data))->ademco_id = pkt.data.ademco_id;
}
if (ademco_is_machine_status_event(pkt.data.ademco_event)) {
((machine_info_t*)(client->data))->status = hb_machine_status_from_ademco_event(pkt.data.ademco_event);
}
if (ademco_is_machine_type_event(pkt.data.ademco_event)) {
((machine_info_t*)(client->data))->type = hb_machine_type_from_ademco_event(pkt.data.ademco_event);
}
if (pkt.data.ademco_event != EVENT_INVALID_EVENT && ((machine_info_t*)(client->data))->acct[0] != '\0') {
relay(((machine_info_t*)(client->data))->acct, pkt.data.ademco_event, pkt.data.zone, pkt.data.gg);
}
ademco_make_ack_packet2(&pkt, pkt.seq, pkt.acct, pkt.data.ademco_id);
uv_tcpserver_send_to_cli(client, pkt.raw, pkt.raw_len);
printf("S:");
ademco_print(pkt.raw, pkt.raw_len);
break;
}
return uv_tcp_parse_ok;
break;
case ADEMCO_PARSE_RESULT_NOT_ENOUGH:
return uv_tcp_parse_not_enough;
break;
case ADEMCO_PARSE_RESULT_ERROR:
return uv_tcp_parse_error;
break;
default:
abort();
break;
}
ademco_packet_t pkt;
ademco_parse_result_t res = ademco_parse_packet(buf, len, &pkt, ate, NULL);
switch (res) {
case ADEMCO_PARSE_RESULT_OK:
switch (pkt.id) {
case AID_NULL:
case AID_HB:
case AID_ADM_CID:
printf("C:");
ademco_print(pkt.raw, pkt.raw_len);
if (((machine_info_t*)(client->data))->acct[0] == '\0') {
strcpy(((machine_info_t*)(client->data))->acct, pkt.acct);
relay(pkt.acct, EVENT_ONLINE, 0, 0);
}
if (pkt.dat.ademco_id) {
((machine_info_t*)(client->data))->ademco_id = pkt.dat.ademco_id;
}
if (ademco_is_machine_status_event(pkt.dat.ademco_event)) {
((machine_info_t*)(client->data))->status = hb_machine_status_from_ademco_event(pkt.dat.ademco_event);
}
if (ademco_is_machine_type_event(pkt.dat.ademco_event)) {
((machine_info_t*)(client->data))->type = hb_machine_type_from_ademco_event(pkt.dat.ademco_event);
}
if (pkt.dat.ademco_event != EVENT_INVALID_EVENT && ((machine_info_t*)(client->data))->acct[0] != '\0') {
relay(((machine_info_t*)(client->data))->acct, pkt.dat.ademco_event, pkt.dat.zone, pkt.dat.gg);
}
ademco_make_ack_packet2(&pkt, pkt.seq, pkt.acct, pkt.dat.ademco_id);
uv_tcpserver_send_to_cli(client, pkt.raw, pkt.raw_len);
printf("S:");
ademco_print(pkt.raw, pkt.raw_len);
break;
}
return uv_tcp_parse_ok;
break;
case ADEMCO_PARSE_RESULT_NOT_ENOUGH:
return uv_tcp_parse_not_enough;
break;
case ADEMCO_PARSE_RESULT_ERROR:
return uv_tcp_parse_error;
break;
default:
abort();
break;
}
}
int init_tcpd(int port) {
static uv_tcpserver_settings_t settings = { on_tcp_connection, on_tcp_parse, NULL };
int r = uv_tcpserver_create(&context.tcpd, context.loop, &settings);
fatal_on_uv_err(r, "uv_tcpserver_create");
r = uv_tcpserver_start_listen(context.tcpd, "0.0.0.0", port);
fatal_on_uv_err(r, "uv_tcpserver_start_listen");
printf("tcp server listening on %s:%d\n", "0.0.0.0", port);
return r;
static uv_tcpserver_settings_t settings = {on_tcp_connection, on_tcp_parse, NULL};
int r = uv_tcpserver_create(&context.tcpd, context.loop, &settings);
fatal_on_uv_err(r, "uv_tcpserver_create");
r = uv_tcpserver_start_listen(context.tcpd, "0.0.0.0", port);
fatal_on_uv_err(r, "uv_tcpserver_start_listen");
printf("tcp server listening on %s:%d\n", "0.0.0.0", port);
return r;
}
int main(int argc, char** argv) {
if (argc != 3) {
fprintf(stderr, "Usage: %s tcp_server_listening_port http_client_relay_to_uri\n"
" Example: %s 12345 http://your-http-server.com:8080/ademco\n",
argv[0], argv[0]);
exit(1);
}
if (argc != 3) {
fprintf(stderr,
"Usage: %s tcp_server_listening_port http_client_relay_to_uri\n"
" Example: %s 12345 http://your-http-server.com:8080/ademco\n",
argv[0], argv[0]);
exit(1);
}
uv_log_set_level(uv_log_level_debug);
memset(&context, 0, sizeof(context));
context.uri = argv[2];
uv_log_set_level(uv_log_level_debug);
memset(&context, 0, sizeof(context));
context.uri = argv[2];
context.loop = uv_default_loop();
fatal_if_null(context.loop);
context.loop = uv_default_loop();
fatal_if_null(context.loop);
curl_global_init(CURL_GLOBAL_ALL);
curl_global_init(CURL_GLOBAL_ALL);
if (init_tcpd(atoi(argv[1]))) {
abort();
}
if (init_tcpd(atoi(argv[1]))) {
abort();
}
uv_run(context.loop, UV_RUN_DEFAULT);
uv_run(context.loop, UV_RUN_DEFAULT);
}
......@@ -153,6 +153,8 @@
<ItemGroup>
<ClCompile Include="..\..\ademco.c" />
<ClCompile Include="..\..\hb_core.c" />
<ClCompile Include="..\..\hb_core_ademco.c" />
<ClCompile Include="..\..\hb_rf.c" />
<ClCompile Include="cJSON\cJSON.c" />
<ClCompile Include="httprelay.c" />
<ClCompile Include="uvlib\llhttp\src\api.c" />
......@@ -169,6 +171,8 @@
<ItemGroup>
<ClInclude Include="..\..\ademco.h" />
<ClInclude Include="..\..\hb_core.h" />
<ClInclude Include="..\..\hb_core_ademco.h" />
<ClInclude Include="..\..\hb_rf.h" />
<ClInclude Include="cJSON\cJSON.h" />
<ClInclude Include="uvlib\list.h" />
<ClInclude Include="uvlib\mybuf.h" />
......
......@@ -69,6 +69,12 @@
<ClCompile Include="..\..\hb_core.c">
<Filter>ademco</Filter>
</ClCompile>
<ClCompile Include="..\..\hb_core_ademco.c">
<Filter>ademco</Filter>
</ClCompile>
<ClCompile Include="..\..\hb_rf.c">
<Filter>ademco</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\ademco.h">
......@@ -107,5 +113,11 @@
<ClInclude Include="..\..\hb_core.h">
<Filter>ademco</Filter>
</ClInclude>
<ClInclude Include="..\..\hb_core_ademco.h">
<Filter>ademco</Filter>
</ClInclude>
<ClInclude Include="..\..\hb_rf.h">
<Filter>ademco</Filter>
</ClInclude>
</ItemGroup>
</Project>
\ No newline at end of file
......@@ -164,7 +164,7 @@ int main(int argc, char** argv) {
case AID_ADM_CID:
{
clientAcct = pkt.acct;
clientAdemcoId = pkt.data.ademco_id;
clientAdemcoId = pkt.dat.ademco_id;
// handle event
// reply ack
......
#ifndef __HB_CONFIG_H__
#define __HB_CONFIG_H__
#ifdef HB_EXPORTS
#if defined __GNUC__
#define HB_EXPORT_SYMBOL __attribute__((visibility("default")))
#elif defined(_MSC_VER)
#define HB_EXPORT_SYMBOL __declspec(dllexport)
#else
#define HB_EXPORT_SYMBOL
#endif
#else // HB_EXPORTS
#define HB_EXPORT_SYMBOL
#endif
#ifndef HB_ENABLE_TO_STRING
#ifdef ADEMCO_ENABLE_TO_STRING
#define HB_ENABLE_TO_STRING ADEMCO_ENABLE_TO_STRING
#else
#define HB_ENABLE_TO_STRING 1
#endif
#endif // HB_ENABLE_TO_STRING
#if HB_ENABLE_TO_STRING
#ifndef HB_ENABLE_CHINESE
#ifdef ADEMCO_ENABLE_CHINESE
#define HB_ENABLE_CHINESE ADEMCO_ENABLE_CHINESE
#else
#define HB_ENABLE_CHINESE 1
#endif
#endif
#else // HB_ENABLE_TO_STRING
#undef HB_ENABLE_CHINESE
#define HB_ENABLE_CHINESE 0
#endif // HB_ENABLE_TO_STRING
#endif
......@@ -2,8 +2,8 @@
#include <string.h>
size_t hb_get_available_zone_properties_by_type(hb_machine_type_t type,
hb_zone_property_t props[HZP_COUNT]) {
uint8_t hb_get_available_zone_properties_by_type(hb_machine_type_t type,
hb_zone_property_t props[HZP_COUNT]) {
switch (type) {
case HMT_WIFI:
break;
......@@ -13,7 +13,7 @@ size_t hb_get_available_zone_properties_by_type(hb_machine_type_t type,
case HMT_GPRS:
case HMT_WIFI2: {
hb_zone_property_t hzps[] = {
HZP_BUGLAR,
HZP_BURGLAR,
HZP_EMERGENCY,
HZP_FIRE,
HZP_DURESS,
......@@ -26,7 +26,7 @@ size_t hb_get_available_zone_properties_by_type(hb_machine_type_t type,
}
case HMT_NETMOD: {
hb_zone_property_t hzps[] = {
HZP_BUGLAR,
HZP_BURGLAR,
HZP_EMERGENCY,
HZP_FIRE,
HZP_DURESS,
......@@ -34,7 +34,7 @@ size_t hb_get_available_zone_properties_by_type(hb_machine_type_t type,
HZP_WATER,
HZP_SUB_MACHINE,
HZP_REMOTE_CONTROL,
HZP_BUGLAR_HALF,
HZP_BURGLAR_HALF,
HZP_SHIELD,
HZP_DOOR_RING,
};
......@@ -43,16 +43,16 @@ size_t hb_get_available_zone_properties_by_type(hb_machine_type_t type,
}
case HMT_LCD: {
hb_zone_property_t hzps[] = {
HZP_BUGLAR, HZP_EMERGENCY, HZP_FIRE,
HZP_BURGLAR, HZP_EMERGENCY, HZP_FIRE,
HZP_DURESS, HZP_GAS, HZP_WATER, HZP_SUB_MACHINE,
HZP_REMOTE_CONTROL, HZP_BUGLAR_HALF, HZP_SHIELD,
HZP_REMOTE_CONTROL, HZP_BURGLAR_HALF, HZP_SHIELD,
HZP_DOOR_RING, HZP_BYPASS};
memcpy(props, hzps, sizeof(hzps));
return sizeof(hzps) / sizeof(hb_zone_property_t);
}
case HMT_WIRED: {
hb_zone_property_t hzps[] = {
HZP_BUGLAR,
HZP_BURGLAR,
HZP_EMERGENCY,
HZP_FIRE,
HZP_DURESS,
......@@ -65,7 +65,7 @@ size_t hb_get_available_zone_properties_by_type(hb_machine_type_t type,
}
case HMT_TRUE_COLOR: {
hb_zone_property_t hzps[] = {
HZP_BUGLAR, HZP_EMERGENCY, HZP_FIRE,
HZP_BURGLAR, HZP_EMERGENCY, HZP_FIRE,
HZP_DURESS, HZP_GAS, HZP_WATER, HZP_REMOTE_CONTROL,
HZP_SHIELD, HZP_DOOR_RING, HZP_BYPASS};
memcpy(props, hzps, sizeof(hzps));
......@@ -73,7 +73,7 @@ size_t hb_get_available_zone_properties_by_type(hb_machine_type_t type,
}
case HMT_THREE_SECTION: {
hb_zone_property_t hzps[] = {
HZP_BUGLAR, HZP_EMERGENCY, HZP_FIRE,
HZP_BURGLAR, HZP_EMERGENCY, HZP_FIRE,
HZP_DURESS, HZP_GAS, HZP_WATER, HZP_REMOTE_CONTROL,
HZP_SHIELD, HZP_DOOR_RING, HZP_BYPASS};
memcpy(props, hzps, sizeof(hzps));
......@@ -81,7 +81,7 @@ size_t hb_get_available_zone_properties_by_type(hb_machine_type_t type,
}
case HMT_IOT: {
hb_zone_property_t hzps[] = {
HZP_BUGLAR, HZP_EMERGENCY, HZP_FIRE,
HZP_BURGLAR, HZP_EMERGENCY, HZP_FIRE,
HZP_DURESS, HZP_GAS, HZP_WATER, HZP_REMOTE_CONTROL,
HZP_SHIELD, HZP_DOOR_RING, HZP_BYPASS};
memcpy(props, hzps, sizeof(hzps));
......@@ -89,7 +89,7 @@ size_t hb_get_available_zone_properties_by_type(hb_machine_type_t type,
}
case HMT_GPRS_PHONE: {
hb_zone_property_t hzps[] = {
HZP_BUGLAR,
HZP_BURGLAR,
HZP_EMERGENCY,
HZP_FIRE,
HZP_DURESS,
......@@ -102,7 +102,7 @@ size_t hb_get_available_zone_properties_by_type(hb_machine_type_t type,
}
case HMT_NB: {
hb_zone_property_t hzps[] = {
HZP_BUGLAR,
HZP_BURGLAR,
HZP_EMERGENCY,
HZP_FIRE,
HZP_DURESS,
......@@ -119,7 +119,7 @@ size_t hb_get_available_zone_properties_by_type(hb_machine_type_t type,
return 0;
}
ademco_zone_t hb_get_max_zone_by_type(hb_machine_type_t type) {
uint16_t hb_get_max_zone_by_type(hb_machine_type_t type) {
switch (type) {
case HMT_GPRS_IOT:
case HMT_GPRS:
......@@ -152,16 +152,16 @@ ademco_zone_t hb_get_max_zone_by_type(hb_machine_type_t type) {
}
}
int hb_is_valid_zone_by_type(hb_machine_type_t type, ademco_zone_t zone) {
return ADEMCO_ZONE_FOR_MACHINE_SELF <= zone &&
uint8_t hb_is_valid_zone_by_type(hb_machine_type_t type, uint16_t zone) {
return 0 <= zone &&
zone <= hb_get_max_zone_by_type(type);
}
int hb_is_valid_zone_by_type_strict(hb_machine_type_t type, ademco_zone_t zone) {
return ADEMCO_ZONE_MIN <= zone && zone <= hb_get_max_zone_by_type(type);
uint8_t hb_is_valid_zone_by_type_strict(hb_machine_type_t type, uint16_t zone) {
return 1 <= zone && zone <= hb_get_max_zone_by_type(type);
}
int hb_is_machine_on_sale(hb_machine_type_t type) {
uint8_t hb_is_machine_on_sale(hb_machine_type_t type) {
return type == HMT_GPRS_IOT ||
type == HMT_NETMOD ||
type == HMT_GPRS ||
......@@ -175,23 +175,23 @@ int hb_is_machine_on_sale(hb_machine_type_t type) {
type == HMT_WIFI2;
}
int hb_machine_can_arm_away(hb_machine_type_t type) {
uint8_t hb_machine_can_arm_away(hb_machine_type_t type) {
return hb_is_machine_on_sale(type) && (type != HMT_NB);
}
int hb_machine_can_disarm(hb_machine_type_t type) {
uint8_t hb_machine_can_disarm(hb_machine_type_t type) {
return hb_is_machine_on_sale(type) && (type != HMT_NB);
}
int hb_machine_can_config(hb_machine_type_t type) {
uint8_t hb_machine_can_config(hb_machine_type_t type) {
return hb_is_machine_on_sale(type);
}
int hb_machine_can_arm_stay(hb_machine_type_t type) {
uint8_t hb_machine_can_arm_stay(hb_machine_type_t type) {
return type == HMT_NETMOD || type == HMT_LCD;
}
int hb_machine_can_report_signal_strength(hb_machine_type_t type) {
uint8_t hb_machine_can_report_signal_strength(hb_machine_type_t type) {
return type == HMT_GPRS ||
type == HMT_GPRS_IOT ||
type == HMT_IOT ||
......@@ -203,7 +203,7 @@ int hb_machine_can_report_signal_strength(hb_machine_type_t type) {
type == HMT_WIFI2;
}
int hb_machine_can_report_by_sms(hb_machine_type_t type) {
uint8_t hb_machine_can_report_by_sms(hb_machine_type_t type) {
return type == HMT_GPRS ||
type == HMT_LCD ||
type == HMT_TRUE_COLOR ||
......@@ -211,13 +211,13 @@ int hb_machine_can_report_by_sms(hb_machine_type_t type) {
type == HMT_GPRS_PHONE;
}
int hb_machine_has_wired_zones(hb_machine_type_t type) {
uint8_t hb_machine_has_wired_zones(hb_machine_type_t type) {
return type == HMT_NETMOD ||
type == HMT_TRUE_COLOR ||
type == HMT_THREE_SECTION;
}
ademco_zone_t hb_wired_zone_min(hb_machine_type_t type) {
uint16_t hb_wired_zone_min(hb_machine_type_t type) {
switch (type) {
case HMT_NETMOD:
return 1;
......@@ -230,7 +230,7 @@ ademco_zone_t hb_wired_zone_min(hb_machine_type_t type) {
}
}
ademco_zone_t hb_wired_zone_max(hb_machine_type_t type) {
uint16_t hb_wired_zone_max(hb_machine_type_t type) {
switch (type) {
case HMT_NETMOD:
return 8;
......@@ -243,21 +243,21 @@ ademco_zone_t hb_wired_zone_max(hb_machine_type_t type) {
}
}
int hb_machine_can_write_zone(hb_machine_type_t type) {
uint8_t hb_machine_can_write_zone(hb_machine_type_t type) {
return type == HMT_NETMOD;
}
int hb_machine_can_link_sub_machine(hb_machine_type_t type) {
uint8_t hb_machine_can_link_sub_machine(hb_machine_type_t type) {
return type == HMT_NETMOD;
}
int hb_zone_can_report_lost(hb_zone_property_t zp) {
uint8_t hb_zone_can_report_lost(hb_zone_property_t zp) {
switch (zp) {
case HZP_BUGLAR:
case HZP_BURGLAR:
case HZP_EMERGENCY:
case HZP_DURESS:
case HZP_SUB_MACHINE:
case HZP_BUGLAR_HALF:
case HZP_BURGLAR_HALF:
case HZP_BYPASS:
return 1;
default:
......@@ -265,125 +265,37 @@ int hb_zone_can_report_lost(hb_zone_property_t zp) {
}
}
void hb_machine_timer_one_init(hb_machine_timer_one_t* timer) {
memset(timer, 0xFF, sizeof(*timer));
}
void hb_machine_timer_init(hb_machine_timer_t* timer) {
memset(timer->data, 25, sizeof(timer));
memset(timer->dat, 0xFF, sizeof(*timer));
}
int hb_is_valid_time_point(hb_machine_time_point_t* tp) {
uint8_t hb_is_valid_time_point(hb_machine_time_point_t* tp) {
return tp &&
tp->hour < 24 &&
tp->minute < 60;
}
void hb_time_point_to_greenwich(hb_machine_time_point_t* tp) {
if (tp && tp->hour != 25)
tp->hour = (tp->hour + 16) % 24;
}
void hb_time_point_from_greenwich(hb_machine_time_point_t* tp) {
if (tp && tp->hour != 25)
tp->hour = (tp->hour + 8) % 24;
uint8_t hb_time_point_equal(hb_machine_time_point_t* tp1, hb_machine_time_point_t* tp2) {
return tp1->hour == tp2->hour && tp1->minute == tp2->minute;
}
int hb_is_valid_timer_one(hb_machine_timer_one_t* timer) {
uint8_t hb_is_valid_timer_one(hb_machine_timer_one_t* timer) {
return timer &&
hb_is_valid_time_point(&timer->arm_at) &&
hb_is_valid_time_point(&timer->disarm_at);
hb_is_valid_time_point(&timer->disarm_at) &&
!hb_time_point_equal(&timer->arm_at, &timer->disarm_at);
}
int hb_is_valid_machine_timer(hb_machine_timer_t* timer) {
uint8_t hb_is_valid_machine_timer(hb_machine_timer_t* timer) {
return timer &&
hb_is_valid_timer_one(&timer->timer[0]) &&
hb_is_valid_timer_one(&timer->timer[1]);
}
void hb_machine_timer_to_greenwich(hb_machine_timer_t* timer) {
hb_time_point_to_greenwich(&timer->timer[0].arm_at);
hb_time_point_to_greenwich(&timer->timer[0].disarm_at);
hb_time_point_to_greenwich(&timer->timer[1].arm_at);
hb_time_point_to_greenwich(&timer->timer[1].disarm_at);
}
void hb_machine_timer_from_greenwich(hb_machine_timer_t* timer) {
hb_time_point_from_greenwich(&timer->timer[0].arm_at);
hb_time_point_from_greenwich(&timer->timer[0].disarm_at);
hb_time_point_from_greenwich(&timer->timer[1].arm_at);
hb_time_point_from_greenwich(&timer->timer[1].disarm_at);
}
ademco_event_t hb_machine_status_to_ademco_event(hb_machine_status_t status) {
switch (status) {
#define XX(hms, ae) \
case hms: \
return ae;
HMS_EVENT_MAP(XX)
#undef XX
default:
return EVENT_INVALID_EVENT;
}
}
hb_machine_status_t hb_machine_status_from_ademco_event(ademco_event_t ademco_event) {
switch (ademco_event) {
#define XX(hms, ae) \
case ae: \
return hms;
HMS_EVENT_MAP(XX)
#undef XX
case EVENT_ARM_STAY_1456:
return HMS_ARM_STAY;
case EVENT_ENTER_SET_MODE:
return HMS_SETTING;
default:
return HMS_INVALID;
}
}
ademco_event_t hb_machine_type_to_ademco_event(hb_machine_type_t type) {
switch (type) {
#define XX(hmt, ae) \
case hmt: \
return ae;
HMT_EVENT_MAP(XX)
#undef XX
default:
return EVENT_INVALID_EVENT;
}
}
hb_machine_type_t hb_machine_type_from_ademco_event(ademco_event_t ademco_event) {
switch (ademco_event) {
#define XX(hmt, ae) \
case ae: \
return hmt;
HMT_EVENT_MAP(XX)
#undef XX
default:
return HMT_INVALID;
}
}
ademco_event_t hb_zone_property_to_ademco_event(hb_zone_property_t zp) {
switch (zp) {
#define XX(hzp, ae) \
case hzp: \
return ae;
HZP_EVENT_MAP(XX)
#undef XX
default:
return EVENT_INVALID_EVENT;
}
}
const char* hb_machine_status_to_string(hb_machine_status_t status) {
switch (status) {
#define XX(name, value, str) \
......@@ -422,7 +334,7 @@ const char* hb_zone_property_to_string(hb_zone_property_t zp) {
}
}
#if ADEMCO_ENABLE_CHINESE
#if HB_ENABLE_CHINESE
const char* hb_machine_status_to_string_chinese(hb_machine_status_t status) {
switch (status) {
#define XX(name, value, str) \
......@@ -461,10 +373,10 @@ const char* hb_zone_property_to_string_chinese(hb_zone_property_t zp) {
return "无效属性";
}
}
#endif // ADEMCO_ENABLE_CHINESE
#endif // HB_ENABLE_CHINESE
const char* hb_get_zone_format_str(hb_machine_type_t type) {
ademco_zone_t zone = hb_get_max_zone_by_type(type);
uint16_t zone = hb_get_max_zone_by_type(type);
if (10 < zone && zone < 100)
return "%02d";
else if (zone < 1000)
......
#ifndef __HB_CORE_H__
#define __HB_CORE_H__
#pragma once
#include <stdint.h>
#include "ademco.h"
#include "hb_config.h"
#ifdef __cplusplus
extern "C" {
......@@ -40,7 +40,7 @@ typedef enum hb_machine_status_t {
// valid count
HMS_COUNT = 4,
// invalid
HMS_INVALID = -1,
HMS_INVALID = 0xFF,
} hb_machine_status_t;
// 主机类型表
......@@ -82,12 +82,12 @@ typedef enum hb_machine_type_t {
// valid count
HMT_COUNT = 13,
// invalid
HMT_INVALID = -1,
HMT_INVALID = 0xFF,
} hb_machine_type_t;
// 防区属性表
#define HB_ZONE_PROPERTY_MAP(XX) \
XX(BUGLAR, 0, "匪警全局") \
XX(BURGLAR, 0, "匪警全局") \
XX(EMERGENCY, 1, "匪警紧急") \
XX(FIRE, 2, "火警防区") \
XX(DURESS, 3, "胁迫防区") \
......@@ -95,22 +95,11 @@ typedef enum hb_machine_type_t {
XX(WATER, 5, "淹水防区") \
XX(SUB_MACHINE, 6, "分机") \
XX(REMOTE_CONTROL, 7, "遥控器") \
XX(BUGLAR_HALF, 8, "匪警半局") \
XX(BURGLAR_HALF, 8, "匪警半局") \
XX(SHIELD, 9, "屏蔽防区") \
XX(DOOR_RING, 0x0A, "门铃防区") \
XX(BYPASS, 0x0F, "旁路防区")
// 防区属性与安定宝事件码对照表
#define HZP_EVENT_MAP(XX) \
XX(HZP_BUGLAR, EVENT_BURGLAR) \
XX(HZP_BUGLAR_HALF, EVENT_BURGLAR) \
XX(HZP_EMERGENCY, EVENT_EMERGENCY) \
XX(HZP_FIRE, EVENT_FIRE) \
XX(HZP_DURESS, EVENT_DURESS) \
XX(HZP_GAS, EVENT_GAS) \
XX(HZP_WATER, EVENT_WATER) \
XX(HZP_DOOR_RING, EVENT_DOOR_RING)
// 防区属性
typedef enum hb_zone_property_t {
#define XX(name, value, str) HZP_##name = value,
......@@ -120,14 +109,15 @@ typedef enum hb_zone_property_t {
// valid count
HZP_COUNT = 12,
// invalid
HZP_INVALID = -1,
HZP_INVALID = 0xFF,
} hb_zone_property_t;
typedef struct {
ademco_zone_t zone;
uint16_t zone;
hb_zone_property_t prop;
} hb_zone_and_property_t;
// UTC time, its user's responsibility to convert to local time
typedef struct {
uint8_t hour;
uint8_t minute;
......@@ -140,146 +130,125 @@ typedef struct {
typedef union {
hb_machine_timer_one_t timer[2]; // 2 set of timer
uint8_t data[8];
uint8_t dat[8];
} hb_machine_timer_t;
///////////////////////////// property functions //////////////////////////////
// return available count
// props must have at least HZP_COUNT items
ADEMCO_EXPORT_SYMBOL
size_t hb_get_available_zone_properties_by_type(hb_machine_type_t type,
hb_zone_property_t props[HZP_COUNT]);
HB_EXPORT_SYMBOL
uint8_t hb_get_available_zone_properties_by_type(hb_machine_type_t type,
hb_zone_property_t props[HZP_COUNT]);
// 最大防区号根据型号不同而不同
ADEMCO_EXPORT_SYMBOL
ademco_zone_t hb_get_max_zone_by_type(hb_machine_type_t type);
HB_EXPORT_SYMBOL
uint16_t hb_get_max_zone_by_type(hb_machine_type_t type);
// 防区号是否合法(可以包含0防区)
ADEMCO_EXPORT_SYMBOL
int hb_is_valid_zone_by_type(hb_machine_type_t type, ademco_zone_t zone);
HB_EXPORT_SYMBOL
uint8_t hb_is_valid_zone_by_type(hb_machine_type_t type, uint16_t zone);
// 防区号是否合法(不可以可以包含0防区)
ADEMCO_EXPORT_SYMBOL
int hb_is_valid_zone_by_type_strict(hb_machine_type_t type, ademco_zone_t zone);
HB_EXPORT_SYMBOL
uint8_t hb_is_valid_zone_by_type_strict(hb_machine_type_t type, uint16_t zone);
// 主机是否已投产使用
ADEMCO_EXPORT_SYMBOL
int hb_is_machine_on_sale(hb_machine_type_t type);
HB_EXPORT_SYMBOL
uint8_t hb_is_machine_on_sale(hb_machine_type_t type);
// 主机是否具有离家布防功能
ADEMCO_EXPORT_SYMBOL
int hb_machine_can_arm_away(hb_machine_type_t type);
HB_EXPORT_SYMBOL
uint8_t hb_machine_can_arm_away(hb_machine_type_t type);
// 主机是否具有撤防功能
ADEMCO_EXPORT_SYMBOL
int hb_machine_can_disarm(hb_machine_type_t type);
HB_EXPORT_SYMBOL
uint8_t hb_machine_can_disarm(hb_machine_type_t type);
// 主机是否可以进入设置状态
ADEMCO_EXPORT_SYMBOL
int hb_machine_can_config(hb_machine_type_t type);
HB_EXPORT_SYMBOL
uint8_t hb_machine_can_config(hb_machine_type_t type);
// 主机是否具有留守布防功能
ADEMCO_EXPORT_SYMBOL
int hb_machine_can_arm_stay(hb_machine_type_t type);
HB_EXPORT_SYMBOL
uint8_t hb_machine_can_arm_stay(hb_machine_type_t type);
// 主机是否可以报告信号强度
ADEMCO_EXPORT_SYMBOL
int hb_machine_can_report_signal_strength(hb_machine_type_t type);
HB_EXPORT_SYMBOL
uint8_t hb_machine_can_report_signal_strength(hb_machine_type_t type);
// 主机本身是否可以短信报警(不算通过服务如阿里语音等)
ADEMCO_EXPORT_SYMBOL
int hb_machine_can_report_by_sms(hb_machine_type_t type);
HB_EXPORT_SYMBOL
uint8_t hb_machine_can_report_by_sms(hb_machine_type_t type);
// 主机是否支持有线防区
ADEMCO_EXPORT_SYMBOL
int hb_machine_has_wired_zones(hb_machine_type_t type);
HB_EXPORT_SYMBOL
uint8_t hb_machine_has_wired_zones(hb_machine_type_t type);
// 主机最小有线防区号
ADEMCO_EXPORT_SYMBOL
ademco_zone_t hb_wired_zone_min(hb_machine_type_t type);
HB_EXPORT_SYMBOL
uint16_t hb_wired_zone_min(hb_machine_type_t type);
// 主机最大有线防区号
ADEMCO_EXPORT_SYMBOL
ademco_zone_t hb_wired_zone_max(hb_machine_type_t type);
HB_EXPORT_SYMBOL
uint16_t hb_wired_zone_max(hb_machine_type_t type);
// 主机是否可以直接写入防区数据(无需对码)
ADEMCO_EXPORT_SYMBOL
int hb_machine_can_write_zone(hb_machine_type_t type);
HB_EXPORT_SYMBOL
uint8_t hb_machine_can_write_zone(hb_machine_type_t type);
// 主机是否可以挂载分机
ADEMCO_EXPORT_SYMBOL
int hb_machine_can_link_sub_machine(hb_machine_type_t type);
HB_EXPORT_SYMBOL
uint8_t hb_machine_can_link_sub_machine(hb_machine_type_t type);
// 根据防区属性判断是否支持失联报告
// 失联报告是主机侧实现的跟防区属性没关系,但是人为限制了只有以下属性的才可以设置
ADEMCO_EXPORT_SYMBOL
int hb_zone_can_report_lost(hb_zone_property_t zp);
HB_EXPORT_SYMBOL
uint8_t hb_zone_can_report_lost(hb_zone_property_t zp);
///////////////////////////// timer functions /////////////////////////////////
ADEMCO_EXPORT_SYMBOL
void hb_machine_timer_init(hb_machine_timer_t* timer);
ADEMCO_EXPORT_SYMBOL
int hb_is_valid_time_point(hb_machine_time_point_t* tp);
ADEMCO_EXPORT_SYMBOL
void hb_time_point_to_greenwich(hb_machine_time_point_t* tp);
HB_EXPORT_SYMBOL
void hb_machine_timer_one_init(hb_machine_timer_one_t* timer);
ADEMCO_EXPORT_SYMBOL
void hb_time_point_from_greenwich(hb_machine_time_point_t* tp);
HB_EXPORT_SYMBOL
void hb_machine_timer_init(hb_machine_timer_t* timer);
ADEMCO_EXPORT_SYMBOL
int hb_is_valid_timer_one(hb_machine_timer_one_t* timer);
HB_EXPORT_SYMBOL
uint8_t hb_is_valid_time_point(hb_machine_time_point_t* tp);
ADEMCO_EXPORT_SYMBOL
int hb_is_valid_machine_timer(hb_machine_timer_t* timer);
HB_EXPORT_SYMBOL
uint8_t hb_time_point_equal(hb_machine_time_point_t* tp1, hb_machine_time_point_t* tp2);
// 传输的是格林威治时间
ADEMCO_EXPORT_SYMBOL
void hb_machine_timer_to_greenwich(hb_machine_timer_t* timer);
HB_EXPORT_SYMBOL
uint8_t hb_is_valid_timer_one(hb_machine_timer_one_t* timer);
ADEMCO_EXPORT_SYMBOL
void hb_machine_timer_from_greenwich(hb_machine_timer_t* timer);
HB_EXPORT_SYMBOL
uint8_t hb_is_valid_machine_timer(hb_machine_timer_t* timer);
///////////////////////////// helper functions ////////////////////////////////
ADEMCO_EXPORT_SYMBOL
ademco_event_t hb_machine_status_to_ademco_event(hb_machine_status_t status);
ADEMCO_EXPORT_SYMBOL
hb_machine_status_t hb_machine_status_from_ademco_event(ademco_event_t ademco_event);
ADEMCO_EXPORT_SYMBOL
ademco_event_t hb_machine_type_to_ademco_event(hb_machine_type_t type);
ADEMCO_EXPORT_SYMBOL
hb_machine_type_t hb_machine_type_from_ademco_event(ademco_event_t ademco_event);
ADEMCO_EXPORT_SYMBOL
ademco_event_t hb_zone_property_to_ademco_event(hb_zone_property_t zp);
ADEMCO_EXPORT_SYMBOL
HB_EXPORT_SYMBOL
const char* hb_machine_status_to_string(hb_machine_status_t status);
ADEMCO_EXPORT_SYMBOL
HB_EXPORT_SYMBOL
const char* hb_machine_type_to_string(hb_machine_type_t type);
ADEMCO_EXPORT_SYMBOL
HB_EXPORT_SYMBOL
const char* hb_zone_property_to_string(hb_zone_property_t zp);
#if ADEMCO_ENABLE_CHINESE
ADEMCO_EXPORT_SYMBOL
#if HB_ENABLE_CHINESE
HB_EXPORT_SYMBOL
const char* hb_machine_status_to_string_chinese(hb_machine_status_t status);
ADEMCO_EXPORT_SYMBOL
HB_EXPORT_SYMBOL
const char* hb_machine_type_to_string_chinese(hb_machine_type_t type);
ADEMCO_EXPORT_SYMBOL
HB_EXPORT_SYMBOL
const char* hb_zone_property_to_string_chinese(hb_zone_property_t zp);
#endif // ADEMCO_ENABLE_CHINESE
#endif // HB_ENABLE_CHINESE
ADEMCO_EXPORT_SYMBOL
HB_EXPORT_SYMBOL
const char* hb_get_zone_format_str(hb_machine_type_t type);
#ifdef __cplusplus
......
#include "hb_core_ademco.h"
ademco_event_t hb_machine_status_to_ademco_event(hb_machine_status_t status) {
switch (status) {
#define XX(hms, ae) \
case hms: \
return ae;
HMS_EVENT_MAP(XX)
#undef XX
default:
return EVENT_INVALID_EVENT;
}
}
hb_machine_status_t hb_machine_status_from_ademco_event(ademco_event_t ademco_event) {
switch (ademco_event) {
#define XX(hms, ae) \
case ae: \
return hms;
HMS_EVENT_MAP(XX)
#undef XX
case EVENT_ARM_STAY_1456:
return HMS_ARM_STAY;
case EVENT_ENTER_SET_MODE:
return HMS_SETTING;
default:
return HMS_INVALID;
}
}
ademco_event_t hb_machine_type_to_ademco_event(hb_machine_type_t type) {
switch (type) {
#define XX(hmt, ae) \
case hmt: \
return ae;
HMT_EVENT_MAP(XX)
#undef XX
default:
return EVENT_INVALID_EVENT;
}
}
hb_machine_type_t hb_machine_type_from_ademco_event(ademco_event_t ademco_event) {
switch (ademco_event) {
#define XX(hmt, ae) \
case ae: \
return hmt;
HMT_EVENT_MAP(XX)
#undef XX
default:
return HMT_INVALID;
}
}
ademco_event_t hb_zone_property_to_ademco_event(hb_zone_property_t zp) {
switch (zp) {
#define XX(hzp, ae) \
case hzp: \
return ae;
HZP_EVENT_MAP(XX)
#undef XX
default:
return EVENT_INVALID_EVENT;
}
}
ademco_event_t hb_rf_code_to_ademco_event(uint8_t rf_code) {
switch (rf_code) {
case HB_RF_CODE_ARM:
return EVENT_ARM_AWAY;
case HB_RF_CODE_DISARM:
return EVENT_DISARM;
case HB_RF_CODE_ARM_STAY_OR_CLEAR_ALARM:
return EVENT_ARM_STAY;
case HB_RF_CODE_EMERGENCY:
return EVENT_EMERGENCY;
case HB_RF_CODE_BURGLAR:
return EVENT_BURGLAR;
case HB_RF_CODE_FIRE:
return EVENT_FIRE;
case HB_RF_CODE_DURESS:
return EVENT_DURESS;
case HB_RF_CODE_GAS:
return EVENT_GAS;
case HB_RF_CODE_WATER:
return EVENT_WATER;
case HB_RF_CODE_TAMPER:
return EVENT_TAMPER;
case HB_RF_CODE_S_BATTERY_LOW:
case HB_RF_CODE_R_BATTERY_LOW:
return EVENT_LOW_BATTERY;
case HB_RF_CODE_S_BATTERY_BROKE:
case HB_RF_CODE_R_BATTERY_BROKE:
return EVENT_BAD_BATTERY;
case HB_RF_CODE_BATTERY_RECOVER:
return EVENT_LOW_BATTERY_RECOVER;
case HB_RF_CODE_SOLAR_DISTURB:
return EVENT_SOLAR_DISTURB;
case HB_RF_CODE_SOLAR_RECOVER:
return EVENT_SOLAR_DISTURB_RECOVER;
case HB_RF_CODE_LONGTIME_DISCONN:
return EVENT_DISCONNECT;
case HB_RF_CODE_LONGTIME_RECOVER:
return EVENT_DISCONNECT_RECOVER;
case HB_RF_CODE_DOOR_RING:
return EVENT_DOOR_RING;
case HB_RF_CODE_SM_EXCEPTION:
return EVENT_SUB_MACHINE_SENSOR_EXCEPTION;
case HB_RF_CODE_SM_EXCEPT_RECOVER:
return EVENT_SUB_MACHINE_SENSOR_RECOVER;
case HB_RF_CODE_SM_POWER_EXCEPT:
return EVENT_SUB_MACHINE_POWER_EXCEPTION;
case HB_RF_CODE_SM_POWER_RECOVER:
return EVENT_SUB_MACHINE_POWER_RECOVER;
case HB_RF_CODE_AC_BROKE:
return EVENT_AC_BROKE;
case HB_RF_CODE_AC_RECOVER:
return EVENT_AC_RECOVER;
case HB_RF_CODE_STARTUP:
case HB_RF_CODE_SHUTDOWN:
case HB_RF_CODE_SENDER_REBOOT:
default:
return EVENT_INVALID_EVENT;
}
}
#ifndef __HB_CORE_ADEMCO_H__
#define __HB_CORE_ADEMCO_H__
#include "ademco.h"
#include "hb_core.h"
#include "hb_rf.h"
#ifdef __cplusplus
extern "C" {
#endif
// 防区属性与安定宝事件码对照表
#define HZP_EVENT_MAP(XX) \
XX(HZP_BURGLAR, EVENT_BURGLAR) \
XX(HZP_BURGLAR_HALF, EVENT_BURGLAR) \
XX(HZP_EMERGENCY, EVENT_EMERGENCY) \
XX(HZP_FIRE, EVENT_FIRE) \
XX(HZP_DURESS, EVENT_DURESS) \
XX(HZP_GAS, EVENT_GAS) \
XX(HZP_WATER, EVENT_WATER) \
XX(HZP_DOOR_RING, EVENT_DOOR_RING)
HB_EXPORT_SYMBOL
ademco_event_t hb_machine_status_to_ademco_event(hb_machine_status_t status);
HB_EXPORT_SYMBOL
hb_machine_status_t hb_machine_status_from_ademco_event(ademco_event_t ademco_event);
HB_EXPORT_SYMBOL
ademco_event_t hb_machine_type_to_ademco_event(hb_machine_type_t type);
HB_EXPORT_SYMBOL
hb_machine_type_t hb_machine_type_from_ademco_event(ademco_event_t ademco_event);
HB_EXPORT_SYMBOL
ademco_event_t hb_zone_property_to_ademco_event(hb_zone_property_t zp);
HB_EXPORT_SYMBOL
ademco_event_t hb_rf_code_to_ademco_event(uint8_t rf_code);
#ifdef __cplusplus
}
#endif
#endif /* __HB_CORE_ADEMCO_H__ */
#include "hb_rf.h"
///////////////////////////// RF functions /////////////////////////////////
hb_rf_code_t hb_rf_code_from_u8(uint8_t rf_code) {
switch (rf_code) {
#define XX(_code, name, desc) \
case _code: \
return HB_RF_CODE_##name;
HB_RF_CODE_MAP(XX)
#undef XX
default:
return HB_RF_CODE_INVALID;
}
}
const char* hb_rf_code_to_string(hb_rf_code_t rf_code) {
switch (rf_code) {
#define XX(_code, name, desc) \
case HB_RF_CODE_##name: \
return #name;
HB_RF_CODE_MAP(XX)
#undef XX
default:
return "Unkown hb_rf_code_t";
}
}
#if HB_ENABLE_CHINESE
const char* hb_rf_code_to_string_chinese(hb_rf_code_t rf_code) {
switch (rf_code) {
#define XX(_code, name, desc) \
case HB_RF_CODE_##name: \
return desc;
HB_RF_CODE_MAP(XX)
#undef XX
default:
return "未知无线码";
}
}
#endif /* HB_ENABLE_CHINESE */
#ifndef __HB_RF_H__
#define __HB_RF_H__
#include <stdint.h>
#include "hb_config.h"
#ifdef __cplusplus
extern "C" {
#endif
#define HB_RF_CODE_MAP(XX) \
XX(0x00, BURGLAR, "报警") \
XX(0x01, ARM, "布防") \
XX(0x02, DISARM, "撤防") \
XX(0x04, ARM_STAY_OR_CLEAR_ALARM, "半布防或消警") \
XX(0x08, EMERGENCY, "紧急报警") \
XX(0x20, FIRE, "火警") \
XX(0x30, DURESS, "呼救/挟持") \
XX(0x40, GAS, "煤气") \
XX(0x50, WATER, "水警") \
XX(0x57, NIGHT, "夜间") \
XX(0x69, SENDER_REBOOT, "发送端重启") \
XX(0x75, DAY, "白天") \
XX(0xA5, R_BATTERY_BROKE, "收电池损坏") \
XX(0xA8, DOOR_RING, "门铃") \
XX(0xAB, S_BATTERY_LOW, "发低电") \
XX(0xAC, R_BATTERY_LOW, "收低电") \
XX(0xAD, BATTERY_RECOVER, "复电") \
XX(0xAE, S_BATTERY_BROKE, "发电池损坏") \
XX(0xB0, AC_BROKE, "AC掉电") \
XX(0xB1, AC_RECOVER, "AC恢复") \
XX(0xBA, TAMPER, "防拆") \
XX(0xBB, SLEEP, "电池电压小于3V,终端进入休眠") \
XX(0xBC, LONGTIME_DISCONN, "长时间没有对上") \
XX(0xBD, SOLAR_DISTURB, "强光干扰") \
XX(0xBE, SM_POWER_EXCEPT, "分机产生电源异常") \
XX(0xBF, SM_POWER_RECOVER, "分机恢复电源异常") \
XX(0xCA, STARTUP, "开机") \
XX(0xCB, LONGTIME_RECOVER, "长时间已经对上") \
XX(0xCD, SOLAR_RECOVER, "强光恢复") \
XX(0xCE, SM_EXCEPTION, "分机产生异常信息") \
XX(0xCF, SM_EXCEPT_RECOVER, "分机恢复异常信息") \
XX(0xDD, QUERY, "查询分机状态") \
XX(0xED, SHUTDOWN, "关机")
// 无线命令码
typedef enum hb_rf_code_t {
#define XX(value, name, str) HB_RF_CODE_##name = value,
HB_RF_CODE_MAP(XX)
#undef XX
// 无效命令码
HB_RF_CODE_INVALID = 0xFF,
} hb_rf_code_t;
///////////////////////////// rf functions /////////////////////////////////
HB_EXPORT_SYMBOL hb_rf_code_t hb_rf_code_from_u8(uint8_t rf_code);
HB_EXPORT_SYMBOL const char* hb_rf_code_to_string(hb_rf_code_t rf_code);
#if HB_ENABLE_CHINESE
HB_EXPORT_SYMBOL const char* hb_rf_code_to_string_chinese(hb_rf_code_t rf_code);
#endif
#ifdef __cplusplus
}
#endif
#endif /* __HB_RF_H__ */
......@@ -32,10 +32,10 @@ namespace CSharpDemo
Debug.Assert(pkt.id == ademco_packet_id_t.AID_HB);
Debug.Assert(pkt.seq == 0);
Debug.Assert(pkt.acct == "90219125916578");
Debug.Assert(pkt.data.ademco_id == 0);
Debug.Assert(pkt.data.ademco_event == ademco_event_t.EVENT_I_AM_WIRE);
Debug.Assert(pkt.data.gg == 0);
Debug.Assert(pkt.data.zone == 0);
Debug.Assert(pkt.dat.ademco_id == 0);
Debug.Assert(pkt.dat.ademco_event == ademco_event_t.EVENT_I_AM_WIRE);
Debug.Assert(pkt.dat.gg == 0);
Debug.Assert(pkt.dat.zone == 0);
Console.WriteLine("res={0:D}, commited={1:D}", res, libademco.size_tp_value(cb));
}
......@@ -57,10 +57,10 @@ namespace CSharpDemo
Debug.Assert(pkt.id == ademco_packet_id_t.AID_HB);
Debug.Assert(pkt.seq == 1);
Debug.Assert(pkt.acct == "861234567890");
Debug.Assert(pkt.data.ademco_id == 666666);
Debug.Assert(pkt.data.ademco_event == ademco_event_t.EVENT_ARM_AWAY);
Debug.Assert(pkt.data.gg == 0);
Debug.Assert(pkt.data.zone == 0);
Debug.Assert(pkt.dat.ademco_id == 666666);
Debug.Assert(pkt.dat.ademco_event == ademco_event_t.EVENT_ARM_AWAY);
Debug.Assert(pkt.dat.gg == 0);
Debug.Assert(pkt.dat.zone == 0);
}
// test pack
......@@ -167,14 +167,14 @@ namespace CSharpDemo
case ademco_packet_id_t.AID_ADM_CID:
replyAck(stream, pkt.seq, pkt.acct);
acct = pkt.acct;
ademco_id = pkt.data.ademco_id;
if (libademco.ademco_is_machine_type_event(pkt.data.ademco_event) != 0)
ademco_id = pkt.dat.ademco_id;
if (libademco.ademco_is_machine_type_event(pkt.dat.ademco_event) != 0)
{
type = libademco.hb_machine_type_from_ademco_event(pkt.data.ademco_event);
type = libademco.hb_machine_type_from_ademco_event(pkt.dat.ademco_event);
}
if (libademco.ademco_is_machine_status_event(pkt.data.ademco_event) != 0)
if (libademco.ademco_is_machine_status_event(pkt.dat.ademco_event) != 0)
{
status = libademco.hb_machine_status_from_ademco_event(pkt.data.ademco_event);
status = libademco.hb_machine_status_from_ademco_event(pkt.dat.ademco_event);
}
// 演示如何进行布撤防,真实项目里可以删改本段
......
......@@ -249,10 +249,10 @@ public class JavaDemo {
case AID_HB:
case AID_ADM_CID:
acct = pkt.getAcct();
ademco_id = pkt.getData().getAdemco_id();
ademco_event_t event = pkt.getData().getAdemco_event();
ademco_id = pkt.getDat().getAdemco_id();
ademco_event_t event = pkt.getDat().getAdemco_event();
System.out.println(id() + " event=" + libademco.ademco_event_to_string(event) + " zone="
+ pkt.getData().getZone());
+ pkt.getDat().getZone());
if (libademco.ademco_is_machine_status_event(event) != 0) {
status = libademco.hb_machine_status_from_ademco_event(event);
// 演示如何进行布撤防,真实项目里可以删改本段
......
......@@ -6,6 +6,8 @@
"libademco_wrap.cxx",
"../ademco.c",
"../hb_core.c",
"../hb_core_ademco.c",
"../hb_rf.c",
],
'conditions': [
['OS=="win"', {
......
......@@ -17,7 +17,8 @@
/* Includes the header in the wrapper code */
#include "../ademco_config.h"
#include "../ademco_version.h"
#include "../hb_core.h"
#include "../hb_core_ademco.h"
#include "../hb_rf.h"
%}
#ifdef SWIGJAVA
......@@ -41,5 +42,8 @@ JAVA_ARRAYS_TYPEMAPS(uint8_t, byte, jbyte, Uint8, "[B")
%include "../ademco_config.h"
%include "../ademco_version.h"
%include "../ademco.h"
%include "../hb_config.h"
%include "../hb_core.h"
%include "../hb_core_ademco.h"
%include "../hb_rf.h"
......@@ -4,7 +4,7 @@ mkdir -p com/hb3344/ademco
swig -java -package com.hb3344.ademco -outdir com/hb3344/ademco -o libademco_java_wrap.c libademco.swig
JAVA_INCLUDE=${JAVA_HOME}/include
JAVA_INCLUDE_OS=${JAVA_INCLUDE}/linux
cc -std=c99 -fpic -c ../ademco.c ../hb_core.c libademco_java_wrap.c -I"../" -I${JAVA_INCLUDE} -I${JAVA_INCLUDE_OS}
ld -shared ademco.o hb_core.o libademco_java_wrap.o -o libademco_java.so
cc -std=c99 -fpic -c ../ademco.c ../hb_core.c ../hb_core_ademco.c ../hb_rf.c libademco_java_wrap.c -I"../" -I${JAVA_INCLUDE} -I${JAVA_INCLUDE_OS}
ld -shared ademco.o hb_core.o hb_core_ademco.o hb_rf.o libademco_java_wrap.o -o libademco_java.so
javac JavaDemo.java
# java -Djava.library.path=./ JavaDemo
\ No newline at end of file
......@@ -5,7 +5,7 @@ mkdir -p com/hb3344/ademco
/usr/local/bin/swig -java -package com.hb3344.ademco -outdir com/hb3344/ademco -o libademco_java_wrap.c libademco.swig
JAVA_INCLUDE=${JAVA_HOME}/include
JAVA_INCLUDE_OS=${JAVA_INCLUDE}/darwin
gcc -fpic -c ../ademco.c ../hb_core.c libademco_java_wrap.c -I"../" -I${JAVA_INCLUDE} -I${JAVA_INCLUDE_OS}
gcc -shared ademco.o hb_core.o libademco_java_wrap.o -o libademco_java.dylib
gcc -fpic -c ../ademco.c ../hb_core.c ../hb_core_ademco.c ../hb_rf.c libademco_java_wrap.c -I"../" -I${JAVA_INCLUDE} -I${JAVA_INCLUDE_OS}
gcc -shared ademco.o hb_core.o hb_core_ademco.o hb_rf.o libademco_java_wrap.o -o libademco_java.dylib
javac JavaDemo.java
# java -Djava.library.path=./ JavaDemo
......@@ -20,10 +20,10 @@ function test_parse() {
assert.strictEqual(pkt.id, libademco.AID_HB);
assert.strictEqual(pkt.seq, 0);
assert.strictEqual(pkt.acct, "90219125916578");
assert.strictEqual(pkt.data.ademco_id, 0);
assert.strictEqual(pkt.data.ademco_event, libademco.EVENT_I_AM_WIRE);
assert.strictEqual(pkt.data.gg, 0);
assert.strictEqual(pkt.data.zone, 0);
assert.strictEqual(pkt.dat.ademco_id, 0);
assert.strictEqual(pkt.dat.ademco_event, libademco.EVENT_I_AM_WIRE);
assert.strictEqual(pkt.dat.gg, 0);
assert.strictEqual(pkt.dat.zone, 0);
console.log("res=%d, commited=%d", res, libademco.size_tp_value(cb));
}
......@@ -43,10 +43,10 @@ function test_pack() {
assert.strictEqual(pkt2.id, libademco.AID_HB);
assert.strictEqual(pkt2.seq, 1);
assert.strictEqual(pkt2.acct, "861234567890");
assert.strictEqual(pkt2.data.ademco_id, 666666);
assert.strictEqual(pkt2.data.ademco_event, libademco.EVENT_ARM_AWAY);
assert.strictEqual(pkt2.data.gg, 0);
assert.strictEqual(pkt2.data.zone, 0);
assert.strictEqual(pkt2.dat.ademco_id, 666666);
assert.strictEqual(pkt2.dat.ademco_event, libademco.EVENT_ARM_AWAY);
assert.strictEqual(pkt2.dat.gg, 0);
assert.strictEqual(pkt2.dat.zone, 0);
}
class AlarmHost {
......
mkdir com\hb3344\ademco
"E:\local_program\swig\swigwin-4.1.1\swig.exe" -csharp -namespace com.hb3344.ademco -outdir com/hb3344/ademco -o libademco_csharp_wrap.c libademco.swig
cl -c ../ademco.c ../hb_core.c libademco_csharp_wrap.c -I"../" /source-charset:utf-8
cl -LD ademco.obj hb_core.obj libademco_csharp_wrap.obj -o libademco.dll
cl -c ../ademco.c ../hb_core.c ../hb_core_ademco.c ../hb_rf.c libademco_csharp_wrap.c -I"../" /source-charset:utf-8
cl -LD ademco.obj hb_core.obj hb_core_ademco.obj hb_rf.obj libademco_csharp_wrap.obj -o libademco.dll
csc CSharpDemo.cs -recurse:com/hb3344/ademco/*.cs
rem CSharpDemo.exe
mkdir com\hb3344\ademco
"E:\local_program\swig\swigwin-4.1.1\swig.exe" -java -package com.hb3344.ademco -outdir com/hb3344/ademco -o libademco_java_wrap.c libademco.swig
cl -c ../ademco.c ../hb_core.c libademco_java_wrap.c -I"../" -I"%JAVA_HOME%include" -I"%JAVA_HOME%include/win32" /source-charset:utf-8
cl -LD ademco.obj hb_core.obj libademco_java_wrap.obj -o ademco_java.dll
cl -c ../ademco.c ../hb_core.c ../hb_core_ademco.c ../hb_rf.c libademco_java_wrap.c -I"../" -I"%JAVA_HOME%include" -I"%JAVA_HOME%include/win32" /source-charset:utf-8
cl -LD ademco.obj hb_core.obj hb_core_ademco.obj hb_rf.obj libademco_java_wrap.obj -o ademco_java.dll
javac -encoding utf-8 JavaDemo.java
rem java JavaDemo
......@@ -9,9 +9,14 @@ repo=/h/dev_hb/libhb/libhb
cp -f ${repo}/ademco.h ../
cp -f ${repo}/ademco.c ../
cp -f ${repo}/hb_core.h ../
cp -f ${repo}/hb_core.c ../
cp -f ${repo}/ademco_version.h ../
cp -f ${repo}/ademco_config.h ../
cp -f ${repo}/hb_config.h ../
cp -f ${repo}/hb_core.h ../
cp -f ${repo}/hb_core.c ../
cp -f ${repo}/hb_core_ademco.h ../
cp -f ${repo}/hb_core_ademco.c ../
cp -f ${repo}/hb_rf.c ../
cp -f ${repo}/hb_rf.h ../
cp -f ${repo}/CHANGELOG.md ../
sed -i '/\[hb\]/d' ../CHANGELOG.md
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment