Refactored the lib to work on multiple platforms (the 2022 release though)

[Belal-Elshinnawey]

Hi,

4 years ago, I wanted to run this lib for testing some IR devices but I switched my platform from ESP32 to a Zephyr based one that was not supported in Arduino. Back then, I refactored the core library and LG + Samsung only to run on Zephyr. I did not release it and only used it as a debugging tool so I just kept it to myself. Now, I have a version that works for all the protocols listed at the 2022 release but its still private. Its built using only .C with no dynamic memory, it uses a context based API that keeps the state management in the user's code instead of the lib, and takes in the hardware layer as input functions so it technically compiles on most C compilers (although I only ran it on Zephyr based nRF and ESP32 processors). I am thinking of releasing it, but I don't want to take credit away from the people who did all the work decoding the protocols.

My questions are:
Is this interesting to you?
Does anyone maintaining this project want to control a specific way of how I should release it?
There are a lot of copy right [name] in the original code, and I rewrote it in C. So do I keep the copy rights or do you want your names taken out so it does not represent code you did not intend or want to write.

I want to release it, but I also want to keep the majority of credit on your side, so let me know how.

BR,
Belal

[NiKiZe]

If you have work based on someone else's you must keep any copyright notices. That is the law, at least in almost all countries.

But does the decoders need to be changed? It is hard to even discuss this without seeing the changes. So essentially you should always make a branch of you changes public, and then go from there on what can be merged and how.

If any major rewrite is done, I personally would like to see less ifdefs following
https://dox.ipxe.org/ifdef_harmful.html but thatmight require to much make logic.

[Belal-Elshinnawey]

Well, its a different language, so it is different.

as a user, you create contexts like this:

static ir_data_t ir_burst_buf[IR_BURST_CAP];

static ir_ac_protocol_t ir_ac = {0};

static ir_send_ctx_t ir_send_ctx = {
.pin = 0,
.modulation = true,
.dutycycle = 50,
.carrier_hz = 38000,
.burst_buf = ir_burst_buf,
.burst_cap = IR_BURST_CAP,
.burst_idx = 0,
.send_hal = NULL,
.hal_ctx = NULL,
};

ir_recv_ctx_t recv_ctx = {
.tolerance = 25,
.unknown_threshold = 12
};

you set your ir send function:
ir_set_send_hal(&ir_send_ctx, ir_send_hal, NULL);

and in your ir receive handler, you call decode as:
`

            recv_ctx.params.rawlen  = len;
	recv_ctx.params.rawbuf  = (uint16_t *)ir_rx_rawbuf;
	recv_ctx.params.bufsize = IR_RX_RAWBUF_SIZE;
	recv_ctx.params.overflow = (len >= IR_RX_RAWBUF_SIZE) ? 1 : 0;
	recv_ctx.params.rcvstate = 5;  

	memset(&results, 0, sizeof(results));
	results.rawbuf = (uint16_t *)ir_rx_rawbuf;
	results.rawlen = len;

	if (decode(&recv_ctx, &results, &save, 0, 0)) {
		print_buf[0] = '\0'; //Buffers are now passed by the user, no malloc
		resultToHumanReadableBasic(print_buf, sizeof(print_buf),
					   &results);

		state_t common;
		initStateObj(&common);
		if (decodeToState(&results, &common, NULL)) {
			char mode_str[16] = {0};
			char fan_str[16] = {0};
			opmodeToString(mode_str, sizeof(mode_str),
				       common.mode, false);
			fanspeedToString(fan_str, sizeof(fan_str),
					 common.fanspeed);

			LOG_INF("IR RX: %s", print_buf);
			LOG_INF("  Power:%s Temp:%dC Mode:%s "
				"Fan:%s SwingV:%d",
				common.power ? "ON" : "OFF",
				(int)common.degrees,
				mode_str, fan_str,
				(int)common.swingv);
		} else {
			LOG_INF("IR RX: %s", print_buf);
		}
	} else {
		LOG_INF("IR RX: UNKNOWN (%u raw samples)", len);
	}

`

All the states are managed by the user, so if you want multiple IR receiver/senders, its super easy, you just create different contexts.
You can also shut down the whole device and save the CTX to flash, and restore your library state the moment your device wakes up, which has been very helpful when debugging with a device that is mounted on an AC that requires a ladder to reach :).

Most importantly, the library contains no hardware specific code, so copying the lib to ESP-IDF or Zephyr or even compiling it in ubuntu is as easy as writing a makefile.

I will finish it up, then make a branch, I will just copy the copyright notices to their respective files and share it.

Although, I don't think its merge-able because its too many changes, so I recommend I separate branch for this variant of the lib.

As for ifdefs, I removed a bunch of compiler flags, the only one's I kept are in the decoder and sender (the big if send_[proto] then call protocol send function). I did not add conditional compilation to multiple platforms if that is your concern.

[NiKiZe]

I like the potential result, not the way to get there.
If it is to be useful in this library, it must be at least mostly workable with current interfaces, be it a compatibility layer or what not.

With offers, right now the support for send/receive is sprinkled all over.

[Belal-Elshinnawey]

Then, Why don't I make a separate repo, and link it here, and see if people want to collaborate to make the features in my version available in yours?

I will just give everyone who built this repo credit.

Since its not mergable anyway.

[crankyoldgit]

Hey, it looks impressive. I'm glad you intend to make it public. Good on ya. Huge effort. Your fork & work is how all of this community works. Well done. Go forth!

If you follow the license (see file), you should be fine.
The copyright & attribution need to remain.

This library itself was a fork of the original IRremote library. We kept & mentioned all the original authors & sources/library where practical & possible. Despite almost 95% of the library being rewritten. Because, that was the right & honorable thing to do. It's annoying in some ways, but that's how open-source works. We all are standing on the shoulders of those who did the work before us. The price of free is the license. People donate their time & effort knowing everyone can benefit, anyone can fork or modify it, but price is following the rules. As long as you do that, you're fine to do as you wish with it.

Good luck!

[Belal-Elshinnawey]

Thanks,

well, FYI: https://github.com/Belal-Elshinnawey/IR_Remote_Universal.git

here is my version if you are interested.