Telemetrix specific analog_input value report on demand ?

[xAht0x]

Is there a method for telemetrix to read ONLY ONE specific analog input reading upon request and only upon request?

The analog callback function currently spams my python script flow and is just a massive headache to work around.

Currently the way I understand how analog reading from Telemetrix works, is that I have to:

1. set_pin_mode_analog_input(pin, ...) for all my analog inputs (similar to what I would do on Arduino) - using 7 in total. A0 - A6
2. Either a) set pin specific callback function to each pin or b) have one callback for all pins.
   I have the latter.
3. Once analog_input is configured, Arduino starts to immediately spam the python script with readouts, ever increasing the report length when adding more analog input pins.

Yes, I could use 'differential' argument to stop spamming too early etc (but then I get no reading reports if analog input has seemingly not changed), maybe even build the entire script around individual callbacks per pin (less spamming from other pins, but report is still blocked by not enough differential change on the pin),
Thus the overall 'interrupt based' reporting is just invasive - awful to control and work around.
Or am I missing something ?

How I would see the analog reading should work (maybe as an addition to the current reporting mechanism):

1. set_pin_mode_analog_input() for all my analog inputs (similar to what I would do on Arduino).
2. I must send a command to Arduino to make me a current relevant measurement. Such as:
   board.analog_read(pin_number). (as I would do on Arduino)
3. Arduino does a simple analogRead() and only THEN reports the raw value back to me.
   Doesn't matter if the value has changed or not.

• It can be callback based, whatever, but I want to be sure that when I send telemetrix.analog_read(pin_A0), I get only A0 measurement result and end of callbacks ! No more callbacks generated after result has been provided. Only new callback when I request it, specifically.

I have done few workarounds myself in python but some odd cases always break the callback calling and I miss some readouts.

Can this be done right now? If not Just please guide me how could I achieve this right now or please find some way to implement this into the API.

[MrYsLab]

@xAht0x Thanks for the question. I will not be implementing a polling method since, in my experience, it leads to more problems than it solves. With the current method, each enabled analog input pin is polled within the Arduino sketch at 19ms per scan. This rate can be modified using the set_analog_scan_interval method. This assures that the likelihood of missing a data change is minimal. Polling the pin from the Python side is inefficient and more likely to lead to missed changes.

The callback method should be as short and as simple as possible. If you wish to supply your callback code, I would be happy to see if any improvements may be made.

If you want to modify Telemetrix, this article explains what is involved. If you have any questions, I would be happy to answer them.

[MrYsLab]

Pymata4 is an older and no longer supported library that allows you to do analog_reads without specifying a callback method. This may help solve your issue.

I am closing this discussion, but please ask questions anytime.

[xAht0x]

Yeah I noticed that, but that API doesn't have servo commands that I also use. So I decided to use Telemetrix. Thanks.

[MrYsLab]

Pymata4 does support servo. The commands are set_pin_servo and servo_write.
I've included an example here. (https://github.com/MrYsLab/pymata4/blob/master/examples/servo.py)

Just so you know, Pymata4 is also continuously receiving analog_input data reports, but it stores the latest values on the Python side. Calling analog_read returns both the last value and a timestamp as to when the change occurred. It is not sending out a separate command to the Arduino. Essentially, it allows you not to specify a callback method but internally uses the same mechanism as if a callback method was specified.

[xAht0x]

Aah silly me. I probably looked at the comparison table on telemetrix introduction page and understood that the 'standardFirmata' is the pymata implementation, since I was first coming over from pymata4 git page.

I will test with pymata, see what's the difference.
Thanks for the patience :)

[xAht0x]

Hei, thanks for looking into this.

@xAht0x Thanks for the question. [..] With the current method, each enabled analog input pin is polled within the Arduino sketch at 19ms per scan. [...]

Exactly! But,

Polling the pin from the Python side is inefficient and more likely to lead to missed changes.

I was not implying to have polling from python side. It's just that I'm expecting analog report only when I ask for it. Not to be spammed/interrupted by all other pins I have not asked for.

I was simply wondering, if it would be possible, to request for a specific analog pin read, so that Arduino calls the callback with that 19ms poll, get my result in callback, for that pin and then Arduino stops reporting - all by telemetrix.

So that I wouldn't need to write filters and double check the content of the callbacks in python to suppress ever increasing callback reports that I have not requested.

===============
I have a python script attached as a example, hopefully it shows how the callback just messes with the script flow.
I tested this on Arduino Mega but should work on any Arduino board with built-in LED on pin 13.
Sure, it's a bit of a mouthful to follow, (It's for a hardware testsystem, so it is built up in a certain way - I send a command and demand a result.)
analog_test.zip

The script runs a background task to blink an LED and then asks for certain analog pins for results.
During each read_analog() I have no other API command of reading the pin, so I have to set the pin to analog_mode which automatically starts the callbacks for that pin.

From terminal it can be seen that the read_analog gets wrong readings stored.

For example, first measurement all good:

Broken:

Trying to read A2 but callback is in A6 and stores that value, so callback is for the wrong pin at the time of reading A2.

Sure I could try and disable reporting after every pin result has been received, but that takes time and callback manages to be called quite a few times before I can suppress it. And yes, maybe in combination with interval I could decrease the frequency of the report, but then I have to wait on python for the callback to be called and again until correct pin is reported etc etc - just annoying.

Anyway, I have few ideas for a workarounds, until then, I hope this helps to illustrate my problem and hopefully this could be solved from API side - I currently don't have much time or interest to fiddle with the source.

[MrYsLab]

Thanks for the code, but it does not show your callback method, so I am not able to suggest a possible solution.
Do you have a persistent data structure for the current values for all the active analog input pins? If so, is this data structure accessible by the callback method? By having a persistent data structure, then when a report comes in, the data structure for that specific pin is updated with its associated reported value. You may then read the current value for any pin at any time. You may need to provide a data lock around the structure to prevent incorrect values being returned.

[xAht0x]

Please see Inside the Test() class

// Analog input callback function
def cb_analog_input_read(self, data):

It stores the data[] values into 'ADC_results' global dictionary.

I was first experimenting to store any value reported by the callback to be stored there, but I still want to have the measurement relevant to the time instance when I request that reading and not to rely on the callback frequency in the background - but that may just be my quirk on not trusting the reporting at any given time.

[MrYsLab]

I still don't understand this "mistrust" of the reporting data. I just measured the round-trip time to loop back a single character with Telemetrix using a Leonardo. That time is over 41ms. It would seem to me that there is a lot more time to lose a data change event using a polling scheme than the callback method that Telemetrix uses.

[xAht0x]

ah nvm the 'mistrust' it's just annoying to have callback functions in between script flow when I'm not requesting them and that I have to actively supress them. My expectation is that the callback is called 1. when I request it 2. when I configure the reporting so that it DOES report me after a set time interval (current option) all the time.

All I'm trying to do

1. I send a command such as read_analog_pin(pin)
2. telemetrix would then give me a reading on that pin -> either via callback... whatever, don't care. Here Telemetrix job is done.
   I would want to read one single pin, one time and no more callback reports.
3. I need the reading so I can progress further -yes main script waits for that measurement to finish It is very important.
   if the reading is off I stop the script. Do not care about other pins at that time.

Right now I'm writing a workaround.

1. Call set_pin_mode_analog_input() to all analog pins (to fill the telemetrix.analog_callback dictionary with all analog pins and start reporting them all).
2. cb_flag inside custom callback to allow storing a value only when I request it. otherwise callback is empty and terminates quickly.
3. sort out the useful reading from the callback:
   a) check that the callback is for the actual pin under interest. Ignore other callback triggers,
   b) Store the value under correct callback pin.
   c) then suppress ALL callback calling to stop spamming python script flow with empty callback calls.

Only then python script can make a decision from the analog measurement and decide to continue.
I don't care what happens to other measurements in between running the main script.

[xAht0x]

Looking into pymata4 implementation I think I now understand the miscommunication.

pymata and Telemetrix are built around the concept that 'when data changes, let me know'.
I ,on the other hand, expect 'when I ask, give me real-time data point'.

The pymata time.sleep(polling_time) method for me is silly as well - I don't think this is how it should be done anyways.
Why keep python polling for input !change! - i don't want that.
I want arduino to do the measurement when I ask for it and just return the value - doesn't matter if the value has actually changed or not

I don't know, I cannot describe this any more clearer.

For me, this settles it. I'm on my own and will continue with the workaround. I may post an example here once I solve this.

[xAht0x]

Got back to it after a while.
Posting my rough example .py with my callback implementations regarding this topic.
Works on Arduino Mega2560, no extra circuitry needed, other than voltage input to analog inputs.

Can play around with two callback methods:

1. cb_analog_input_read_avg()
   Takes 'average_count' amount of samples from a specified analog pin and returns an average value.
   Without currently knowing how to pass arguments via the callback function, the average sample count is controlled via global variables.

2. cb_analog_input_read_pin()
   Returns a real-time value of the requested pin at request and nothing else. Mutes the callbacks right after.

Callbacks should be changed inside read_analog() method.

Note:
I found a bug on Telemetrix4Arduino side as well. I wasn't able to read A15.
Had to change on Line 525:
#define MAX_ANALOG_PINS_SUPPORTED 15
to
#define MAX_ANALOG_PINS_SUPPORTED 16

Because mega has 16 analog pins, not 15. A0 - A15. The checks inside Telemetrix4Arduino were non-inclusive thus excluding pin 15.
At least this fixed it for me.

Thanks for the great software, works like a charm.
analog_test.zip

[MrYsLab]

I am glad things worked for you. Thanks for pointing out the 16 analog pins bug. I will be updating the sketch within the next couple of days.