The ECU-VCI CAN Communication Driver Function is this


esp_err_t can_send_data_bcu(const uint8_t to_send[], const uint16_t send_len, uint8_t start_byte) {
	static twai_message_t rx_message;
	//twai_message_t tx_message;

	uint8_t byte_received = 0;
	uint16_t byte_transmitted = 0;
	uint8_t byte_length = 0;
	memset(can_rx_data,0,sizeof(can_rx_data));
	memset(tx_message.data,0xFF,sizeof(tx_message.data));

	//Pre-Condition Check Not Passed
//	int can_rx_ticks_to_wait = 250;
//	int can_tx_ticks_to_wait = 1000;
//	int can_rx_timeout_delay = 250;

	//Pre-Condition Check Not Passed
//	int can_rx_ticks_to_wait = 250;
//	int can_tx_ticks_to_wait = 1000;
//	int can_rx_timeout_delay = 150;

	//Pre-Condition Check Passed
	int can_rx_ticks_to_wait = 150;
	int can_tx_ticks_to_wait = 1000;
	int can_rx_timeout_delay = 250;

//	int can_rx_ticks_to_wait = 250;
//	printf("Switching can_tx_ticks_to_wait to 1000 \n");
//	int can_tx_ticks_to_wait = 1000;
//	printf("Switching can_rx_timeout_delay to 100 \n");
//	int can_rx_timeout_delay = 150;

//int can_tx_timeout_retry = 70;

//	int tx_timeout_fc = 250;
//	int tx_transmit_cf = 10;
//	int rx_timeout_cf = 250;





	tx_message.data_length_code = 8;

	if(send_len <= 7) {
		for(uint8_t i =1;i< 8;i++)
		{
			if(byte_transmitted != send_len) {
				tx_message.data[i] = to_send[byte_transmitted++];
			}
		}
		tx_message.data[0] = byte_transmitted;

#ifdef DEBUG_CAN_TX
		printf("CAN TX DATA: ");
		for (int i=0; i< byte_transmitted+1; i++){
			printf("%02X ", tx_message.data[i]);
		}
		printf("\n");
#endif


		twai_transmit(&tx_message, pdMS_TO_TICKS(can_tx_ticks_to_wait));

		while (1) {
			if (twai_receive(&rx_message, pdMS_TO_TICKS(can_rx_ticks_to_wait)) == ESP_OK) {
				while(rx_message.data[1] == 0x7F && rx_message.data[3] == 0x78 ){
					twai_receive(&rx_message, pdMS_TO_TICKS(10));
					ESP_LOGI("CAN", "Waiting for Response");
#ifdef DEBUG_CAN_RX
		printf("CAN RX DATA: ");
		for (int i=0; i< 8; i++){
			printf("%02X ", rx_message.data[i]);
		}
		printf("\n");
#endif
				}
				if(rx_message.data[1] == 0x7F && rx_message.data[3] != 0x78 ) {
					printf("Negative Response %x\n", rx_message.data[3]);

					uint8_t structlen=(sizeof(NEGATIVE_RES)/(sizeof(NEGATIVE_RES[0]))); //find the number of items in our -ve response dictionary

					for(uint8_t j=0; j<structlen; j++) //check which type of -ve response did we receive
					{
						if((NEGATIVE_RES[j].id)==rx_message.data[3])
						{
							printf("%s \n", NEGATIVE_RES[j].description);
						}
					}

					for(uint8_t i = start_byte;i<=rx_message.data_length_code;i++)
					{
						can_rx_data[byte_received++] = rx_message.data[i];
					}

#ifdef DEBUG_CAN_RX
		printf("CAN RX DATA: ");
		for (int i=0; i< byte_received+1; i++){
			printf("%02X ", rx_message.data[i]);
		}
		printf("\n");
#endif
					break;

				} else if(rx_message.data[0] > 7) {
					byte_length = rx_message.data[1];

					for(uint8_t i = (start_byte+1);i<rx_message.data_length_code;i++)
					{
						can_rx_data[byte_received++] = rx_message.data[i];
					}
#ifdef DEBUG_CAN_RX
		printf("CAN RX DATA: ");
		for (int i=0; i< byte_received+2; i++){
			printf("%02X ", rx_message.data[i]);
		}
		printf("\n");
#endif

					if(tx_message.flags == TWAI_MSG_FLAG_EXTD)//physical address for flow control
					{
						tx_message.identifier = (((rx_message.identifier & 0xFF) << 8) |
								((rx_message.identifier >> 8) & 0xFF) |
								(rx_message.identifier & 0xFFFF0000));
					}

					tx_message.data[0] = 0x30;
					tx_message.data[1] = 0x00;
					tx_message.data[2] = 0x00;
					tx_message.data[3] = 0x00;
					tx_message.data[4] = 0x00;
					tx_message.data[5] = 0x00;
					tx_message.data[6] = 0x00;
					tx_message.data[7] = 0x00;

#ifdef DEBUG_CAN_TX
		printf("CAN TX DATA: ");
		for (int i=0; i< byte_transmitted+1; i++){
			printf("%02X ", tx_message.data[i]);
		}
		printf("\n");
#endif

					twai_transmit(&tx_message, pdMS_TO_TICKS(can_tx_ticks_to_wait));

					while(byte_received < byte_length) {
						if (twai_receive(&rx_message, pdMS_TO_TICKS(can_rx_ticks_to_wait)) == ESP_OK)
						{
							for(uint8_t i =1;i< 8;i++)
							{
								if(byte_received != byte_length) {
									can_rx_data[byte_received++] = rx_message.data[i];
								}
							}
						}
					}
					data_CAN_length = byte_received;

#ifdef DEBUG_CAN_RX
					printf("CAN RX DATA: ");
					for(int i=0;i<data_CAN_length;i++)
					{
						printf("%02X ",can_rx_data[i]);
					}
					printf("\n");
#endif
					return ESP_OK;
				} else {
					byte_length = rx_message.data[0];
					for(uint8_t i = start_byte;i<=byte_length;i++)
					{
						can_rx_data[byte_received++] = rx_message.data[i];
					}
					data_CAN_length = byte_received;

#ifdef DEBUG_CAN_RX
					printf("CAN RX DATA: ");
					for(int i=0;i<data_CAN_length;i++)
					{
						printf("%02X ",can_rx_data[i]);
					}
					printf("\n");
#endif
					return ESP_OK;
				}
			} else {
				return ESP_FAIL;
			}
		}//end of while can receive loop
	}
	// //sending length is greater than 7
	else {//sending length is greater than 7
		tx_message.data[0] = (send_len >>8 ) | 0x10;
		tx_message.data[1] =  send_len & 0xFF;
		for(uint8_t i=2;i< 8;i++)
		{
			if(byte_transmitted != send_len) {
				tx_message.data[i] = to_send[byte_transmitted++];
			}
		}

#ifdef DEBUG_CAN_TX
		printf("CAN TX DATA: ");
		for (int i=0; i< byte_transmitted+1; i++){
			printf("%02X ", tx_message.data[i]);
		}
		printf("\n");
#endif
		twai_transmit(&tx_message, pdMS_TO_TICKS(can_tx_ticks_to_wait));

		memset(tx_message.data,0xFF,sizeof(tx_message.data));

		if (twai_receive(&rx_message, pdMS_TO_TICKS(can_rx_ticks_to_wait)) == ESP_OK) {
			if(rx_message.data[0] == 0x30) {
				tx_message.data[0] = 0x21;
				for(uint8_t i=1;i< 8;i++)
				{
					if(byte_transmitted != send_len) {
						tx_message.data[i] = to_send[byte_transmitted++];
					}
				}
#ifdef DEBUG_CAN_TX
		printf("CAN TX DATA: ");
		for (int i=0; i< byte_transmitted+1; i++){
			printf("%02X ", tx_message.data[i]);
		}
		printf("\n");
#endif
				twai_transmit(&tx_message, pdMS_TO_TICKS(can_tx_ticks_to_wait));

				while(byte_transmitted < send_len) {
					if(tx_message.data[0] == 0x2F) {
						tx_message.data[0] = 0x20;
					} else {
						tx_message.data[0] += 1;
					}
					for(uint8_t i=1;i< 8;i++)
					{
						if(byte_transmitted != send_len) {
							tx_message.data[i] = to_send[byte_transmitted++];
						}
					}
#ifdef DEBUG_CAN_TX
		printf("CAN TX DATA: ");
		for (int i=0; i< byte_transmitted+1; i++){
			printf("%02X ", tx_message.data[i]);
		}
		printf("\n");
#endif
					twai_transmit(&tx_message, can_tx_ticks_to_wait);
					//twai_transmit(&tx_message, portMAX_DELAY);
					//vTaskDelay(pdMS_TO_TICKS(10));
				}
				twai_receive(&rx_message, pdMS_TO_TICKS(can_rx_ticks_to_wait));
				byte_length = rx_message.data[0];
				for(uint8_t i = start_byte; i<=byte_length;i++)
				{
					can_rx_data[byte_received++] = rx_message.data[i];
				}
				data_CAN_length = byte_received;

#ifdef DEBUG_CAN_RX
					printf("CAN RX DATA: ");
					for(int i=0;i<data_CAN_length;i++)
					{
						printf("%02X ",can_rx_data[i]);
					}
					printf("\n");
#endif
			}

			return ESP_OK;
		} else {
			return ESP_FAIL;
		}
	}
	return ESP_FAIL;
}