HomeEnergyMeter/main/toshiba_ir.c

#include "toshiba_ir.h"
#include <stdint.h>
#include <stdio.h>
#include "esp_log.h"
#include "rxTimer.h"
#include <string.h>
#include "config.h"

uint8_t sumBytes(const uint8_t * const start, const uint16_t length);

uint8_t bitReverse(uint8_t b) {
   b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;
   b = (b & 0xCC) >> 2 | (b & 0x33) << 2;
   b = (b & 0xAA) >> 1 | (b & 0x55) << 1;
   return b;
}


/**
 * @Analys of Toshiba IR Rx:
 *  0  1  2  3  4  5  6  7  8
 * F2 0D 03 FC 01 D0 A3 00 72       30 Grader
 * F2 0D 03 FC 01 90 A3 00 32       26 Grader
 * F2 0D 03 FC 01 40 A3 00 E2       21 Grader
 * F2 0D 03 FC 01 30 A3 00 92       20 Grader
 * F2 0D 03 FC 01 20 A3 00 82       19 Grader
 * F2 0D 03 FC 01 10 A3 00 B2       18
 * F2 0D 03 FC 01 00 A3 00 A2       17
 * 
 * F2 0D 03 FC 01 D0 03 00 D2       Auto Fan  0000  0 (0 is Auto, 2-6 is the speed, 6 is Max)
 * F2 0D 03 FC 01 D0 43 00 92       1         0100  2
 *                                  2         0110  3
 * F2 0D 03 FC 01 D0 83 00 52       3         1000  4
 *                                  4         1010  5
 * F2 0D 03 FC 01 D0 C3 00 12       5         1100  6
 * 
 * F2 0D 03 FC 01 60 83 00 E2       ON        1000 0011 (3 is ON, 7 is OFF)
 * F2 0D 03 FC 01 60 87 00 E6       OFF       1000 0111
 * 
 */

/*****
 * Panasonic decode 19 bytes
 *
 *         1 2 3 4 5 6 7 8  9 0 1 2 3 4 5 6  7 8 9 
 * 30 deg 4004072000123C61 C560007007000091 000054   0011 1100  - 11100 1C 28
 * 24 deg 4004072000120C61 C560007007000091 000078   0000 1100  - 10000 10 16
 * 23 deg 4004072000127461 C560007007000091 000038   0111 0100  - 01110  E 14
 * 22 deg 4004072000123461 C560007007000091 000058   0011 0100  - 01100  C 12
 * 21.5   400407200012D461 C560007007000091 000098   1101 0100  - 01011  B 11
 * 21 deg 4004072000125461 C560007007000091 000018   0101 0100  - 01010  A 10
 * 16 deg 4004072000120461 C560007007000091 000070   0000 0100  - 00000  0 00
 *        0220E00400482086 A306000EE0000089 00000E   0010 0010 17 grader
 *
 * Me:    4004072000000060 0220E00400483286 6306000EE00000890000E0
 * Forum: 0220E00400000006 0220E00400492880 A40D000EE000000100069D
 * Code has a checksum in the last byte (9D) calculated as follows:
 * f4 + 02 + 20 + ... + 00 + 06 (= 9D in the case above).
 * Summing all but the last byte to f4.
 * Forum: https://www.varmepumpsforum.com/vpforum/index.php?topic=13580.0
 * For me, the chksum needs to add 0x06 to make it work.
 * 
 * 
 * Fan in byte ([8] >> 4)
 * 10 = Auto
 *  3 = F1
 *  4 = F2
 *  5 = F3
 *  6 = F4
 *  7 = F5
 * 
 * Power in data->raw[5]&0x01
 * 0 = OFF
 * 1 = ON
 * 
 * Checksum
 * Byte #19 of frame 2 is the checksum for frame 2. It allows the AC unit to know whether the command sent
 * is valid or not.
 * The checksum is the sum (addition) of the previous 18 bytes modulo 256 (frame 2 only).
*/



uint8_t data[kPanasonicNumberOfBytes];            // Temp data during rx
uint8_t dataTransfer[kPanasonicNumberOfBytes];    // Send as pointer to receiver

enum
{
    UNKNOWN,
    STARTER,
    T0,
    T1,
    DONE
};

static uint8_t rx_state = UNKNOWN;

static uint32_t rx_numBits;


void Toshiba_ir_ResetDecoder()
{
    //ESP_LOGI("T", "Reset decoder");
    rx_numBits = 0;
    rx_state = UNKNOWN;
    memset(data,0,kPanasonicNumberOfBytes);
}

static void addBit(uint8_t value)
{
    if( value == 1 ) {

        const uint8_t byteNo = rx_numBits / 8;
        const uint8_t shiftBits = rx_numBits % 8;

        //ESP_LOGI("BIT RX:","%u  %u", byteNo, shiftBits);

        data[byteNo] |= 1u << (7-shiftBits);
    }

    rx_numBits++;
}

#define HDR_MARK_MIN (kPanasonicAcHdrMark-200)
#define HDR_MARK_MAX (kPanasonicAcHdrMark+200)

#define HDR_SPACE_MIN (kPanasonicAcHdrSpace-200)
#define HDR_SPACE_MAX (kPanasonicAcHdrSpace+200)

#define T0_PULSE_MIN (kPanasonicAcBitMark-100)
#define T0_PULSE_MAX (kPanasonicAcBitMark+100)

#define SHORT_PULSE_MIN (kPanasonicAcZeroSpace-100)
#define SHORT_PULSE_MAX (kPanasonicAcZeroSpace+100)

#define LONG_PULSE_MIN (kPanasonicAcOneSpace-100)
#define LONG_PULSE_MAX (kPanasonicAcOneSpace+100)

#define GAP_PULSE_MIN (kPanasonicAcUsualGap-200)
#define GAP_PULSE_MAX (kPanasonicAcUsualGap+200)


// Pulse decoder
static int32_t rx_decode(uint32_t width)
{
    switch (rx_state) {
        case UNKNOWN: // Start of frame A
            if ( HDR_MARK_MIN <= width && width <= HDR_MARK_MAX )
            {
                rx_state = STARTER;
                ESP_LOGI("T", "STARTER A");
            }
            else
            {
                ESP_LOGI("T", "Err STARTER A %u",width);
                return -1; // error, reset
            }
            break;
        
        case STARTER: // Start of frame B
            if ( HDR_SPACE_MIN <= width && width <= HDR_SPACE_MAX )
            {
                rx_state = T0;
                ESP_LOGI("T", "STARTER B");
            }
            else
            {
                ESP_LOGI("T", "Err STARTER B %u",width);
                return -1; // error, reset
            }
            break;


        case T0: // First half of pulse

            if(rx_numBits == kPanasonicNumberOfBits)
            { // end of frame
                ESP_LOGI("T", "END OF FRAME");
                rx_state = DONE;
                return 1;
            }
            else if( T0_PULSE_MIN <= width && width <= T0_PULSE_MAX )
            {
                rx_state = T1;
                //ESP_LOGI("T", "T0 %u",width);
            }
            else
            {
                ESP_LOGI("T", "Err T0 %u",width);
                return -1; // error, reset
            }
            break;

        case T1:
            if( SHORT_PULSE_MIN <= width && width <= SHORT_PULSE_MAX )
            {
                addBit(0);
                //ESP_LOGI("T", "Short %u",rx_numBits);
            }
            else if( LONG_PULSE_MIN <= width && width <= LONG_PULSE_MAX )
            {
                addBit(1);
                //ESP_LOGI("T", "Long %u", rx_numBits);
            }
            else if( GAP_PULSE_MIN <= width && width <= GAP_PULSE_MAX )
            {
                ESP_LOGI("T", "GAP-Pulse. Restart");
                rx_numBits = 0;
                rx_state = UNKNOWN;
                break;
            }
            else
            {
                ESP_LOGI("T", "Err T1 %u",width);
                return -1; // error, reset
            }
            rx_state = T0;
            break;
    }
    return 0;
}



uint8_t* nextPulseToshiba_ir(uint32_t width)
{
    uint8_t* retVal = NULL;

    if (width > 0)
    {
        if (rx_state != DONE)
        {
            // Send the pulse to the decoder
            switch (rx_decode(width))
            {
            case -1:
                Toshiba_ir_ResetDecoder();
                break;
            case 1:
                rx_state = DONE;
                // Panasonic has LSB8 format so we need to bit-reverse each byte
                for( uint8_t i=0; i<kPanasonicNumberOfBytes; i++ ) data[i] = bitReverse(data[i]);
                // Check checksum
                uint8_t chkSum = sumBytes(data,18) - 6;
                ESP_LOGI("TOSHIBA","Chksum:0x%02X  B18:0x%02X  Diff:0x%02X", chkSum,data[18],(uint8_t)(chkSum-data[18]));

                if( chkSum == data[18] ) {
                    ESP_LOGI("TOSHIBA", "CORRECT CHKSUM");
                    memcpy(dataTransfer,data,kPanasonicNumberOfBytes);
                    Toshiba_ir_ResetDecoder();
                    retVal = dataTransfer;
                }
                else {
                    ESP_LOGE("TOSHIBA", "WRONG CHKSUM");
                    ESP_LOGE("TOSHIBA","Chksum:0x%02X  B18:0x%02X  Diff:0x%02X", chkSum,data[18],(uint8_t)(chkSum-data[18]));
                    Toshiba_ir_ResetDecoder();
                }
                break;
            }
        }
    }
    
    return retVal;
}

uint8_t sumBytes(const uint8_t * const start, const uint16_t length) {
  uint8_t checksum = 0;
  const uint8_t *ptr;
  for (ptr = start; ptr - start < length; ptr++) {
    checksum += (*ptr);
    //ESP_LOGI("CS","Byte:0x%02X",(*ptr));
  }
  return (uint8_t) (checksum);
}