ESP32 PICO Isobus++ VT Library to Component Adaptation

[thiagozf1]

Hi guys,
I'm kind of new to git and to Isobus world and I've been trying to integrate your library to a ESP32 pico v3 project. I would really apreciate if someone could help me here. Recently I've tried to compile one of the VT examples and I got several errors that made me adapt my programm and the library itself. At the moment the project compiles, but when the ESP32 starts running, it crashes after reaching one function inside "iop_file_interface". Basically, it can't open the iop file I think, and I couldn't find out why :(. I've read the discussion that was posted here this week but it doesn't solve my problem. Just a side note here, I'm not using platformIO. Also, I'm trying to transform this library into a component for the ESP. I will be leaving the component code here.

Isobus_pp.zip

I'm using the CMake extensions and the languages are C and C++. If you need more parts of the programm, just ask for them :)

[ad3154]

Hey there! I'm not an ESP32 expert, maybe @GwnDaan knows more since he is the main author of the ESP32 integration, but I would definitely question how the ESP32's file streaming works. That helper function in iop_file_interface relies on an ifstream working like it would on a platform with a full fledged file system, so maybe there's complications with that on ESP32?

Either way, I have a suggestion you could try! I've attached a cpp file that contains the content of that IOP file as a std::uint8_t vector. Instead of reading it from the file, you could use this directly instead, perhaps by keeping it in it's own file.
objectPoolConverted.zip

It's a bit weird, but this is fairly similar to how I'd expect someone to load an object pool on a platform with onboard flash memory as well, like Teensy (some day). There is one downside, and that is that you may need to cast it if you want to use hash_object_pool_to_version, or make it non-const to use it.

Let me know if you run into compilation issues with the library, or if you have to change things in the library to make everything happy, as we will want to make sure it's as compatible with ESP32 as we can.

[GwnDaan]

Hey @thiagozf1! I only have experience with using ESP in combination with PlatformIO, but the following might be useful to you as well.

I don't use any file system on my ESP but instead compile the binary pool file together with the rest of the program and then flash it all together. For PlatformIO to do this I have to specify the following in the platformio.ini configuration file:

board_build.embed_txtfiles = src/vtpooldata.iop

In your case, where you use CMake with ESP, I think it is a different setting, but similar. Your best bet I feel like is to read the following: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/build-system.html#embedding-binary-data

How I load in an embedded object pool which is compiled together with the program:

	// Load object pool from embedded vtpooldata.iop file
	extern const std::uint8_t iopStart[] asm("_binary_vtpooldata_iop_start");
	extern const std::uint8_t iopEnd[] asm("_binary_vtpooldata_iop_end");
	const size_t objectPoolSize = (iopEnd - iopStart) - 1;
	if (0 == objectPoolSize)
	{
		ESP_LOGI("UI Controller", "Failed to load object pool from vtpooldata.iop");
	}
	virtualTerminalClient->set_object_pool(0, isobus::VirtualTerminalClient::VTVersion::Version3, iopStart, objectPoolSize);

I think this should work in your case as well!
Note that I left out the hash_object_pool_to_version as I haven't used it on the ESP platform yet. For that to work you have to make a vector copy of the pool in memory (or @ad3154 we might be able to change the parameter of the hash function to a uint8_t pointer?).

I hope this helps! 😄

[thiagozf1]

Ok I've corrected it, thanks! I also had to change a few things to the pins configuration and than the driver worked properly.

And than later..

The loop was just for testing a thing, so that's ok. As I turned the logger on, after correcting the CAN issues, I got this log:

In the next hours I will be trying to solve this. If the pool shows up on the terminal, I will post the code here and mark as answer. I'm still accepting help here as I don't think it's going to work that soon sadly, but we are close.

[GwnDaan]

Hi @thiagozf1 , you could try to use the following as your g_config, it works for me at least:

static constexpr twai_general_config_t g_config = TWAI_GENERAL_CONFIG_DEFAULT(xBoardPins.xCan1Tx, xBoardPins.xCan1Rx, TWAI_MODE_NORMAL);

If that doesn't help, I'd also recommend verifying your cable isn't broken. That was the cause for me when receiving aborts, and it was driving me nuts hahah.

When that doesn't help either, a candump would be really useful to debug this. That is, if you have a linux based computer laying around that you are able to hook onto the canbus. 😄

[thiagozf1]

Hi guys. I've finally made it!! One week to understand why sometimes the CAN messages were being echoed.
Look at lines 15 and 16...

The driver echoed some of the TX messages and not the others, and that was driving me crazy. Today I've f*ck around a lot so I could find out, and than I discovered that some of the "twai_message_t" flags were not being initialized. So, sometimes the "self" flag had the value one and sometimes it had the value zero I guess. Than I set it to zero and that was it, the VT showed me "If you are seeing this, then you have successfully loaded an object pool to your VT!" :) I added the following lines (sided by a green bar) to the twai_plugin.cpp write_frame function:

On regards to the screen now. Should the buttons change the number at the center? I receive a response everytime I press the buttons but nothing happens.

[thiagozf1]

@GwnDaan and @ad3154 I have one more question here. Which software you guys use to create the objectpool (xml) and export it as .iop and .h? Currently I'm using the PoolEdit/PoolParser, but I don't know if it is going to work. i'll be trying in the next hours, but if you know a better option, please tell me!!!

[ad3154]

Hello again! I'm glad you're making progress. Yeah, the number is supposed to change when you press plus or minus, but that is dependent on if you keep around the return value of add_vt_soft_key_event_listener and add_vt_button_event_listener. Basically the code is setup to receive the responses as long as you keep around the return values of those functions. Generally for this project at least I'm using the free trial of Jetter ISO-Designer. I've started adding the classes needed to allow development of object pools programmatically here https://github.com/ad3154/Isobus-plus-plus/tree/vt-server-managed-working-set but they are still a work in progress.

[thiagozf1]

Hi guys, I made it work a while ago. Now that I understand a bit more of the code, I'll leave here my experience with your library :)
My objective here was to create a task capable of sending objectpools and dealing with the TCs. So basically my main.c runs this function to start up the task:

void IsobusPP_vInit(void)
    {
	InitializeEnumCases();
        if(xTaskCreate(taskIsobusPP, "IsobusPP", 5000, NULL, TASK_ISOBUS_PP_PRIORITY, NULL) != pdTRUE)
        {
            ESP_LOGE(TAG, "Failed to create IsobusPP task!");
        }
    }

The function taskIsobusPP is declared as static void taskIsobusPP(void* pvParameters), and it is basically the same main function of the examples, with only a little bit of exceptions.

static void taskIsobusPP(void* pvParameters)
{
    //==========CONFIG INIT START========

	std::shared_ptr<CANHardwarePlugin> canDriver = nullptr;
#if defined(ISOBUS_TWAI_AVAILABLE)
	canDriver = std::make_shared<TWAIPlugin>(&g_config, &t_config_250K, &f_config);
#endif

	if (nullptr == canDriver)
	{
		ESP_LOGE(TAG, "Unable to find a CAN driver. Please make sure you have one of the drivers installed with the library.");
	}

	isobus::CANStackLogger::set_can_stack_logger_sink(&logger);
	isobus::CANStackLogger::set_log_level(isobus::CANStackLogger::LoggingLevel::Debug); // Change this to Debug to see more information

	CANHardwareInterface::set_number_of_can_channels(1);
	CANHardwareInterface::assign_can_channel_frame_handler(0, canDriver);
                                 .
                                 .
                                 .

In this first part above, I set the CAN driver to work with the twai interface, as it was already being used in others parts of my code. It's important to set the values of g_config, t_config and f_config somewhere in the code. I used the following configuration:

static twai_timing_config_t t_config_250K = TWAI_TIMING_CONFIG_250KBITS();
// static twai_timing_config_t t_config_500K = TWAI_TIMING_CONFIG_500KBITS();
static twai_filter_config_t f_config = TWAI_FILTER_CONFIG_ACCEPT_ALL();
static twai_general_config_t g_config = {
    .mode = TWAI_MODE_LISTEN_ONLY,
    .tx_io = GPIO_NUM_NC,
    .rx_io = GPIO_NUM_NC,
    .clkout_io = TWAI_IO_UNUSED,
    .bus_off_io = TWAI_IO_UNUSED,
    .tx_queue_len = 16,
    .rx_queue_len = 32,
    .alerts_enabled = (TWAI_ALERT_ALL & ~(TWAI_ALERT_TX_IDLE | TWAI_ALERT_TX_SUCCESS)),
    .clkout_divider = 0,
	.intr_flags = 0,
};

Continuing taskIsobusPP, we define the CAN pins of the board and start the CAN interface like in the examples:

                                      .
                                      .
                                      .
// Enable transceiver
    gpio_set_level(xBoardPins.xStandby, 0);
    gpio_reset_pin(xBoardPins.xStandby);
    gpio_set_direction(xBoardPins.xStandby, GPIO_MODE_OUTPUT);

	g_config.rx_io = xBoardPins.xCan1Rx;
	g_config.tx_io = xBoardPins.xCan1Tx;
	g_config.mode = TWAI_MODE_NORMAL;

	if ((!CANHardwareInterface::start()) || (!canDriver->get_is_valid()))
	{
		ESP_LOGE(TAG, "Failed to start hardware interface. The CAN driver might be invalid.");
	}

	CANHardwareInterface::add_can_lib_update_callback(update_CAN_network, nullptr);
	CANHardwareInterface::add_raw_can_message_rx_callback(raw_can_glue, nullptr);

	std::this_thread::sleep_for(std::chrono::milliseconds(250));
                                      .
                                      .
                                      .

Then we define the ISO NAME and load the .iop file that you want to use. The way you load the file doesn't matter that much , it only needs to be able to fullfill the parameters of the set_object_pool method.

                                      .
                                      .
                                      .

        isobus::NAME DeviceNAME(0);

	//! Make sure you change these for your device!!!!
	//! This is an example device that is using a manufacturer code that is currently unused at time of writing
	DeviceNAME.set_arbitrary_address_capable(true);
	DeviceNAME.set_industry_group(1);
	DeviceNAME.set_device_class(0);
	DeviceNAME.set_function_code(static_cast<std::uint8_t>(isobus::NAME::Function::SteeringControl));
	DeviceNAME.set_identity_number(2);
	DeviceNAME.set_ecu_instance(0);
	DeviceNAME.set_function_instance(0);
	DeviceNAME.set_device_class_instance(0);
	DeviceNAME.set_manufacturer_code(64);

	const std::string &filename = "/outTemplate1.iop";
	EmbedFs_File_t xFsFile;

	if(EmbedFs_xGetFile(filename.c_str(), &xFsFile) != ESP_OK)
	{
		ESP_LOGE(TAG, "File '%s' not exist", filename.c_str());
	}
	else ESP_LOGI(TAG, "File '%s' loaded", filename.c_str());
                                       .
                                       .
                                       .

After this we create the control functions and the VT client to set the objectpool from the .iop file loaded. Before initializing the client, we set the callbacks functions that are going to be used (in my case, I wanted to take some actions when buttons were pressed and when a specific string had it value changed). Just a side note here, don't set the callbacks inside any scope, as they are held by shared pointers that would destroy the callback after exiting the scopes (I had accidentlly put then inside an else and lost a week trying to understand why the callbacks weren't working at all).

                                       .
                                       .
                                       .
        const isobus::NAMEFilter filterVirtualTerminal(isobus::NAME::NAMEParameters::FunctionCode, static_cast<std::uint8_t>                	 
        (isobus::NAME::Function::VirtualTerminal));
	const std::vector<isobus::NAMEFilter> vtNameFilters = { filterVirtualTerminal };
	
	std::shared_ptr<isobus::InternalControlFunction> TestInternalECU = std::make_shared<isobus::InternalControlFunction> 
        (DeviceNAME, 0x1C, 0);
	std::shared_ptr<isobus::PartneredControlFunction> TestPartnerVT = std::make_shared<isobus::PartneredControlFunction>(0,                                 	                
        vtNameFilters);

	TestVirtualTerminalClient = std::make_shared<isobus::VirtualTerminalClient>(TestPartnerVT, TestInternalECU);

	TestVirtualTerminalClient->set_object_pool(0, isobus::VirtualTerminalClient::VTVersion::Version3, xFsFile.pu8FileData, 
        xFsFile.u32FileLength);

	// auto softKeyListener = TestVirtualTerminalClient->add_vt_soft_key_event_listener(handleVTKeyEvents);
	auto buttonListener = TestVirtualTerminalClient->add_vt_button_event_listener(handleVTKeyEvents);
	auto changeStringListener = TestVirtualTerminalClient->add_vt_change_string_value_event_listener(handleVTChangeStringEvents);

	if (0 == xFsFile.u32FileLength)
	{
		ESP_LOGE(TAG, "Failed to load object pool from outTemplate1.iop");
	}
	else
	{
		TestVirtualTerminalClient->initialize(true);
	}
	

    //==========CONFIG INIT END==========

	esp_task_wdt_reset();
	vTaskDelay(pdMS_TO_TICKS(100));

	std::this_thread::sleep_for(std::chrono::milliseconds(20000));
	while(1)
	{
		// CAN stack runs in other threads. Do nothing forever.
		ESP_LOGW(TAG, "10 segundos para alarme");
		std::this_thread::sleep_for(std::chrono::milliseconds(15000));

		// TestVirtualTerminalClient->send_change_active_mask(WorkingSet_0, amAlarme);
	}

	TestVirtualTerminalClient->terminate();
	CANHardwareInterface::stop();    

        // Remove this task from watchdog
        esp_task_wdt_delete(NULL);
} // end of taskIsobusPP

And that is it :) I'll be leaving the code here if I wasn't clear in my explanations. Thanks for the support @ad3154 and @GwnDaan !!!! I wish a good luck to both of you, and please continue with the good work!!
Isobus_pp.zip