ChipSAT Mesh Networking

• 

  Setup of slave, master nodes

• 

  Sending luminosity data from slave node 3

• 

  Receiving luminosity data at the master

Background

ChipSATs are tiny, gram-sized satellites designed to be deployed into space. They are able to be equipped with sensors such as a camera, spectrophotometer, or magnetometer, and can transmit and receive radio signals. They can also “sail” by tilting towards or away from the Sun. A current is run through a coil, turning the chip into a compass needle that aligns with Earth’s magnetic field, allowing the chipsat to control its orientation.

Because chipsats are small and cheap, they can be disposable sensors that could be sent on suicide missions to explore hostile environments, such as Saturn’s rings. Following the r-strategy employed by animals such as fish, they are designed to be released in large quantities from CubeSAT dispensers. While the survival rate of any one chip may be small, together there is a high likelihood they are able to transmit meaningful data.

Objective / project

We decided to to tackle the problem of consolidating data from a large swarm of chipsats, when not every chipsat can communicate directly to every other chipsat.

This is a relevant problem because of the environments they are deployed in, which cause problems such as:

• Individual chipsats may be easily destroyed, so relying on a master chipsat node means that if that chipsat is lost all data is lost.
• Uneven terrain means that there is no guarantee of good signal strength between any two chipsats.

Solving this problem means that chipsats would be able to share and synchronize data between each other in a swarm. This is useful, for example:

• Distributed processing and selecting of data while deployed, to reduce the transmission and thus power cost of every chipsat transmitting all their data back to ground.
• Coordinating positions and intended directions to allow a swarm to move as a swarm, and not be separated.
• Reaching consensus on a certain sensor measurement, decreasing the chance of faulty sensors or “lost” chipsats corrupting data.

Communication model

We divided the problem into three main tasks:

1. Communication (the ‘link layer’): how to send data directly between two chipsats which are in range of each other;
2. Routing (the ‘network layer’): how to send data collected from the chipsats to a ‘master’ node (either a ground station or a cubesat that is unlikely to be lost or destroyed);
3. Error resistance (the ‘transport layer’): making sure that all packets get delivered correctly when the network is unreliable.

Communication

Because CircuitPython, used for the chip, does not support multithreading, a half-duplex method of communication was needed.

Every regular node attempts to listen to and receive data at all times unless it just received something (e.g. a SYNC packet, or some data by another node). Then, it will send the data then go back to listening.

The master node is listening at all times for incoming data except when sending the SYNC packet.

Routing

We adopted a simple hierarchical routing system:

• Every node in the network has a ‘rank’ associated with it; informally, this represents the minimum number of hops needed to get a message back to the master node.
• This rank is established by a ‘sync’ packet, which is periodically broadcast by the master node. Each node that receives this updates its rank and rebroadcasts it with the rank increased by one. This packet then propagates throughout the entire network.
• To send data back to master, a node at layer n relays its data to the nodes at layer n - 1, who then relay it to layer n - 2, etc.

This hierarchical structure is needed when there is too long of a distance between the master and a node, or when one node can only reach another node because there is terrain obstructing the signal. For example, the structure might more realistically look like this:

So it is infeasible to send data directly to and from the master and some of the further nodes, or those blocked by terrain.

In our demo, we have used one of the chipsats as a master node. In practice, the master node would be a “ground” node or satellite. This allows us to assume that the master node is secure, and unlikely to be destroyed.

Error resistance

If one chipsat fails, a new route is automatically found to the master given one exists when the nodes with the data broadcast again. If a packet is lost, the same occurs.

Further work

Our work allows data to be transmitted by slave nodes and received by master nodes, while being resistant to signal strength loss (due to terrain, etc.) and individual nodes failing. Some packet loss resistance exists, because if a packet is lost but is received by at least one node, it is retransmitted.

Further work could involve investigating and detecting packet loss that corrupts the data. This could make use of error checking mechanisms similar to those used by TCP such as a checksum field or sequence numbers. Error-correcting mechanisms could also be used, such as cyclic redundancy checks or multi-dimensional parity check codes.

Another avenue that can be investigated was compressing the data. For example, multiple chipsats might be measuring spectroscopy data from the same location. Adding some type of processing or compression to the data would allow the transmissions to require less power.

Finally, an inherent limitation of chipsats is that they cannot listen and receive at the same time because they can only have one thread. Investigating the effect of very large swarms or very long messages on the frequency of messages lost because nodes cannot be listening while they are transmitting the messages may be useful before deploying this.

Built With

• circuitpython
• graphs
• python
• radio-transmission
• sensor
• soldering