Why do digitalRead/analogRead turn reporting pins on?

[PKGeorgiev]

I'm really confused of how digitalRead/analogRead work.
In fact these two turn pin reporting on. In case of analogRead it floods host app with data.
On the other hand, digitalRead's callback is only called on value change. In Arduino *Read() means "single read". May be names are confusing.
One would expect simple flow:

digitalRead > sendPaketToArduino > digitalRead(port) /Arduino side/ > sendDigitalResponse > invokeCallback

The same applies to analogRead.
Now digitalRead is just: "reportDigitalPortChanges" and analogRead is: "turnOnAnalogPinReporting". This makes NodeJs app's flow much more complicated. For example - a trivial task - how can we read single port value?

Also, digitalWrite/analogWrite should execute callback so there is feedback from the write requests. Now it is like "fire and forget". Current implementations assume digitalWrite/analogWrite will succeed. But that's not always the case - for example communication failure.

Following NodeJs recommendations, at the end every function should start a callback with an error var as first parameter.

[soundanalogous]

Firmata does not report digital or analog pin changes unless pin reporting is enabled. This is to prevent flooding the host with unwanted data. In some firmata host libraries it is up to the user to enable pin reporting separately, but for firmata.js a decision was made to simplify this for the user and enable reporting only when a digital read or analog read request is sent.

I agree that digitalRead and analogRead are misleading choices of method names for wrapping the DIGITAL_MESSAGE or ANALOG_MESSAGE in any Firmata host library because they do not function like the Arduino/Wiring equivalent. They should really be named something like startDigitalRead and startAnalogRead since that is what the actual behavior is. They could then be complimented with stopDigitalRead and stopAnalogRead. There is an addendum to the Firmata protocol that would add the ability for a true digitalRead or analogRead (as in read the specified pin only once) but it is a less efficient approach than using the reporting methods.

Regarding digitalWrite and analogWrite, the Firmata protocol does not ACK writes. Theoretically you could using the pin state query, but that is another round trip from the host to the firmware and back.

[soundanalogous]

@rwaldron FYI about method names. It may be worth making a change like this at some point and deprecating digitalRead and analogRead. Or at least better explaining how those methods actually function. I'm starting to see a wave of people who started with Arduino and are now exploring Firmata hosts (firmata.js, johnny-five), etc. They are confused by the similar Wiring API but different functionality.

[PKGeorgiev]

@soundanalogous thank you for your fast response. Better explanation would be very helpful. I spent a few hours trying to understand "what happens here".
My case is simple: I look for strong protocol for communication between host and Arduino. Firmata looks promising. I come from a "transactional world" and I expected to see request/response like style APIs. Adding single query/response to the library will be very helpful. I get the "big picture" now, but I was confused by method naming and different behavior on each platform.

[troywweber7]

I'd like to know how to get a single read out of an analog pin every 1 second. I can't see any way to stop the analog reading, and as mentioned, it just floods the serial line unnecessarily. Ideas?

[rwaldron]

You can change speed of the polling interval:

board.setSamplingInterval(1000);

[troywweber7]

Excellent, thank you! I presume there is a command to stop the reading
altogether and I probably just need to look in the code harder to find it?

On Sep 22, 2016 10:56 AM, "Rick Waldron" notifications@github.com wrote:

You can change speed of the polling interval:

board.setSamplingInterval(1000);

—
You are receiving this because you commented.
Reply to this email directly, view it on GitHub
#127 (comment),
or mute the thread
https://github.com/notifications/unsubscribe-auth/AEi5G0vD8HZnFZTDlRCnK5XxyN4stYX5ks5qssFXgaJpZM4IyOQi
.

[troywweber7]

I think I found it. I presume I can just use

board.reportDigitalPin(14,0);

To turn off the reporting on digital pin 14.

[bsefton]

I am having a problem using analogRead with firmata. I am running firmata on a Yun shield runnng OpenWRT Linux with node.js and firmata. Everything is installed correctly, and I was able to create an LED blink program and add web based on/off to it based on values passed through the url.

I am now trying to do an analogRead and am getting nowhere. THis doesnt seem to work despite trying lots of attempts. Does anyone have, or know where I can get a javascript code snippet which uses firmata and shows how to do an analogRead? I am trying to read a dht11 temp and humidity sensor and display the output via console.log as a basic test. The data output pin is on A0.

THanks

[soundanalogous]

DHT11 is digital not analog so that may be part of the issue. There is actually no way to read that sensor directly with firmata.js since it uses a custom protocol that is not supported by Firmata. You have to use an I2C backpack or modified version of Firmata that provides DHT11 support.

Regarding how to read an analog input with firmata.js, you simply do this:

var Board = require("firmata");
Board.requestPort(function(error, port) {
  if (error) {
    console.log(error);
    return;
  }
  var board = new Board(port.comName);
  board.on("ready", function() {
    this.pinMode(0, this.MODES.ANALOG);
    // read pin A0
    this.analogRead(0, function(value) {
      console.log(value);
    });
  });
});

[bsefton]

Thanks, I got it working with the following code in case anyone is interested. You are right the DHT11 is digital and gives a numeric value. Adding the board.setSamplingInterval(1000); line reduces the output to one value per second. The specification of the serial port like this is the only way I could find to make this work on a Dragino (yun shield) on an Uno. It is configured like this tutorial (however I did not install and am not using cyclon.js) https://cylonjs.com/documentation/platforms/yun/
This code may be only relevant for those runing yun or dragino on Uno, but it works.

var serialport = require('serialport');
var sp = new serialport.SerialPort('/dev/ttyATH0', {baudrate:57600});
var firmata = require('firmata');
var board = new firmata.Board(sp, function(err) {
if (err) {
console.log(err);
board.reset();
return;
}
console.log('connected...');
console.log('board.firmware: ', board.firmware);
board.setSamplingInterval(1000);
board.analogRead(0, function(val) {
console.log(val);
});
});

[soundanalogous]

That cylonjs article references a really old version of StandardFirmata (from 2011). This newer one should be used instead: https://github.com/firmata/StandardFirmataYun.

[gkzsolt]

I'd like to return to @PKGeorgiev 's opening comment:

I'm really confused of how digitalRead/analogRead work.
In fact these two turn pin reporting on. In case of analogRead it floods host app with data.
On the other hand, digitalRead's callback is only called on value change. In Arduino *Read() means "single read". May be names are confusing.
One would expect simple flow:
digitalRead > sendPaketToArduino > digitalRead(port) /Arduino side/ > sendDigitalResponse > invokeCallback
The same applies to analogRead.
Now digitalRead is just: "reportDigitalPortChanges" and analogRead is: "turnOnAnalogPinReporting". This makes NodeJs app's flow much more complicated. For example - a trivial task - how can we read single port value?

I completely agree. There are 2 issues here:

(1) reading a pin
(2) reporting pin value changes

Reading a pin (1) is done by digitalRead() or analogRead() on the Arduino and provide a simple direct pin read. If we are interested only in pin changes (2) then we'll use a function or library which stores a pin's state, reads the pin regularly and reports the state change. For example, the Bounce library's rose() function returns true if signal transitions from low to high (and fell() does the reverse).
(1) and (2) are 2 different functions: the second is the derivative of the first with respect to time.

Now Firmata seems to have implemented only the derivative while keeping the original function name. This is extremely confusing. Some library providers followed this. Johnny-Five board API informs us that:

digitalRead(pin, handler(value))
Register a handler to be called whenever the board reports the value (0 or 1) of the specified digital pin.

No, please. This should be called onPinChange, onDigitalPinChange, or something similar, but in neither case digitalRead. Neither can I agree with startDigitalRead, because it is not a read what we'll get in the callback. The handler will be called only if the pin state changes (and not on all pin reads), and this should be reflected in the name, to be clear. That's about the naming.

On the other hand, I took for granted that a communication library can read pin states, glancing through the API calls reassured me on that so it came as a big surprise that it cannot. Direct digital- and analogRead calls are basic and I'd expect Firmata to do also this. To infer a pin state from its derivative (by storing an initial value and then integrating the changes) is very costly for such a trivial task.

So I'd expect a digitalRead(pin, callback) to read the pin, then send the value back to notify a registered once listener for the callback (of course the naming is problematic due to legacy issues, so some plan should be made.)

A similar behaviour would be logical for analogRead. This seems to do a real analog read ;), so the function itself and not the derivative - but only if reportAnalog was enabled, when it is reporting the value steadily at the set frequency rate. Then reportAnalog should be stopped by the client. Well, this matches well the way I'd use it, so I'll not complain here ;) A question here: is analogReference() implemented in Firmata? (it may be an Arduino-specific call, but how to handle this?)

@PKGeorgiev, I don't think digitalWrite/analogWrite should execute callback so there is feedback from the write requests. There is no feedback from the Arduino itself, so this would hardly be possible. You can do a read afterwards (if digitalRead() was implemented ;) if you want to be sure the command has completed (at least as regarding digitalWrite. I don't know much about analogWrite.)

I hope these make sense.

[soundanalogous]

The Firmata protocol makes no claim to being a wrapper for the Arduino/Wiring api. It actually makes no claim to being exclusive to Arduino either. It is a general protocol for communicating with microcontrollers that could theoretically be implemented on any microcontroller platform.

There is also no requirement in the Firmata protocol that analog pin reporting or digital port reporting should be enabled automatically when sending a read request.

A question here: is analogReference() implemented in Firmata?

Not currently. I had submitted a proposal a couple of years ago, then ran into a technical issue with the implementation (it was difficult to handle the differences between the AVR and SAM architectures but Arduino has since added constants to make that easier to deal with).

[soundanalogous]

Direct digital- and analogRead calls are basic and I'd expect Firmata to do also this.

Please submit a proposal to add such functionality: https://github.com/firmata/protocol/issues.

I could see a message to query an analog pin value to be useful (rather than relying purely on analog reporting). However I don't see any real good use cases for a way to query a digital pin value, mostly because of the latency involved in the round trip transmissions and you'd typically want the digital value asap. However if there are real uses cases other than a purely semantic advantage I could be convinced otherwise.

[gkzsolt]

What about the naming? How are we supposed to get the value of a pin?