我已经弄清楚了大多数事情，但是我找不到错误检查的方式。 Temp +模式是其中的一部分，但我找不到整个难题的解决方案。也关于什么颜色的任何建议。 16可能是（我是否缺少概述中的功能？）会很棒。
以下是示例值：目前为止：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
100 1 00 0 0 1011 00 1111 000 1 1 0 00001010010 0000 00000 0 000100000000000000 1010 ->
100 1 00 0 0 1011 00 1111 000 1 1 1 00001010010 0000 00000 0 000100000000000000 1010 ->
100 1 00 1 0 0000 00 0000 000 1 1 0 00001010010 1110 00000 1 000100000000000000 1010
100 1 00 1 0 1000 00 0000 000 1 1 0 00001010010 1110 00000 1 000100000000000000 0110
100 1 00 1 0 0100 00 0000 000 1 1 0 00001010010 1110 00000 1 000100000000000000 1110
100 1 00 1 0 1011 00 0000 000 1 1 0 00001010010 1110 00000 1 000100000000000000 0100
100 1 00 0 0 0011 00 1111 000 1 1 0 00001010010 0000 00000 0 000100000000000000 0010 ->
100 1 00 0 0 0011 00 1111 000 1 1 0 00001010010 0000 00000 0 000100000000000000 0010 ->
100 1 00 0 0 1011 00 0000 000 1 1 0 00001010010 0100 00000 1 000100000000000000 0100
100 1 00 0 0 1011 00 0000 000 1 1 0 00001010010 1100 00000 1 000100000000000000 0100
100 1 00 0 0 1011 00 0000 000 1 1 0 00001010010 0010 00000 1 000100000000000000 0100
100 1 00 0 0 1011 00 0000 000 1 1 0 00001010010 1010 00000 1 000100000000000000 0100
100 1 00 0 0 1011 00 0000 000 1 1 0 00001010010 0110 00000 1 000100000000000000 0100
100 1 00 1 0 1011 00 0000 000 1 1 0 00001010010 1000 00000 1 000100000000000000 0100
100 1 00 1 0 1011 00 0000 000 1 1 0 00001010010 1101 00000 1 000100000000000000 0100
100 1 00 1 0 1011 00 0000 000 1 1 0 00001010010 1110 00000 1 000100000000000000 0100
100 1 00 1 0 1011 00 0000 000 1 1 0 00001010010 1001 00000 1 000100000000000000 0100
100 1 00 0 0 1011 00 0000 000 1 1 0 00001010010 0000 00000 1 000100000000000000 0100
100 1 10 1 0 1011 00 0000 000 1 1 0 00001010010 1110 00000 1 000100000000000000 0100
100 1 01 1 0 1011 00 0000 000 1 1 0 00001010010 1110 00000 1 000100000000000000 0100
100 1 11 1 0 1011 00 0000 000 1 1 0 00001010010 1110 00000 1 000100000000000000 0100
100 1 00 1 0 1011 00 0000 000 1 1 0 00001010010 1110 00000 1 000100000000000000 0100
100 1 00 0 0 0011 00 0000 000 0 1 0 00001010010 0000 00000 0 000100000000000000 1000
100 1 00 0 0 0011 00 0000 000 1 1 0 00001010010 0000 00000 0 000100000000000000 1000
000 1 10 0 0 1001 00 0000 000 1 1 0 00001010010 0000 00000 0 000100000000000000 1011
100 1 00 0 0 0011 00 0000 000 1 1 0 00001010010 0000 00000 0 000100000000000000 1000
010 1 10 0 0 0100 00 0000 000 1 1 0 00001010010 0000 00000 0 000100000000000000 0001
110 1 00 1 0 1011 00 0000 000 1 1 0 00001010010 1110 00000 0 000100000000000000 0010
001 1 00 0 0 0011 00 0000 000 1 1 0 00001010010 0000 00000 0 000100000000000000 0010
100 0 00 1 0 1011 00 0000 000 1 0 0 00001010010 1110 00000 1 000100000000000000 0101
EDIT1剥离的行/列不添加信息：
#1 楼
我是从布尔逻辑简化器的角度来解决这个问题的：您可以调整的值越多，校验和函数的输入就越少，那么它就越容易理解。 ，但请注意以下几点：用数据集中的相同值对行进行修剪。它们只是杂音。
第5、7、9、13、15和17列的每一行都有相同的值，因此您只能猜测如何将它们计入校验和。因此，它们无助于确定如何使用其他值。
校验和中不包括第3、4、10、12和14列，因为存在所有其他值相同且校验和相同的行。
第1、6和8列肯定包含在校验和中，因为有些行的所有其他值都相同，但校验和不同。数据集。
#2 楼
我知道这个问题很旧，但是我在为这种交流电进行位映射时偶然发现了这个问题。在此处查看Catalyn的帖子：https://myesp8266.blogspot.com.ar/2016/05/keep-your-house-cool-with-esp8266.html。似乎是相同的AC协议，并且那里有一些关于如何计算CRC的信息。我还没有尝试过，因为我目前正在将位映射到功能。您有一些我还没有找到，并节省了我一些时间。顺便说一句，您在第5列中的常数0实际上是睡眠功能。编辑：我已经解决了这个问题！我发现了其他一些不错的intel信息源，一些带有糟糕的代码有时可以工作，还有一些很好的文档却缺少了假设。合并它们，现在我有了工作代码。我忽略了一些我不在乎的内容，但是您可以弄清楚如何添加它们。我进行的CRC计算已经考虑到了所有因素，无论它们是否固定。 >
const header = [9050, 4450];
const zero_bit = [700, 550];
const one_bit = [700, 1650];
const separator = [700, 19900];
const MODE = {
AUTO: 0x0,
COOL: 0x1,
DRY: 0x2,
FAN: 0x3,
HEAT: 0x4
};
const POWER = {
OFF: 0x0,
ON: 0x1
};
const FAN = {
AUTO: 0x0,
SPEED_1: 0x1,
SPEED_2: 0x2,
SPEED_3: 0x3,
SPEED_4: 0x4,
};
const SWING = {
OFF: 0x0,
ON: 0x1
};
const SLEEP = {
OFF: 0x0,
ON: 0x1
};
const TURBO = {
OFF: 0x0,
ON: 0x1
};
const LIGHT = {
OFF: 0x0,
ON: 0x1
}
const HEALTH = {
OFF: 0x0,
ON: 0x1
}
const XFAN = {
OFF: 0x0,
ON: 0x1
}
const TEMPERATURE = {
BASE: 16
};
let state = {
mode: MODE.COOL,
power: POWER.ON,
temperature: 27 - TEMPERATURE.BASE,
xfan: XFAN.ON,
health: HEALTH.ON,
light: LIGHT.ON,
turbo: TURBO.OFF,
swing: SWING.ON,
fan: FAN.AUTO
};
function reverseBits(x, bitLength) {
let result = 0;
for (let index = 0; index < bitLength; ++index) {
result |= ((x >> index) & 1) << (bitLength - index - 1)
}
return result
}
function reverseByte(value) {
return reverseBits(value, 8);
}
function reverseNibble(value) {
return reverseBits(value, 4);
}
function buildPacket(state) {
const byte1 = (reverseBits(state.mode, 3) << 5) | (reverseBits(state.power, 1) << 4) | (reverseBits(state.fan, 2) << 2) | (reverseBits(state.swing, 1) << 1) | (reverseBits(state.sleep, 1) << 0);
const byte2 = (reverseBits(state.temperature, 4) << 4);
const byte3 = (reverseBits(state.turbo, 1) << 3) | (reverseBits(state.light, 1) << 2) | (reverseBits(state.health, 1) << 1) | (reverseBits(state.xFan, 1) << 1);
const byte4 = 0x0A;
const byte5 = 0;
const byte6 = 4;
const byte7 = 0;
const byte8 = reverseNibble(
(
(reverseByte(byte1) & 0x0F) +
(reverseByte(byte2) & 0x0F) +
(reverseByte(byte3) & 0x0F) +
(reverseByte(byte4) & 0x0F) +
((reverseByte(byte5) & 0xF0) >> 4 ) +
((reverseByte(byte6) & 0xF0) >> 4 ) +
((reverseByte(byte7) & 0xF0) >> 4 ) + 10
) & 0x0F);
let data = [];
data = data.concat(header);
data = pushBits(data, byte1);
data = pushBits(data, byte2);
data = pushBits(data, byte3);
data = pushBits(data, byte4);
data = data.concat(zero_bit);
data = data.concat(one_bit);
data = data.concat(zero_bit);
data = data.concat(separator);
data = pushBits(data, byte5);
data = pushBits(data, byte6);
data = pushBits(data, byte7);
data = pushBits(data, byte8);
data = data.concat([650]);
return data;
}
function pushBits(data, byte) {
for (let i = 7; i >= 0; --i) {
if ((byte & (1 << i)) !== 0) {
data = data.concat(one_bit);
}
else {
data = data.concat(zero_bit);
}
}
return data;
}
const data = buildPacket(state);
console.log(data)
评论
请看一下链接，它应该对您的逆向工程有所帮助