3,430
edits
Changes
From Pumping Station One
→A Simple Example
There are 3 basic node types in things bus:
There are 3 basic node types in things bus:
* Sensors. Sensors produce data
* Sensors. Sensors produce data
* Actuators. Data Sinks consume data, and probably do something interesting with it.
* Actuators. Data Sinks consume data, and probably do something interesting with it.
* Neurons. Neurons take in sensory data, manipulate it in some way, and send the data to actuators.
* Neurons. Neurons take in sensory data, manipulate it in some way, and send the data to actuators.
=== Sensors ===
=== Sensors ===
A simple of an example of a sensor would be a temperature sense in the space. A temperature sensor would be a Raspberry Pi hooked into a temperature sense, and would send out the current temperature every 5 minutes.
A simple of an example of a sensor would be a temperature sense in the space. A temperature sensor would be a Raspberry Pi hooked into a temperature sense, and would send out the current temperature every 5 minutes.
Sensors make data available by using a zmq bind PUB socket.
Sensors make data available by using a zmq bind PUB socket.
=== Actuators ===
=== Actuators ===
An Actuator is something that, when triggered, does something. It doesn't have to be physical. An actuator could be as simple as an led wired into a Raspberry Pi that can be triggered by a Neuron.
An Actuator is something that, when triggered, does something. It doesn't have to be physical. An actuator could be as simple as an led wired into a Raspberry Pi that can be triggered by a Neuron.
Actuators consume data by using a zmq bind PULL socket
Actuators consume data by using a zmq bind PULL socket
There can be more complex arrangements, Neurons are free to communicate with other Neurons, and can trigger actuators without sensory input, and can read sensor data without actually forwarding it to an actuator.
There can be more complex arrangements, Neurons are free to communicate with other Neurons, and can trigger actuators without sensory input, and can read sensor data without actually forwarding it to an actuator.
Neurons consume information around by using zmq connect SUB sockets to sensors
* Neurons consume information from sensors by using zmq connect SUB sockets to sensors
Nuerons send information to actuators by using zmq connect PUSH sockets to actuators.
* Nuerons send information to actuators by using zmq connect PUSH sockets to actuators.
=== Mixed Mode and Multi Mode Nodes ===
=== Mixed Mode and Multi Mode Nodes ===
Examples:
Examples:
* A Dust Collection Node would likely be both a sensor (Is it on?) and an actuator (Turn it on)
* A Dust Collection Node would likely be both a sensor (Is it on?) and an actuator (Turn it on)
== A Simple Example ==
== A Simple Example ==
The following is an example of a Neuron. It connects to sensory input, the hackerpspace's front and back doors, and sense data to an actuator, zirc, an actuator that writes data to #pumpingstationone on irc.freenode.net
The following is an example of a Neuron. It connects to sensory input, the hackerpspace's front and back doors, and sense data to an actuator, zirc, an actuator that writes data to #pumpingstationone on irc.freenode.net
Before running the example, you must have a recent python, recent libzmq installed, and must have pyzmq installed.
Before running the example, you must have a recent python, recent libzmq installed, and must have pyzmq installed.
<syntaxhighlight lang="python">
#!/usr/bin/env python
import zmq
context = zmq.Context.instance()
# Create a zmq socket that will SUBscribe to door nodes.
door_socket = context.socket(zmq.SUB)
door_socket.connect("tcp://frontdoor.pumpingstationone.org:5556")
door_socket.connect("tcp://backdoor.pumpingstationone.org:5556")
# The doors send a lot of types of messages. We only care about "door.state.unlock" messages
door_socket.setsockopt(zmq.SUBSCRIBE, b"door.state.unlock")
# create a zmq socket that will PUSH data to our IRC actuator node.
zirc_socket = context.socket(zmq.PUSH)
zirc_socket.connect('tcp://sally.ad.pumpingstationone.org:5558')
# Loop forever
while True:
# Read messages from the doors
topic, message = door_socket.recv_multipart()
# Send the message to the irc channel
zirc_socket.send(message)
</syntaxhighlight>
== Hardware ==
== Hardware ==
We are targetting Beagle Bone Blacks for node hardware. While in theory, the hardware can be anything, having a consistent dev platform is useful.
We are targetting Beagle Bone Blacks for node hardware. While in theory, the hardware can be anything, having a consistent dev platform is useful.
The BBB has 2 blocks of GPIO lines, and the capability of supporting up to 4 Serial devices. A lot of the types of data we want to collect are available over gpio and serial.
The BBB has 2 blocks of GPIO lines, and the capability of supporting up to 4 Serial devices. A lot of the types of data we want to collect are available over gpio and serial.
==Things Bus Broker ==
== Things Bus Broker ==
For certain types of nodes, a broker that maintains state is useful.
For certain types of nodes, a broker that maintains state is useful.
For details of this system, see https://github.com/eastein/thingsbus
For details of this system, see https://github.com/eastein/thingsbus
== Inter-Node Communication ==
{{ambox
|type=content
|text=The code snippits contain errors
}}
The software for a node can be written in any language that supports zmq and json.
Nodes send messages using json data. Sensors use zmq PUB/SUB. Actuators use zmq PUSH/PULL. Neurons use whatever they have to do get the job done, which means they SUB to sensors, and PUSH to actuators.
=== Code Snippits ===
Sensors send data like this:
import zmq
context = zmq.Context.instance()
socket = context.socket(zmq.PUB)
socket.bind('tcp://*:5556')
socket.send_multipart(('dot.delimited.filter', '{"json":"message"}'))
Neurons receive data like this:
import zmq
context = zmq.Context.instance()
sensor = context.socket(zmq.SUB)
sensor.connect("tcp://sensor.tld:5556")
sensor.setsockopt(zmq.SUBSCRIBE, b"dot.delimited.filter")
topic, message = sensor.recv_multipart()
data = json.loads(message)
Neurons send data like this:
import zmq
context = zmq.Context.instance()
actuator = context.socket(zmq.PUSH)
actuator.connect('tcp://actuator.tld:5558')
actuator.send_json(data)
Actuators receive data like this:
import zmq
context = zmq.Context.instance()
socket = context.socket(zmq.PULL)
socket.bind('tcp://*:5558')
data = socket.recv_json()
== Existing Nodes ==
== Existing Nodes ==
