1215 lines
36 KiB
C
1215 lines
36 KiB
C
/**************************************************************************************************
|
|
Filename: irda_decode.c
|
|
Revised: Date: 2016-10-01
|
|
Revision: Revision: 1.0
|
|
|
|
Description: This file provides algorithms for IR decode (status type)
|
|
|
|
Revision log:
|
|
* 2016-10-01: created by strawmanbobi
|
|
**************************************************************************************************/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include "include/irda_decode.h"
|
|
#include "include/irda_utils.h"
|
|
#include "include/irda_ac_parse_frame_parameter.h"
|
|
#include "include/irda_ac_parse_parameter.h"
|
|
#include "include/irda_ac_parse_forbidden_info.h"
|
|
#include "include/irda_ac_build_frame.h"
|
|
#include "include/irda_ac_apply.h"
|
|
#include "include/irda_tv_parse_protocol.h"
|
|
|
|
struct ir_bin_buffer binaryfile;
|
|
struct ir_bin_buffer *pirda_buffer = &binaryfile;
|
|
struct tag_head *tags;
|
|
|
|
// IRDA hex code
|
|
UINT8* ir_hex_code = NULL;
|
|
UINT8 ir_hex_len = 0;
|
|
|
|
// tv raw code length
|
|
UINT16 tv_bin_length = 0;
|
|
|
|
// global output buffer
|
|
UINT8 tag_count = 0;
|
|
UINT16 tag_head_offset = 0;
|
|
|
|
UINT8 byteArray[PROTOCOL_SIZE] = {0};
|
|
UINT16 user_data[USER_DATA_SIZE] = {0};
|
|
UINT8 tv_bin[EXPECTED_MEM_SIZE] = {0};
|
|
remote_ac_status_t ac_status;
|
|
|
|
// 2016-10-09 updated by strawmanbobi, change global data context to array pointer
|
|
protocol *context = (protocol *) byteArray;
|
|
|
|
// ban function table
|
|
// fixed swing should not be counted in case of AC
|
|
INT8 apply_power(remote_ac_status_t ac_status, UINT8 function_code);
|
|
INT8 apply_mode(remote_ac_status_t ac_status, UINT8 function_code);
|
|
INT8 apply_wind_speed(remote_ac_status_t ac_status, UINT8 function_code);
|
|
INT8 apply_swing(remote_ac_status_t ac_status, UINT8 function_code);
|
|
INT8 apply_temperature(remote_ac_status_t ac_status, UINT8 function_code);
|
|
|
|
lp_apply_ac_parameter apply_table[AC_APPLY_MAX] =
|
|
{
|
|
apply_power,
|
|
apply_mode,
|
|
apply_temperature,
|
|
apply_temperature,
|
|
apply_wind_speed,
|
|
apply_swing,
|
|
apply_swing
|
|
};
|
|
|
|
const UINT16 tag_index[TAG_COUNT_FOR_PROTOCOL] =
|
|
{
|
|
1, 2, 3, 4, 5, 6, 7,
|
|
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
|
|
41, 42, 43, 44, 45, 46, 47, 48
|
|
};
|
|
|
|
#if defined BOARD_PC
|
|
void free_pirda(void);
|
|
#endif
|
|
|
|
///////////////////////////////////////////////// AC Begin /////////////////////////////////////////////////
|
|
|
|
INT8 binary_parse_offset()
|
|
{
|
|
int i = 0;
|
|
UINT16 *phead = (UINT16 *) &pirda_buffer->data[1];
|
|
|
|
tag_count = pirda_buffer->data[0];
|
|
if(TAG_COUNT_FOR_PROTOCOL != tag_count)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
|
|
tag_head_offset = (tag_count << 1) + 1;
|
|
|
|
tags = (t_tag_head *) irda_malloc(tag_count * sizeof(t_tag_head));
|
|
if (NULL == tags)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
|
|
for (i = 0; i < tag_count; i++)
|
|
{
|
|
tags[i].tag = tag_index[i];
|
|
tags[i].offset = *(phead + i);
|
|
if (tags[i].offset == TAG_INVALID)
|
|
{
|
|
tags[i].len = 0;
|
|
}
|
|
}
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
INT8 binary_parse_len()
|
|
{
|
|
UINT16 i = 0, j = 0;
|
|
for (i = 0; i < (tag_count - 1); i++)
|
|
{
|
|
if (tags[i].offset == TAG_INVALID)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
for (j = (i + 1); j < tag_count; j++)
|
|
{
|
|
if (tags[j].offset != TAG_INVALID)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if (j < tag_count)
|
|
{
|
|
tags[i].len = tags[j].offset - tags[i].offset;
|
|
}
|
|
else
|
|
{
|
|
tags[i].len = pirda_buffer->len - tags[i].offset - tag_head_offset;
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
}
|
|
if (tags[tag_count - 1].offset != TAG_INVALID)
|
|
{
|
|
tags[tag_count - 1].len = pirda_buffer->len - tag_head_offset - tags[tag_count - 1].offset;
|
|
}
|
|
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
void binary_tags_info()
|
|
{
|
|
UINT16 i = 0;
|
|
for (i = 0; i < tag_count; i++)
|
|
{
|
|
if (tags[i].len == 0)
|
|
{
|
|
continue;
|
|
}
|
|
IR_PRINTF("tag(%d).len = %d\n", tags[i].tag, tags[i].len);
|
|
}
|
|
}
|
|
|
|
INT8 binary_parse_data()
|
|
{
|
|
UINT16 i = 0;
|
|
for (i = 0; i < tag_count; i++)
|
|
{
|
|
tags[i].pdata = pirda_buffer->data + tags[i].offset + tag_head_offset;
|
|
}
|
|
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
INT8 free_ac_context()
|
|
{
|
|
UINT16 i = 0;
|
|
|
|
if (ir_hex_code != NULL)
|
|
{
|
|
irda_free(ir_hex_code);
|
|
ir_hex_code = NULL;
|
|
}
|
|
ir_hex_len = 0;
|
|
|
|
if (context->default_code.data != NULL)
|
|
{
|
|
irda_free(context->default_code.data);
|
|
context->default_code.data = NULL;
|
|
context->default_code.len = 0;
|
|
}
|
|
|
|
for (i = 0; i < AC_POWER_MAX; i++)
|
|
{
|
|
if (context->power1.comp_data[i].segment != NULL)
|
|
{
|
|
irda_free(context->power1.comp_data[i].segment);
|
|
context->power1.comp_data[i].segment = NULL;
|
|
context->power1.comp_data[i].seg_len = 0;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < AC_TEMP_MAX; i++)
|
|
{
|
|
if (context->temp1.comp_data[i].segment != NULL)
|
|
{
|
|
irda_free(context->temp1.comp_data[i].segment);
|
|
context->temp1.comp_data[i].segment = NULL;
|
|
context->temp1.comp_data[i].seg_len = 0;
|
|
}
|
|
if (context->temp2.comp_data[i].segment != NULL)
|
|
{
|
|
irda_free(context->temp2.comp_data[i].segment);
|
|
context->temp2.comp_data[i].segment = NULL;
|
|
context->temp2.comp_data[i].seg_len = 0;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < AC_MODE_MAX; i++)
|
|
{
|
|
if (context->mode1.comp_data[i].segment != NULL)
|
|
{
|
|
irda_free(context->mode1.comp_data[i].segment);
|
|
context->mode1.comp_data[i].segment = NULL;
|
|
context->mode1.comp_data[i].seg_len = 0;
|
|
}
|
|
if (context->mode2.comp_data[i].segment != NULL)
|
|
{
|
|
irda_free(context->mode2.comp_data[i].segment);
|
|
context->mode2.comp_data[i].segment = NULL;
|
|
context->mode2.comp_data[i].seg_len = 0;
|
|
}
|
|
}
|
|
for (i = 0; i < AC_WS_MAX; i++)
|
|
{
|
|
if (context->speed1.comp_data[i].segment != NULL)
|
|
{
|
|
irda_free(context->speed1.comp_data[i].segment);
|
|
context->speed1.comp_data[i].segment = NULL;
|
|
context->speed1.comp_data[i].seg_len = 0;
|
|
}
|
|
if (context->speed2.comp_data[i].segment != NULL)
|
|
{
|
|
irda_free(context->speed2.comp_data[i].segment);
|
|
context->speed2.comp_data[i].segment = NULL;
|
|
context->speed2.comp_data[i].seg_len = 0;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < context->si.mode_count; i++)
|
|
{
|
|
if (context->swing1.comp_data != NULL &&
|
|
context->swing1.comp_data[i].segment != NULL)
|
|
{
|
|
irda_free(context->swing1.comp_data[i].segment);
|
|
context->swing1.comp_data[i].segment = NULL;
|
|
context->swing1.comp_data[i].seg_len = 0;
|
|
}
|
|
if (context->swing2.comp_data != NULL &&
|
|
context->swing2.comp_data[i].segment != NULL)
|
|
{
|
|
irda_free(context->swing2.comp_data[i].segment);
|
|
context->swing2.comp_data[i].segment = NULL;
|
|
context->swing2.comp_data[i].seg_len = 0;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < AC_FUNCTION_MAX - 1; i++)
|
|
{
|
|
if (context->function1.comp_data[i].segment != NULL)
|
|
{
|
|
irda_free(context->function1.comp_data[i].segment);
|
|
context->function1.comp_data[i].segment = NULL;
|
|
context->function1.comp_data[i].seg_len = 0;
|
|
}
|
|
if (context->function2.comp_data[i].segment != NULL)
|
|
{
|
|
irda_free(context->function2.comp_data[i].segment);
|
|
context->function2.comp_data[i].segment = NULL;
|
|
context->function2.comp_data[i].seg_len = 0;
|
|
}
|
|
}
|
|
|
|
// free composite data for swing1 and swing 2
|
|
if(context->swing1.comp_data != NULL)
|
|
{
|
|
irda_free(context->swing1.comp_data);
|
|
context->swing1.comp_data = NULL;
|
|
}
|
|
if(context->swing2.comp_data != NULL)
|
|
{
|
|
irda_free(context->swing2.comp_data);
|
|
context->swing2.comp_data = NULL;
|
|
}
|
|
|
|
for(i = 0; i < context->checksum.count; i++)
|
|
{
|
|
if(context->checksum.checksum_data != NULL &&
|
|
context->checksum.checksum_data[i].spec_pos != NULL)
|
|
{
|
|
irda_free(context->checksum.checksum_data[i].spec_pos);
|
|
context->checksum.checksum_data[i].len = 0;
|
|
context->checksum.checksum_data[i].spec_pos = NULL;
|
|
}
|
|
}
|
|
if(context->checksum.checksum_data != NULL)
|
|
{
|
|
irda_free(context->checksum.checksum_data);
|
|
context->checksum.checksum_data = NULL;
|
|
}
|
|
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
INT8 irda_ac_lib_open(UINT8 *binary, UINT16 binary_length)
|
|
{
|
|
// it is recommended that the parameter binary pointing to
|
|
// a global memory block in embedded platform environment
|
|
pirda_buffer->data = binary;
|
|
pirda_buffer->len = binary_length;
|
|
pirda_buffer->offset = 0;
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
INT8 irda_context_init()
|
|
{
|
|
irda_memset(context, 0, sizeof(protocol));
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
INT8 irda_ac_lib_parse()
|
|
{
|
|
UINT16 i = 0;
|
|
// suggest not to call init function here for de-couple purpose
|
|
irda_context_init();
|
|
|
|
if (IR_DECODE_FAILED == binary_parse_offset())
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
|
|
if (IR_DECODE_FAILED == binary_parse_len())
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
|
|
if (IR_DECODE_FAILED == binary_parse_data())
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
|
|
binary_tags_info();
|
|
|
|
context->endian = 0;
|
|
context->lastbit = 0;
|
|
context->repeat_times = 1;
|
|
|
|
for (i = 0; i < N_MODE_MAX; i++)
|
|
{
|
|
context->n_mode[i].enable = TRUE;
|
|
context->n_mode[i].allspeed = FALSE;
|
|
context->n_mode[i].alltemp = FALSE;
|
|
irda_memset(context->n_mode[i].speed, 0x00, AC_WS_MAX);
|
|
context->n_mode[i].speed_cnt = 0;
|
|
irda_memset(context->n_mode[i].temp, 0x00, AC_TEMP_MAX);
|
|
context->n_mode[i].temp_cnt = 0;
|
|
}
|
|
|
|
// parse TAG 46 in first priority
|
|
for (i = 0; i < tag_count; i++)
|
|
{
|
|
if (tags[i].tag == TAG_AC_SWING_INFO)
|
|
{
|
|
if (tags[i].len != 0)
|
|
{
|
|
parse_swing_info(&tags[i], &(context->si));
|
|
}
|
|
else
|
|
{
|
|
context->si.type = SWING_TYPE_NORMAL;
|
|
context->si.mode_count = 2;
|
|
}
|
|
context->si.dir_index = 0;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < tag_count; i++)
|
|
{
|
|
if (tags[i].len == 0)
|
|
{
|
|
continue;
|
|
}
|
|
// then parse TAG 26 or 33
|
|
if (context->si.type == SWING_TYPE_NORMAL)
|
|
{
|
|
UINT16 swing_space_size = 0;
|
|
if (tags[i].tag == TAG_AC_SWING_1)
|
|
{
|
|
IR_PRINTF("\nparse swing 1\n");
|
|
context->swing1.count = context->si.mode_count;
|
|
context->swing1.len = tags[i].len >> 1;
|
|
swing_space_size = sizeof(tag_comp) * context->si.mode_count;
|
|
context->swing1.comp_data = (tag_comp*) irda_malloc(swing_space_size);
|
|
if (NULL == context->swing1.comp_data)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
|
|
irda_memset(context->swing1.comp_data, 0x00, swing_space_size);
|
|
if (IR_DECODE_FAILED == parse_common_ac_parameter(&tags[i],
|
|
context->swing1.comp_data,
|
|
context->si.mode_count,
|
|
AC_PARAMETER_TYPE_1))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_SWING_2)
|
|
{
|
|
IR_PRINTF("\nparse swing 2\n");
|
|
context->swing2.count = context->si.mode_count;
|
|
context->swing2.len = tags[i].len >> 1;
|
|
swing_space_size = sizeof(tag_comp) * context->si.mode_count;
|
|
context->swing2.comp_data = (tag_comp*) irda_malloc(swing_space_size);
|
|
if (NULL == context->swing2.comp_data)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
irda_memset(context->swing2.comp_data, 0x00, swing_space_size);
|
|
if (IR_DECODE_FAILED == parse_common_ac_parameter(&tags[i],
|
|
context->swing2.comp_data,
|
|
context->si.mode_count,
|
|
AC_PARAMETER_TYPE_2))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (tags[i].tag == TAG_AC_DEFAULT_CODE) // default code TAG
|
|
{
|
|
IR_PRINTF("\nparse default\n");
|
|
context->default_code.data = (UINT8 *) irda_malloc((tags[i].len - 2) >> 1);
|
|
if (NULL == context->default_code.data)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
if (IR_DECODE_FAILED == parse_defaultcode(&tags[i], &(context->default_code)))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_POWER_1) // power tag
|
|
{
|
|
IR_PRINTF("\nparse power 1\n");
|
|
context->power1.len = tags[i].len >> 1;
|
|
if (IR_DECODE_FAILED == parse_common_ac_parameter(&tags[i],
|
|
context->power1.comp_data,
|
|
AC_POWER_MAX,
|
|
AC_PARAMETER_TYPE_1))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_TEMP_1) // temperature tag type 1
|
|
{
|
|
IR_PRINTF("\nparse temperature 1\n");
|
|
if (IR_DECODE_FAILED == parse_temp_1(&tags[i], &(context->temp1)))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_MODE_1) // mode tag
|
|
{
|
|
IR_PRINTF("\nparse mode 1\n");
|
|
context->mode1.len = tags[i].len >> 1;
|
|
if (IR_DECODE_FAILED == parse_common_ac_parameter(&tags[i],
|
|
context->mode1.comp_data,
|
|
AC_MODE_MAX,
|
|
AC_PARAMETER_TYPE_1))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_SPEED_1) // wind speed tag
|
|
{
|
|
IR_PRINTF("\nparse speed 1\n");
|
|
context->speed1.len = tags[i].len >> 1;
|
|
if (IR_DECODE_FAILED == parse_common_ac_parameter(&tags[i],
|
|
context->speed1.comp_data,
|
|
AC_WS_MAX,
|
|
AC_PARAMETER_TYPE_1))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_CHECKSUM_TYPE)
|
|
{
|
|
IR_PRINTF("\nparse checksum\n");
|
|
if (IR_DECODE_FAILED == parse_checksum(&tags[i], &(context->checksum)))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_MODE_2)
|
|
{
|
|
IR_PRINTF("\nparse mode 2\n");
|
|
context->mode2.len = tags[i].len >> 1;
|
|
if (IR_DECODE_FAILED ==
|
|
parse_common_ac_parameter(&tags[i],
|
|
context->mode2.comp_data, AC_MODE_MAX, AC_PARAMETER_TYPE_1))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_SPEED_2)
|
|
{
|
|
IR_PRINTF("\nparse speed 2\n");
|
|
context->speed2.len = tags[i].len >> 1;
|
|
if (IR_DECODE_FAILED ==
|
|
parse_common_ac_parameter(&tags[i],
|
|
context->speed2.comp_data, AC_WS_MAX, AC_PARAMETER_TYPE_1))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_TEMP_2)
|
|
{
|
|
IR_PRINTF("\nparse temperature 2\n");
|
|
if (IR_DECODE_FAILED == parse_temp_2(&tags[i], &(context->temp2)))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_SOLO_FUNCTION)
|
|
{
|
|
IR_PRINTF("\nparse solo functions\n");
|
|
if (IR_DECODE_FAILED == parse_solo_code(&tags[i], &(context->sc)))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
context->solo_function_mark = 1;
|
|
}
|
|
else if (tags[i].tag == TAG_AC_FUNCTION_1)
|
|
{
|
|
if (IR_DECODE_FAILED == parse_function_1_tag29(&tags[i], &(context->function1)))
|
|
{
|
|
IR_PRINTF("\nfunction code parse error\n");
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_FUNCTION_2)
|
|
{
|
|
IR_PRINTF("\nparse function 2\n");
|
|
if (IR_DECODE_FAILED == parse_function_2_tag34(&tags[i], &(context->function2)))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_FRAME_LENGTH)
|
|
{
|
|
if (IR_DECODE_FAILED == parse_framelen(&tags[i], tags[i].len))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_ZERO)
|
|
{
|
|
if (IR_DECODE_FAILED == parse_zero(&tags[i]))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_ONE)
|
|
{
|
|
if (IR_DECODE_FAILED == parse_one(&tags[i]))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_BOOT_CODE)
|
|
{
|
|
if (IR_DECODE_FAILED == parse_bootcode(&tags[i]))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_REPEAT_TIMES)
|
|
{
|
|
if (IR_DECODE_FAILED == parse_repeat_times(&tags[i]))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_BITNUM)
|
|
{
|
|
if (IR_DECODE_FAILED == parse_bitnum(&tags[i]))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_ENDIAN)
|
|
{
|
|
if (IR_DECODE_FAILED == parse_endian(&tags[i]))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_BAN_FUNCTION_IN_COOL_MODE)
|
|
{
|
|
if (IR_DECODE_FAILED == parse_nmode(&tags[i], N_COOL))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_BAN_FUNCTION_IN_HEAT_MODE)
|
|
{
|
|
if (IR_DECODE_FAILED == parse_nmode(&tags[i], N_HEAT))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_BAN_FUNCTION_IN_AUTO_MODE)
|
|
{
|
|
if (IR_DECODE_FAILED == parse_nmode(&tags[i], N_AUTO))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_BAN_FUNCTION_IN_FAN_MODE)
|
|
{
|
|
if (IR_DECODE_FAILED == parse_nmode(&tags[i], N_FAN))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
else if (tags[i].tag == TAG_AC_BAN_FUNCTION_IN_DRY_MODE)
|
|
{
|
|
if (IR_DECODE_FAILED == parse_nmode(&tags[i], N_DRY))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
}
|
|
|
|
for(i = 0 ; i < tag_count; i++)
|
|
{
|
|
if(tags[i].len == 0)
|
|
{
|
|
continue;
|
|
}
|
|
if (tags[i].tag == TAG_AC_DELAY_CODE)
|
|
{
|
|
if (IR_DECODE_FAILED == parse_delaycode(&tags[i]))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
if (tags[i].tag == TAG_AC_LASTBIT)
|
|
{
|
|
if (IR_DECODE_FAILED == parse_lastbit(&tags[i]))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(NULL != tags)
|
|
{
|
|
irda_free(tags);
|
|
tags = NULL;
|
|
}
|
|
|
|
ir_hex_code = (UINT8 *) irda_malloc(context->default_code.len);
|
|
if(NULL == ir_hex_code)
|
|
{
|
|
// warning: this AC bin contains no default code
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
|
|
ir_hex_len = context->default_code.len;
|
|
irda_memset(ir_hex_code, 0x00, ir_hex_len);
|
|
|
|
// pre-calculate solo function status after parse phase
|
|
if (1 == context->solo_function_mark)
|
|
{
|
|
context->solo_function_mark = 0x00;
|
|
// bit order from right to left : power, mode, temp+, temp-, wind_speed, swing, fix
|
|
for (i = AC_FUNCTION_POWER; i < AC_FUNCTION_MAX; i++)
|
|
{
|
|
if (isin(context->sc.solo_function_codes, i, context->sc.solo_func_count))
|
|
{
|
|
context->solo_function_mark |= (1 << (i - 1));
|
|
}
|
|
}
|
|
}
|
|
|
|
// it is strongly recommended that we free pirda_buffer
|
|
// or make global buffer shared in extreme memory case
|
|
/* in case of running with test - begin */
|
|
#if defined BOARD_PC
|
|
free_pirda();
|
|
#endif
|
|
/* in case of running with test - end */
|
|
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
#if defined BOARD_PC
|
|
void free_pirda(void)
|
|
{
|
|
irda_free(pirda_buffer->data);
|
|
pirda_buffer->len = 0;
|
|
pirda_buffer->offset = 0;
|
|
}
|
|
#endif
|
|
|
|
BOOL is_solo_function(UINT8 function_code)
|
|
{
|
|
return (((context->solo_function_mark >> (function_code - 1)) & 0x01) == 0x01) ? TRUE : FALSE;
|
|
}
|
|
|
|
UINT8 has_function(struct ac_protocol *protocol, UINT8 function)
|
|
{
|
|
if (0 != protocol->function1.len)
|
|
{
|
|
if(0 != protocol->function1.comp_data[function - 1].seg_len)
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
if(0 != protocol->function2.len)
|
|
{
|
|
if(0 != protocol->function2.comp_data[function - 1].seg_len)
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
INT8 apply_power(remote_ac_status_t ac_status, UINT8 function_code)
|
|
{
|
|
apply_ac_power(context, ac_status.acPower);
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
INT8 apply_mode(remote_ac_status_t ac_status, UINT8 function_code)
|
|
{
|
|
if (IR_DECODE_FAILED == apply_ac_mode(context, ac_status.acMode))
|
|
{
|
|
// do not implement this mechanism since mode, temperature, wind
|
|
// speed would have unspecified function
|
|
//if(FALSE == has_function(context, AC_FUNCTION_MODE))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
INT8 apply_wind_speed(remote_ac_status_t ac_status, UINT8 function_code)
|
|
{
|
|
if (FALSE == context->n_mode[ac_status.acMode].allspeed)
|
|
{
|
|
// if this level is not in black list
|
|
if(!isin(context->n_mode[ac_status.acMode].speed,
|
|
ac_status.acWindSpeed,
|
|
context->n_mode[ac_status.acMode].speed_cnt))
|
|
{
|
|
if(IR_DECODE_FAILED == apply_ac_wind_speed(context, ac_status.acWindSpeed) &&
|
|
function_code == AC_FUNCTION_WIND_SPEED)
|
|
{
|
|
// do not implement this mechanism since mode, temperature, wind
|
|
// speed would have unspecified function
|
|
//if(FALSE == has_function(context, AC_FUNCTION_WIND_SPEED))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// if this level is in black list, do not send IR wave if user want to apply this function
|
|
if(function_code == AC_FUNCTION_WIND_SPEED)
|
|
{
|
|
// do not implement this mechanism since mode, temperature, wind
|
|
// speed would have unspecified function
|
|
//if(FALSE == has_function(context, AC_FUNCTION_WIND_SPEED))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// if this level is in black list, do not send IR wave if user want to apply this function
|
|
if(function_code == AC_FUNCTION_WIND_SPEED)
|
|
{
|
|
// do not implement this mechanism since mode, temperature, wind
|
|
// speed would have unspecified function
|
|
//if(FALSE == has_function(context, AC_FUNCTION_WIND_SPEED))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
}
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
INT8 apply_swing(remote_ac_status_t ac_status, UINT8 function_code)
|
|
{
|
|
if(function_code == AC_FUNCTION_WIND_FIX)
|
|
{
|
|
// adjust fixed wind direction according to current status
|
|
if(context->si.type == SWING_TYPE_NORMAL && context->si.mode_count > 1)
|
|
{
|
|
if (TRUE == context->change_wind_direction)
|
|
{
|
|
context->si.dir_index++;
|
|
}
|
|
|
|
if(context->si.dir_index == context->si.mode_count)
|
|
{
|
|
// reset dir index
|
|
context->si.dir_index = 1;
|
|
}
|
|
context->swing_status = context->si.dir_index;
|
|
}
|
|
}
|
|
else if(function_code == AC_FUNCTION_WIND_SWING)
|
|
{
|
|
context->swing_status = 0;
|
|
}
|
|
else
|
|
{
|
|
// do nothing
|
|
}
|
|
|
|
if(IR_DECODE_FAILED == apply_ac_swing(context, context->swing_status))
|
|
{
|
|
if(function_code == AC_FUNCTION_WIND_SWING && FALSE == has_function(context, AC_FUNCTION_WIND_SWING))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
else if(function_code == AC_FUNCTION_WIND_FIX && FALSE == has_function(context, AC_FUNCTION_WIND_FIX))
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
INT8 apply_temperature(remote_ac_status_t ac_status, UINT8 function_code)
|
|
{
|
|
if (FALSE == context->n_mode[ac_status.acMode].alltemp)
|
|
{
|
|
if(!isin(context->n_mode[ac_status.acMode].temp,
|
|
ac_status.acTemp,
|
|
context->n_mode[ac_status.acMode].temp_cnt))
|
|
{
|
|
if(IR_DECODE_FAILED == apply_ac_temperature(context, ac_status.acTemp))
|
|
{
|
|
if(function_code == AC_FUNCTION_TEMPERATURE_UP
|
|
/*&& FALSE == has_function(context, AC_FUNCTION_TEMPERATURE_UP)*/)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
else if(function_code == AC_FUNCTION_TEMPERATURE_DOWN
|
|
/*&& FALSE == has_function(context, AC_FUNCTION_TEMPERATURE_DOWN)*/)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// if this level is in black list, do not send IR wave if user want to apply this function
|
|
if(function_code == AC_FUNCTION_TEMPERATURE_UP
|
|
/*&& FALSE == has_function(context, AC_FUNCTION_TEMPERATURE_UP)*/)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
else if(function_code == AC_FUNCTION_TEMPERATURE_DOWN
|
|
/*&& FALSE == has_function(context, AC_FUNCTION_TEMPERATURE_DOWN)*/)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// if this level is in black list, do not send IR wave if user want to apply this function
|
|
if(function_code == AC_FUNCTION_TEMPERATURE_UP
|
|
/*&& FALSE == has_function(context, AC_FUNCTION_TEMPERATURE_UP)*/)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
else if(function_code == AC_FUNCTION_TEMPERATURE_DOWN
|
|
/*&& FALSE == has_function(context, AC_FUNCTION_TEMPERATURE_DOWN)*/)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
UINT16 irda_ac_lib_control(remote_ac_status_t ac_status, UINT16 *user_data, UINT8 function_code,
|
|
UINT8 change_wind_direction)
|
|
{
|
|
UINT16 time_length = 0;
|
|
UINT8 i = 0;
|
|
|
|
if (0 == context->default_code.len)
|
|
{
|
|
IR_PRINTF("\ndefault code is empty\n");
|
|
return 0;
|
|
}
|
|
|
|
// pre-set change wind direction flag here
|
|
context->change_wind_direction = change_wind_direction;
|
|
|
|
context->time = user_data;
|
|
|
|
// generate temp buffer for frame calculation
|
|
irda_memcpy(ir_hex_code, context->default_code.data, context->default_code.len);
|
|
|
|
#if defined USE_APPLY_TABLE
|
|
if(ac_status.acPower != AC_POWER_OFF)
|
|
{
|
|
for (i = AC_APPLY_POWER; i < AC_APPLY_MAX; i++)
|
|
{
|
|
apply_table[i](context, parameter_array[i]);
|
|
}
|
|
}
|
|
#else
|
|
if(ac_status.acPower == AC_POWER_OFF)
|
|
{
|
|
// otherwise, power should always be applied
|
|
apply_power(ac_status, function_code);
|
|
}
|
|
else
|
|
{
|
|
// check the mode as the first priority, despite any other status
|
|
if(TRUE == context->n_mode[ac_status.acMode].enable)
|
|
{
|
|
if (is_solo_function(function_code))
|
|
{
|
|
// this key press function needs to send solo code
|
|
apply_table[function_code - 1](ac_status, function_code);
|
|
}
|
|
else
|
|
{
|
|
if(!is_solo_function(AC_FUNCTION_POWER))
|
|
{
|
|
apply_power(ac_status, function_code);
|
|
}
|
|
|
|
if(!is_solo_function(AC_FUNCTION_MODE))
|
|
{
|
|
if (IR_DECODE_FAILED == apply_mode(ac_status, function_code))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if(!is_solo_function(AC_FUNCTION_WIND_SPEED))
|
|
{
|
|
if (IR_DECODE_FAILED == apply_wind_speed(ac_status, function_code))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if(!is_solo_function(AC_FUNCTION_WIND_SWING) &&
|
|
!is_solo_function(AC_FUNCTION_WIND_FIX))
|
|
{
|
|
if (IR_DECODE_FAILED == apply_swing(ac_status, function_code))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if(!is_solo_function(AC_FUNCTION_TEMPERATURE_UP) &&
|
|
!is_solo_function(AC_FUNCTION_TEMPERATURE_DOWN))
|
|
{
|
|
if (IR_DECODE_FAILED == apply_temperature(ac_status, function_code))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
#endif
|
|
apply_ac_function(context, function_code);
|
|
// checksum should always be applied
|
|
apply_checksum(context);
|
|
|
|
// have some debug
|
|
IR_PRINTF("==============================\n");
|
|
for(i = 0; i < ir_hex_len; i++)
|
|
{
|
|
IR_PRINTF("[%02X] ", ir_hex_code[i]);
|
|
}
|
|
IR_PRINTF("\n");
|
|
|
|
time_length = create_ir_frame();
|
|
|
|
return time_length;
|
|
}
|
|
|
|
void irda_ac_lib_close()
|
|
{
|
|
// free context
|
|
if (NULL != tags)
|
|
{
|
|
irda_free(tags);
|
|
tags = NULL;
|
|
}
|
|
free_ac_context();
|
|
return;
|
|
}
|
|
|
|
// utils
|
|
INT8 get_temperature_range(UINT8 ac_mode, INT8* temp_min, INT8* temp_max)
|
|
{
|
|
UINT8 i = 0;
|
|
|
|
if (ac_mode >= AC_MODE_MAX)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
if (NULL == temp_min || NULL == temp_max)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
|
|
if (1 == context->n_mode[ac_mode].alltemp)
|
|
{
|
|
*temp_min = *temp_max = -1;
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
*temp_min = -1;
|
|
*temp_max = -1;
|
|
for (i = 0; i < AC_TEMP_MAX; i++)
|
|
{
|
|
if(isin(context->n_mode[ac_mode].temp, i, context->n_mode[ac_mode].temp_cnt) ||
|
|
(context->temp1.len != 0 && 0 == context->temp1.comp_data[i].seg_len) ||
|
|
(context->temp2.len != 0 && 0 == context->temp2.comp_data[i].seg_len))
|
|
{
|
|
continue;
|
|
}
|
|
if (-1 == *temp_min)
|
|
{
|
|
*temp_min = i;
|
|
}
|
|
if (-1 == *temp_max || i > *temp_max)
|
|
{
|
|
*temp_max = i;
|
|
}
|
|
}
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
INT8 get_supported_mode(UINT8* supported_mode)
|
|
{
|
|
UINT8 i = 0;
|
|
if (NULL == supported_mode)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
*supported_mode = 0x1F;
|
|
|
|
for (i = 0; i < AC_MODE_MAX; i++)
|
|
{
|
|
if (0 == context->n_mode[i].enable ||
|
|
(context->mode1.len != 0 && 0 == context->mode1.comp_data[i].seg_len) ||
|
|
(context->mode2.len != 0 && 0 == context->mode2.comp_data[i].seg_len))
|
|
{
|
|
*supported_mode &= ~(1 << i);
|
|
}
|
|
}
|
|
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
INT8 get_supported_wind_speed(UINT8 ac_mode, UINT8* supported_wind_speed)
|
|
{
|
|
UINT8 i = 0;
|
|
if (ac_mode >= AC_MODE_MAX)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
|
|
if (NULL == supported_wind_speed)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
|
|
if (1 == context->n_mode[ac_mode].allspeed)
|
|
{
|
|
*supported_wind_speed = 0;
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
*supported_wind_speed = 0x0F;
|
|
|
|
for (i = 0; i < AC_WS_MAX; i++)
|
|
{
|
|
if (isin(context->n_mode[ac_mode].speed, i, context->n_mode[ac_mode].speed_cnt) ||
|
|
(context->speed1.len != 0 && 0 == context->speed1.comp_data[i].seg_len) ||
|
|
(context->speed2.len != 0 && 0 == context->speed2.comp_data[i].seg_len))
|
|
{
|
|
*supported_wind_speed &= ~(1 << i);
|
|
}
|
|
}
|
|
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
INT8 get_supported_swing(UINT8 ac_mode, UINT8* supported_swing)
|
|
{
|
|
if (ac_mode >= AC_MODE_MAX)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
|
|
if (NULL == supported_swing)
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
|
|
if (context->si.type == SWING_TYPE_NORMAL)
|
|
{
|
|
*supported_swing = 0x03;
|
|
}
|
|
else if (context->si.type == SWING_TYPE_SWING_ONLY)
|
|
{
|
|
*supported_swing = 0x02;
|
|
}
|
|
else if (context->si.type == SWING_TYPE_NOT_SPECIFIED)
|
|
{
|
|
*supported_swing = 0x00;
|
|
}
|
|
else
|
|
{
|
|
*supported_swing = 0x01;
|
|
}
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
INT8 get_supported_wind_direction(UINT8* supported_wind_direction)
|
|
{
|
|
if (NULL != context)
|
|
{
|
|
*supported_wind_direction = context->si.mode_count - 1;
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
else
|
|
{
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////// AC End //////////////////////////////////////////////////
|
|
|
|
///////////////////////////////////////////////// TV Begin /////////////////////////////////////////////////
|
|
INT8 irda_tv_lib_open(UINT8 *binary, UINT16 binary_length)
|
|
{
|
|
return tv_lib_open(binary, binary_length);
|
|
}
|
|
|
|
INT8 irda_tv_lib_parse(UINT8 irda_hex_encode)
|
|
{
|
|
if (FALSE == tv_lib_parse(irda_hex_encode))
|
|
{
|
|
IR_PRINTF("parse irda binary failed\n");
|
|
memset(tv_bin, 0x00, EXPECTED_MEM_SIZE);
|
|
tv_bin_length = 0;
|
|
return IR_DECODE_FAILED;
|
|
}
|
|
IR_PRINTF("parse irda binary successfully\n");
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
|
|
UINT16 irda_tv_lib_control(UINT8 key, UINT16* l_user_data)
|
|
{
|
|
UINT16 print_index = 0;
|
|
UINT16 irda_code_length = 0;
|
|
memset(user_data, 0x00, USER_DATA_SIZE);
|
|
irda_code_length = tv_lib_control(key, l_user_data);
|
|
|
|
// have some debug
|
|
IR_PRINTF("=============================\n");
|
|
IR_PRINTF("length of IRDA code = %d\n", irda_code_length);
|
|
for(print_index = 0; print_index < irda_code_length; print_index++)
|
|
{
|
|
IR_PRINTF("%d ", user_data[print_index]);
|
|
}
|
|
IR_PRINTF("\n=============================\n\n");
|
|
|
|
return irda_code_length;
|
|
}
|
|
|
|
INT8 irda_tv_lib_close()
|
|
{
|
|
// no need to close tv binary
|
|
return IR_DECODE_SUCCEEDED;
|
|
}
|
|
///////////////////////////////////////////////// TV End /////////////////////////////////////////////////
|