payano / mmesh Goto Github PK

Disband network.
generate a new address
set paired and connected to false.

https://controllerstech.com/low-power-modes-in-stm32/

Make a class of networkdata and move the NetHelper methods to the new class.

https://stackoverflow.com/questions/43781207/how-to-cross-compile-with-cmake-arm-none-eabi-on-windows

https://github.com/kontaktio/cmake-tools/blob/master/gcc-arm-embedded-toolchain.cmake

The nrf24 radio consumes around 15mA when in RX mode.
The stm32f103 circuit can be set to sleep mode and draw around 2uA.

If a battery has 2000mAh and the only consumer is the radio, it can drive the radio for around 133,3 hours.

Because of the battery consumption from the radio, there might be a good idea to have three nodes in the network:

• Master
• End device
• Router

The master is directly connected to a computer and gets its energy from there. A router is connected to the main lines and can have the radio in RX mode all the time. An End Device is a device that uses a battery is energy source, therefore its good to set that radio in sleep mode as much as possible.

NRF24L01 datasheet:
https://www.sparkfun.com/datasheets/Components/nRF24L01_prelim_prod_spec_1_2.pdf
It's good to know how to setup the data pipes for receiving and sending, pipe 0 is the broadcast address.

Information from tmrh20 blog, useful information to read up on:
http://tmrh20.blogspot.com/

NRF driver on github:
https://github.com/nRF24/RF24

Doxygen for the driver:
https://tmrh20.github.io/RF24/

The modified driver implementation is found here:
https://github.com/payano/mMesh/tree/master/src/network/RF24

The adapter is found here:
https://github.com/payano/mMesh/blob/master/src/network/Nrf24.cpp

The user of the adapter is found here:
https://github.com/payano/mMesh/blob/master/src/mesh/MeshNetworkHandler.cpp

https://github.com/rogerclarkmelbourne/Arduino_STM32/wiki/Programming-an-STM32F103XXX-with-a-generic-%22ST-Link-V2%22-programmer-from-Linux

Refactor this file.

If the child keepalive timer reaches 0, send a
disconnect to the child, and perhaps generate a new
host address so the child can't connect again?
The child will also have the timer.

https://github.com/nRF24/RF24
IRQ is not used, the library uses polling instead, this makes unnecessary traffic over SPI.

For communication we have structs on both sides.

https://kbiva.wordpress.com/2013/03/25/microsecond-delay-function-for-stm32/

Kicad is a good tool for this.

Investigate which encryption algorithm is best
suited for STM32F103C6T8, and (Arduino?), it
would be neat if it is easily portable.

Keeping the state machine in Mesh.cpp and the network_recv methods into another class.
A good name for the class might be MeshNetworkHandler.
The Mesh class could also be renamed to MeshSM, and perhaps create a new class Mesh which creates instances of both classes mentioned above.

If a child gets that message from a parent, the whole network downwards needs to be disbanded because the network does not have an address anymore and their default route is disbanded.
Therefore send disconnect requests downwards towards childs.

• Test cases for routing algorithm
• Mesh state machine
  ... And so on.

STM32, Raspberry PI, (Arduino?)

Something like: https://tutorialspoint.dev/language/c/convert-floating-point-number-string

It doesn't have to be fast because this is only used for debugging.

Update so routing of packets also can be sent sideways.

use printf methods so we can use standardized methods calls which will work for both linux and stm32

https://help.github.com/en/actions/hosting-your-own-runners/about-self-hosted-runners#self-hosted-runner-security-with-public-repositories

Under settings->actions->add-new-runner

Which have multiple stm32 connected via uart, jtag and usb dev.
Here we can monitor everything and see if a stm32 for example reaches an errornous state, we can get the state and hunt down the bug.

Ping parent. If parent doesn't respond after n tries,
send disconnect to children and get a generated address
and try to connect to network again.

And add the best NB's to the list of n NB's.

Integrate with an adapter so the mesh data structures can be read in the server.

Create sending requests via uart so we can ask the system for statistics and also change states of the application.

for example we should be able to mute the radio for testing the timeouts intervals.

For example:
Set good values when using armTimer and decreasing the values for childs and parent for disconnecting and sending new ping_parent_req messages.