HomeEnergyMeter/main/ir_transmit.c

#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "esp_log.h"
#include "driver/rmt.h"

#include "toshiba_ir.h"
#include "ir_transmit.h"
#include "config.h"

#ifdef IR_TRANSMIT

extern uint8_t bitReverse(uint8_t b);

// RMT values
#define RMT_TX_CHANNEL RMT_CHANNEL_0
#define RMT_TX_GPIO    GPIO_NUM_26
// channel clock period = 1 uS
#define RMT_CLK_DIV    80

// Variable that holds the IR protocol transmission. 1 start bit, 8*8+19*8 data bits and one stop bit
#define STATIC_PRE_BYTES 8
#define DYN_DATA_BYTES 19
#define TOT_DATA_BYTES (STATIC_PRE_BYTES+DYN_DATA_BYTES)
#define RMT_BITS (1+(STATIC_PRE_BYTES*8)+1+1+(DYN_DATA_BYTES*8)+1+1) // 221 bits in total

rmt_item32_t toshiba_rmt[RMT_BITS];
uint8_t irTxData[TOT_DATA_BYTES];

QueueHandle_t toshibaTxQueue = NULL;

void copyDataToRmtArray( const uint8_t rmtStartBit, const uint8_t* data, const uint8_t noOfBytes, const bool reverseByte) {
	for(uint8_t b=0;b<noOfBytes*8;b++) {
		uint8_t byteNo = b / 8;
		uint8_t byte = (reverseByte) ? bitReverse(data[byteNo]) : data[byteNo];
		uint8_t shiftBits = b % 8;
		uint8_t bit_data = (1u << (7-shiftBits)) & byte;
		uint32_t space = bit_data ? kPanasonicAcOneSpace : kPanasonicAcZeroSpace;
		toshiba_rmt[b+rmtStartBit].val = ((kPanasonicAcBitMark+5) << 0) | (1 << 15) | (space << 16);
    }
}

void correctIrTxDataChecksum() {

	irTxData[TOT_DATA_BYTES-1] = 0xFA;
	for( uint8_t b=0+STATIC_PRE_BYTES ; b<(TOT_DATA_BYTES-1) ; b++ ) {
		irTxData[TOT_DATA_BYTES-1] += irTxData[b];
	}
}

void toshibaTxTask(void *pvParameter)
{
	ESP_LOGI("IR_TRANSMIT", "toshibaTxTask() starting.");

	uint8_t data[8];
    	
	while( true ) {
		if( xQueueReceive( toshibaTxQueue, data, 100 ) == pdTRUE ) {
			ESP_LOGI("IR_TRANSMIT","Received a TX from MQTT");

			uint8_t irPair = 1;
			for(uint8_t b=0;b<kPanasonicNumberOfBits;b++) {
				
				uint8_t byteNo = b / 8;
				uint8_t shiftBits = b % 8;
				uint8_t bit_data = (1u << (7-shiftBits)) & data[byteNo];
				uint32_t space = bit_data ? kPanasonicAcOneSpace : kPanasonicAcZeroSpace;

				toshiba_rmt[irPair].val = (kPanasonicAcBitMark << 0) | (1 << 15) | (space << 16);    // Header of IR Transmit 

				irPair++;
			}

			ESP_ERROR_CHECK(rmt_write_items(RMT_TX_CHANNEL, &(toshiba_rmt[0]), 1+72+1, true));
		}
	}
}



void initIrTransmit() {

	const esp_err_t uninstRetVal = rmt_driver_uninstall(RMT_TX_CHANNEL);

	ESP_LOGI("IR_TRANSMIT","Uninst: %u", uninstRetVal);

    rmt_config_t rmt_tx;
	memset(&rmt_tx,0,sizeof(rmt_config_t));
	rmt_tx.rmt_mode = RMT_MODE_TX;
	rmt_tx.channel  = RMT_TX_CHANNEL;
	rmt_tx.gpio_num = GPIO_IR_TX_DATA;
	rmt_tx.mem_block_num = 1;
	rmt_tx.clk_div = RMT_CLK_DIV;
	rmt_tx.tx_config.loop_en = false;
	rmt_tx.tx_config.carrier_duty_percent = 30;
	rmt_tx.tx_config.carrier_freq_hz = 38000;
	rmt_tx.tx_config.carrier_level   = RMT_CARRIER_LEVEL_HIGH;
	rmt_tx.tx_config.carrier_en      = true;
	rmt_tx.tx_config.idle_level      = RMT_IDLE_LEVEL_LOW;
	rmt_tx.tx_config.idle_output_en  = true;
    rmt_tx.flags = 0;
	
	ESP_LOGI("IR_TRANSMIT","Install driver....");
	ESP_ERROR_CHECK( rmt_config(&rmt_tx) );
	const esp_err_t retVal = rmt_driver_install(rmt_tx.channel, 0, 0);
	if( retVal != ESP_OK ) {
		ESP_LOGE("IR_TRANSMIT","Error on driver install %u",retVal);
		return;
	}

	//ESP_ERROR_CHECK( rmt_driver_install(rmt_tx.channel, 0, 0) );

    // Init the ir default Panasonic IR data field
	/**
	 * The IR is divided into 2 parts
	 * 0    Start
	 * 1    64 fixed bits
	 * 65   A gap
	 * 66   Start (again)
	 * 67   152 bits with data
	 * 219  Stop
	 * 220  End-marker (Not sent)
	 *  
	 */
	
    toshiba_rmt[0].val = (kPanasonicAcHdrMark << 0) | (1 << 15) | (kPanasonicAcHdrSpace << 16); 
    toshiba_rmt[65].val = (kPanasonicAcBitMark << 0) | (1 << 15) | (kPanasonicAcUsualGap << 16);
	toshiba_rmt[66].val = (kPanasonicAcHdrMark << 0) | (1 << 15) | (kPanasonicAcHdrSpace << 16); 
	toshiba_rmt[219].val = (kPanasonicAcBitMark << 0) | (1 << 15) | (kPanasonicAcZeroSpace << 16); 
    toshiba_rmt[220].val = (1 << 16);    // RMT End marker

	// Setup the fixed 64 bits: 0x4004072000000060 (Sent like this)
	//const uint8_t fixedData[STATIC_PRE_BYTES]={0x40,0x04,0x07,0x20,0x0,0x00,0x0,0x60}; // Non-reversed
	const uint8_t fixedData[STATIC_PRE_BYTES]={0x02,0x20,0xE0,0x04,0x00,0x00,0x00,0x06}; // Reversed
	memcpy(&irTxData[0],(void *)&fixedData[0],STATIC_PRE_BYTES);	// Copy the fixed data

	// Setup the the real 152 data bits
	const uint8_t confData[DYN_DATA_BYTES]={0x02,0x20,0xE0,0x04,0x00,0x49,0x31,0x86,	// 0x86 is correct
	                            			0xA3,0x06,0x00,0x0E,0xE0,0x00,0x00,0x89,
											0x00,0x00,0x20 };
	memcpy(&irTxData[0+STATIC_PRE_BYTES],(void *)&confData[0],DYN_DATA_BYTES);

	correctIrTxDataChecksum();
	
	copyDataToRmtArray(1,&irTxData[0],STATIC_PRE_BYTES,true);
	copyDataToRmtArray(67,&irTxData[8],DYN_DATA_BYTES,true);

    toshibaTxQueue = xQueueCreate( 5, IR_TX_QUEUE_DATA_SIZE );
	//xTaskCreatePinnedToCore(toshibaTxTask, "toshibaTxTask", 1024*10, NULL, 2, NULL,0);

	ESP_LOGI("IR_TRANSMIT","Init done.");

	ESP_ERROR_CHECK(rmt_write_items(RMT_TX_CHANNEL, &(toshiba_rmt[0]), RMT_BITS, true));
}

#endif