digital | Boston javascript webapps managed by DoIT Digital Team | Dataset library

Ok, the signature container is embedded correctly.

But there are issues with the signature container itself:

• Both in the SignedData.digestAlgorithms collection and in the SignerInfo.digestAlgorithm value you have used the OID of SHA1withRSA, but that is a full signature algorithm, not the mere digest algorithm SHA1 expected there.

• Then the SHA1 hash of the signed bytes is BB78A402F7A537A34D6892B83881266501A691A8 but the hash you signed is 90E28B8A0D8E48691DAFE2BA10A4761FFFDCCD3D. This might be because you hash buffer2 and

  buffer2 has empty contents data (/Contents <>)

  The hex string delimiters '<' and '>' also belong to the contents value and, therefore, must also be removed in buffer2.

Furthermore, your signature is very weak:

• It uses SHA1 as hash algorithm. SHA1 meanwhile has been recognized as too weak a hash algorithm for document signatures.
• It doesn't use signed attributes, neither the ESS signing certificate nor the algorithm identifier protection attribute. Many validation policies require such special attributes.

You're using wrong hardware & software for the job. Jetson Nano can be considered as a full featured PC. As I understand, it's suitable for high level algorithms, image processing and neural network evaluation. Bare metal programming does not make much sense for this kind of devices, hence you have Linux running on it. You need to be aware that in the presence of a non real-time operating system, you can't get reliable delay times.

Reading a quadrature encoder is low level task with strict hard real-time requirements. For this, you need microcontrollers (like PIC, AVR, ARM Cortex M), C/C++, bare-metal programming or an RTOS, and preferably dedicated hardware which is capable of reading quadrature encoders directly.

Polling input pins isn't the correct way of interfacing encoders. Keep it in mind that you need to poll the pins much faster than the expected pulse frequency. In microcontrollers, you use interrupts instead which saves you from polling. Even interrupts can't keep up with high resolution & fast turning encoders. When interrupts don't suffice, you need dedicated encoder interfacing hardware which counts pulses automatically for you.

The best thing you can do is picking a microcontroller and outsourcing the encoder counting job to it. As your encoder resolution is low, you don't need special quadrature interface hardware modules. You can just pick an Arduino and make it count pulses. Then your Jetson Nano can query Arduino using serial port, I2C or SPI to retrieve the up-to-date pulse count.

I would try the following:

Since HAL_SPI_Receive is already using HAL_SPI_TransmitReceive (github stm32f4 spi driver) to send dummy data to generate clock, you can use that fact and ditch the HAL_SPI_Transmit, and use the receive function like this:

You need to reconsider the way you deal with the word lists and the pattern you use.

Here is a possible solution with the regular re package:

This might help....

There is an open issue on how Azure hosted agents authenticate back to ADO using the az-pipelines command.

Feel this is related but if it's not feel free to respond and I'll remove the answer.

You should check your Node version on the server. Most probably it's older and you're using ES6 exports.

If you got the right version that supports ES6, then you should make sure you've enabled that (as CommonJS is the default option). From the docs:

• Files ending in .mjs.

• Files ending in .js when the nearest parent package.json file contains a top-level "type" field with a value of "module".

• Strings passed in as an argument to --eval, or piped to node via STDIN, with the flag --input-type=module.

Does the library auto-assign the slave number, or we have to define it?

With MinimalModbus you pass the slave ID through in the minimalmodbus.Instrument('/dev/ttyUSB0', 1) call (the 1 is the Slave ID). How you set the slave ID on the device itself varies (this is not covered by the Modbus over serial line spec; could be a configuration program, DIP switches, based on the serial number etc. Other libraries may take different approaches (for example defaulting to Slave ID 1).

From the datasheet, is it the register number is the address?

The header in the spec tables says "No(Address)" so "10001(0000)" means register 1, address 0 (these refer to the same thing; I recommend reading the "Modbus: When 40001 Really Means 1, or 0 Really Means 1" section in this article which explains some of the issues around addressing).

And how many decimals do I expect if there's two data sequence as a response?

Not quite sure what you mean by "two data sequence". The Modbus spec only details the sending of bits (coils) and 16 bit values (input/holding registers). From a quick look at your spec it looks like this device just uses a single registers; for instance "OUT1 Output time" has "unit: ×10㎳" so take whatever is in the register and divide by 10 to get ms.

Is the CRC16 check already included within the library as i shouldn't code it?

Any decent Modbus library will look after the protocol details (such as CRC) for you (so no you don't need to code this; MinimalModbus will calculate it for you)

Since you have the value returned by the Arduino in a variable, you can use it in your If statement: