zeus
3 years ago
10 changed files with 1315 additions and 3 deletions
@ -0,0 +1,5 @@ |
|||
name: swarmlab_poc-datacollector |
|||
title: swarmlab_poc-datacollector |
|||
version: docs |
|||
nav: |
|||
- modules/ROOT/nav.adoc |
|||
|
After Width: | Height: | Size: 80 KiB |
@ -0,0 +1,2 @@ |
|||
* xref:index.adoc[Sensor mode] |
|||
* xref:index-imu.adoc[node IMU] |
|||
@ -0,0 +1,505 @@ |
|||
= Sensor node IMU |
|||
|
|||
|
|||
.The typical architecture of the sensor node |
|||
image::ROOT:sensorNode.jpg[alt="The typical architecture of the sensor node"] |
|||
|
|||
The main components of a sensor node are a **microcontroller**, **transceiver/Communication Module**, **memory**, **power source** and one or more **sensors.** |
|||
|
|||
== Sensor node example using IMU sensors |
|||
|
|||
A basic IMU (Intertial Measurement Unit) generally provides raw sensor data, whereas an AHRS takes this data one step further, converting it into heading or direction in degrees, converting the raw altitude data into standard units like feet or meters, etc. |
|||
|
|||
.AHRS (Attitude and Heading Reference System) |
|||
[NOTE] |
|||
==== |
|||
An attitude and heading reference system (AHRS) consists of sensors on three axes that provide attitude information for aircraft, including roll, pitch and yaw. These are sometimes referred to as MARG (Magnetic, Angular Rate, and Gravity) sensors and consist of either solid-state or microelectromechanical systems (MEMS) gyroscopes, accelerometers and magnetometers. They are designed to replace traditional mechanical gyroscopic flight instruments. |
|||
[More Info]https://en.wikipedia.org/wiki/Attitude_and_heading_reference_system[^] |
|||
==== |
|||
|
|||
=== IMU |
|||
|
|||
image::ROOT:sensors_1604_LRG.jpg[alt="Adafruit 10-DOF IMU Breakout"] |
|||
|
|||
Adafruit's 10DOF https://en.wikipedia.org/wiki/Degrees_of_freedom[(10 Degrees of Freedom)^] breakout board allows you to capture ten distinct types of motion or orientation related data. |
|||
|
|||
|
|||
- LSM303DLHC - a 3-axis accelerometer (up to +/-16g) and a 3-axis magnetometer (up to +/-8.1 gauss) on a single die |
|||
- L3GD20 - a 3-axis gyroscope (up to +/-2000 dps) |
|||
- BMP180 - A barometric pressure sensor (300..1100 hPa) that can be used to calculate altitude, with an additional on-board temperature sensor |
|||
|
|||
=== Connecting It Up |
|||
|
|||
Basic Setup |
|||
|
|||
- Connect the **SCL** pin on the breakout to the **SCL** pin on your Arduino. On an UNO & '328 based Arduino, this is also known as **A5** |
|||
- Connect the **SDA** pin on the breakout to the **SDA** pin on your Arduino. On an UNO & '328 based Arduino, this is also known as **A4** |
|||
- Connect the **VIN** pin on the breakout to **3.3V** or **5V** on your Uno (5V is preferred but if you have a 3V logic Arduino 3V is best) |
|||
- Connect the **GND** pin on the breakout to the **GND** pin on your Uno |
|||
|
|||
That's it! With those four wires, you should be able to talk to any of the I2C chips on the board and run any of the example sketches. |
|||
|
|||
|
|||
image::ROOT:sensors_10dofwire.jpg[alt="Connecting"] |
|||
|
|||
Advanced Setup |
|||
|
|||
- **GINT** - The interrupt pin on the L3GD20 gyroscope |
|||
- **GRDY** - The 'ready' pin on the L3GD20 gyroscope |
|||
- **LIN1** - Interrupt pin 1 on the LSM303DLHC |
|||
- **LIN2** - Interrupt pin 2 on the LSM303DLHC |
|||
- **LRDY** - The ready pin on the LSM303DLHC |
|||
|
|||
These pins are all outputs from the 10-DOF breakout and are all 3.3V logic |
|||
|
|||
|
|||
=== Downloading Libraries |
|||
|
|||
Place the files in the Arduino Sketch Folder '/libraries' sub-folder. You should end up with a structure like this: |
|||
|
|||
- arduinosketches/libraries/Adafruit_10DOF |
|||
- arduinosketches/libraries/Adafruit_BMP085 |
|||
- arduinosketches/libraries/Adafruit_L3GD20_U |
|||
- arduinosketches/libraries/Adafruit_LSM303DLHC |
|||
- arduinosketches/libraries/Adafruit_Sensor |
|||
|
|||
.Arduino libraries |
|||
[NOTE] |
|||
==== |
|||
Arduino libraries are a convenient way to share code such as device drivers or commonly used utility functions. |
|||
https://learn.adafruit.com/adafruit-all-about-arduino-libraries-install-use[How to install Arduino libraries^] |
|||
==== |
|||
|
|||
=== Example Sketch |
|||
|
|||
==== pitch & roll |
|||
|
|||
|
|||
.sketch pitchrollheading |
|||
[source,c] |
|||
---- |
|||
sensors_event_t accel_event; |
|||
sensors_vec_t orientation; |
|||
|
|||
/* Calculate pitch and roll from the raw accelerometer data */ |
|||
accel.getEvent(&accel_event); |
|||
if (dof.accelGetOrientation(&accel_event, &orientation)) |
|||
{ |
|||
/* 'orientation' should have valid .roll and .pitch fields */ |
|||
Serial.print(F("Roll: ")); |
|||
Serial.print(orientation.roll); |
|||
Serial.print(F("; ")); |
|||
Serial.print(F("Pitch: ")); |
|||
Serial.print(orientation.pitch); |
|||
Serial.print(F("; ")); |
|||
} |
|||
---- |
|||
|
|||
|
|||
image::ROOT:800px-Flight_dynamics_with_text.png[alt="pitchroll"] |
|||
|
|||
Arguments |
|||
|
|||
- event: The **sensors_event_t** variable containing the data from the **accelerometer** |
|||
- orientation: The **sensors_vec_t** object that will have its **.pitch** and **.roll** fields populated |
|||
|
|||
Returns |
|||
|
|||
- **true** if the operation was successful, |
|||
- **false** if there was an error |
|||
|
|||
|
|||
image::ROOT:piandrroll.png[alt="pitchroll"] |
|||
|
|||
|
|||
|
|||
|
|||
== A real AHRS system |
|||
|
|||
|
|||
=== Loading the AHRS Sketch |
|||
|
|||
.AHRS Sketch |
|||
[source,c] |
|||
---- |
|||
#include <Wire.h> |
|||
#include <Adafruit_Sensor.h> |
|||
#include <Adafruit_LSM303_U.h> |
|||
#include <Adafruit_BMP085_U.h> |
|||
#include <Adafruit_Simple_AHRS.h> |
|||
|
|||
// Create sensor instances. |
|||
Adafruit_LSM303_Accel_Unified accel(30301); |
|||
Adafruit_LSM303_Mag_Unified mag(30302); |
|||
Adafruit_BMP085_Unified bmp(18001); |
|||
|
|||
// Create simple AHRS algorithm using the above sensors. |
|||
Adafruit_Simple_AHRS ahrs(&accel, &mag); |
|||
|
|||
// Update this with the correct SLP for accurate altitude measurements |
|||
float seaLevelPressure = SENSORS_PRESSURE_SEALEVELHPA; |
|||
|
|||
void setup() |
|||
{ |
|||
Serial.begin(115200); |
|||
Serial.println(F("Adafruit 10 DOF Board AHRS Example")); Serial.println(""); |
|||
|
|||
// Initialize the sensors. |
|||
accel.begin(); |
|||
mag.begin(); |
|||
bmp.begin(); |
|||
} |
|||
|
|||
void loop(void) |
|||
{ |
|||
sensors_vec_t orientation; |
|||
|
|||
// Use the simple AHRS function to get the current orientation. |
|||
if (ahrs.getOrientation(&orientation)) |
|||
{ |
|||
/* 'orientation' should have valid .roll and .pitch fields */ |
|||
Serial.print(F("Orientation: ")); |
|||
Serial.print(orientation.roll); |
|||
Serial.print(F(" ")); |
|||
Serial.print(orientation.pitch); |
|||
Serial.print(F(" ")); |
|||
Serial.print(orientation.heading); |
|||
Serial.println(F("")); |
|||
} |
|||
|
|||
// Calculate the altitude using the barometric pressure sensor |
|||
sensors_event_t bmp_event; |
|||
bmp.getEvent(&bmp_event); |
|||
if (bmp_event.pressure) |
|||
{ |
|||
/* Get ambient temperature in C */ |
|||
float temperature; |
|||
bmp.getTemperature(&temperature); |
|||
/* Convert atmospheric pressure, SLP and temp to altitude */ |
|||
Serial.print(F("Alt: ")); |
|||
Serial.print(bmp.pressureToAltitude(seaLevelPressure, |
|||
bmp_event.pressure, |
|||
temperature)); |
|||
Serial.println(F("")); |
|||
/* Display the temperature */ |
|||
Serial.print(F("Temp: ")); |
|||
Serial.print(temperature); |
|||
Serial.println(F("")); |
|||
} |
|||
|
|||
delay(500); |
|||
} |
|||
---- |
|||
|
|||
=== compile |
|||
|
|||
- Compile the sketch, |
|||
- open up the Serial Monitor (Tools > Serial Monitor), |
|||
- set the baud rate to 115200 |
|||
|
|||
|
|||
.output |
|||
image::ROOT:sensors_01_AHRSOutput.png[alt="AHRS raw data"] |
|||
|
|||
This raw data shows the main orientation data, consisting of 'roll', 'pitch' and 'heading' (or 'yaw) in degrees, followed by the current altitude and temperature |
|||
|
|||
|
|||
|
|||
=== Using AHRS Data |
|||
|
|||
The AHRS sketchs reads raw data from the board's accelerometer/magnetometer and converts the raw data into easy to understand **Euler angles.** |
|||
|
|||
In this case, we can see that the **roll is about 18°**, the **pitch is about 78°** and the **heading or yaw is about 32°**, and the sketch will keep updating itself with the latest values at whatever speed we've set in the sketch. |
|||
|
|||
[NOTE] |
|||
==== |
|||
.Euler angles, one of the possible ways to describe an orientation |
|||
image::ROOT:Eulerangles.svg.png[alt="Euler angles"] |
|||
|
|||
The first attempt to represent an orientation is attributed to Leonhard Euler. He imagined three reference frames that could rotate one around the other, and realized that by starting with a fixed reference frame and performing three rotations, he could get any other reference frame in the space (using two rotations to fix the vertical axis and other to fix the other two axes). The values of these three rotations are called Euler angles. |
|||
|
|||
.Tait–Bryan angles, another way to describe orientation |
|||
image::ROOT:Taitbrianzyx.svg.png[alt="Tait–Bryan angles"] |
|||
|
|||
These are three angles, also known as yaw, pitch and roll, Navigation angles and Cardan angles. Mathematically they constitute a set of six possibilities inside the twelve possible sets of Euler angles, the ordering being the one best used for describing the orientation of a vehicle such as an airplane. In aerospace engineering they are usually referred to as Euler angles. |
|||
|
|||
https://en.wikipedia.org/wiki/Rigid_body_dynamics[More Info: Rigid_body_dynamics^] |
|||
|
|||
https://en.wikipedia.org/wiki/Euler_angles[More Info: Eulers angles^] |
|||
|
|||
https://en.wikipedia.org/wiki/Leonhard_Euler[Leonhard Euler^] |
|||
==== |
|||
|
|||
|
|||
=== Save/Sending the Data |
|||
|
|||
This raw data can then be sent over the network to the central application. |
|||
|
|||
This will be the subject of another Lab Lesson |
|||
|
|||
=== Visualizing Data |
|||
|
|||
|
|||
|
|||
==== The tools, languages, and frameworks |
|||
|
|||
===== Three.js |
|||
|
|||
**Three.js** is a cross-browser JavaScript library and Application Programming Interface (API) used to create and display animated 3D computer graphics in a web browser. Three.js uses WebGL. |
|||
|
|||
|
|||
===== Processing |
|||
|
|||
**Processing** is an open-source graphical library and integrated development environment (IDE) built for the electronic arts, new media art, and visual design communities with the purpose of teaching non-programmers the fundamentals of computer programming in a visual context. |
|||
|
|||
Processing uses the Java language, with additional simplifications such as additional classes and aliased mathematical functions and operations. It also provides a graphical user interface for simplifying the compilation and execution stage. |
|||
|
|||
The Processing language and IDE were the precursor to other projects including Arduino, Wiring and p5.js. |
|||
|
|||
===== p5.js |
|||
|
|||
In 2013, Lauren McCarthy created p5.js, a native JavaScript alternative to Processing.js that has the official support of the Processing Foundation. |
|||
|
|||
===== Processing.py |
|||
|
|||
Python Mode for Processing, or Processing.py is a Python interface to the underlying Java toolkit. It was chiefly developed by Jonathan Feinberg starting in 2010, with contributions from James Gilles and Ben Alkov |
|||
|
|||
|
|||
|
|||
[NOTE] |
|||
==== |
|||
**ThreeJS** is a wrapper around the browser’s native WebGL API. It’s the de facto standard 3D library — there are others, like BabylonJS, but Three is just miles more popular. The native browser APIs are… painful to work with, you can think of ThreeJS kinda like a jQuery for in-browser 3D graphics. Doesn’t give you anything that’s not already there, it just wraps it all into a user-friendly API |
|||
|
|||
**P5** is not a 3d graphics library, it’s an API for doing creative coding: things like procedural generation, natural simulations etc. It has some 3D features because it wraps the native WebGL API, but that’s not it’s core purpose. It is a artistic and teaching tool — it is occasionally used in production outside of artistic audio/visual stuff, but not often. It’s basically the JS version of Processing. |
|||
|
|||
==== |
|||
|
|||
https://www.slideshare.net/victorporof/processingjs-vs-threejs[More: Processing.js vs. three.js^] |
|||
|
|||
|
|||
==== Requirements |
|||
|
|||
To visualize the data, we've put together a basic **Processing** sketch that loads a 3D model and renders it using the data generated by the AHRS sketch. |
|||
|
|||
- https://processing.org/[Processing^] |
|||
- https://code.google.com/archive/p/saitoobjloader/#Download[OBJ Loader library for Processing^] |
|||
- http://www.lagers.org.uk/g4p/[G4P GUI library for Processing^] |
|||
|
|||
[NOTE] |
|||
==== |
|||
The OBJ library is required to load 3D models. It isn't strictly necessary and you could also render a boring cube in Processing, but why play with cubes when you have rabbits?! |
|||
==== |
|||
|
|||
|
|||
==== Write the Processing Sketch |
|||
|
|||
.Processing Sketch |
|||
[source,c] |
|||
---- |
|||
import processing.serial.*; |
|||
import java.awt.datatransfer.*; |
|||
import java.awt.Toolkit; |
|||
import processing.opengl.*; |
|||
import saito.objloader.*; |
|||
import g4p_controls.*; |
|||
|
|||
float roll = 0.0F; |
|||
float pitch = 0.0F; |
|||
float yaw = 0.0F; |
|||
float temp = 0.0F; |
|||
float alt = 0.0F; |
|||
|
|||
OBJModel model; |
|||
|
|||
// Serial port state. |
|||
Serial port; |
|||
String buffer = ""; |
|||
final String serialConfigFile = "serialconfig.txt"; |
|||
boolean printSerial = false; |
|||
|
|||
// UI controls. |
|||
GPanel configPanel; |
|||
GDropList serialList; |
|||
GLabel serialLabel; |
|||
GCheckbox printSerialCheckbox; |
|||
|
|||
void setup() |
|||
{ |
|||
size(400, 500, OPENGL); |
|||
frameRate(30); |
|||
model = new OBJModel(this); |
|||
model.load("bunny.obj"); |
|||
model.scale(20); |
|||
|
|||
// Serial port setup. |
|||
// Grab list of serial ports and choose one that was persisted earlier or default to the first port. |
|||
int selectedPort = 0; |
|||
String[] availablePorts = Serial.list(); |
|||
if (availablePorts == null) { |
|||
println("ERROR: No serial ports available!"); |
|||
exit(); |
|||
} |
|||
String[] serialConfig = loadStrings(serialConfigFile); |
|||
if (serialConfig != null && serialConfig.length > 0) { |
|||
String savedPort = serialConfig[0]; |
|||
// Check if saved port is in available ports. |
|||
for (int i = 0; i < availablePorts.length; ++i) { |
|||
if (availablePorts[i].equals(savedPort)) { |
|||
selectedPort = i; |
|||
} |
|||
} |
|||
} |
|||
// Build serial config UI. |
|||
configPanel = new GPanel(this, 10, 10, width-20, 90, "Configuration (click to hide/show)"); |
|||
serialLabel = new GLabel(this, 0, 20, 80, 25, "Serial port:"); |
|||
configPanel.addControl(serialLabel); |
|||
serialList = new GDropList(this, 90, 20, 200, 200, 6); |
|||
serialList.setItems(availablePorts, selectedPort); |
|||
configPanel.addControl(serialList); |
|||
printSerialCheckbox = new GCheckbox(this, 5, 50, 200, 20, "Print serial data"); |
|||
printSerialCheckbox.setSelected(printSerial); |
|||
configPanel.addControl(printSerialCheckbox); |
|||
// Set serial port. |
|||
setSerialPort(serialList.getSelectedText()); |
|||
} |
|||
|
|||
void draw() |
|||
{ |
|||
background(0,0, 0); |
|||
|
|||
// Set a new co-ordinate space |
|||
pushMatrix(); |
|||
|
|||
// Simple 3 point lighting for dramatic effect. |
|||
// Slightly red light in upper right, slightly blue light in upper left, and white light from behind. |
|||
pointLight(255, 200, 200, 400, 400, 500); |
|||
pointLight(200, 200, 255, -400, 400, 500); |
|||
pointLight(255, 255, 255, 0, 0, -500); |
|||
|
|||
// Displace objects from 0,0 |
|||
translate(200, 350, 0); |
|||
|
|||
// Rotate shapes around the X/Y/Z axis (values in radians, 0..Pi*2) |
|||
rotateX(radians(roll)); |
|||
rotateZ(radians(pitch)); |
|||
rotateY(radians(yaw)); |
|||
|
|||
pushMatrix(); |
|||
noStroke(); |
|||
model.draw(); |
|||
popMatrix(); |
|||
popMatrix(); |
|||
//print("draw"); |
|||
} |
|||
|
|||
void serialEvent(Serial p) |
|||
{ |
|||
String incoming = p.readString(); |
|||
if (printSerial) { |
|||
println(incoming); |
|||
} |
|||
|
|||
if ((incoming.length() > 8)) |
|||
{ |
|||
String[] list = split(incoming, " "); |
|||
if ( (list.length > 0) && (list[0].equals("Orientation:")) ) |
|||
{ |
|||
roll = float(list[1]); |
|||
pitch = float(list[2]); |
|||
yaw = float(list[3]); |
|||
buffer = incoming; |
|||
} |
|||
if ( (list.length > 0) && (list[0].equals("Alt:")) ) |
|||
{ |
|||
alt = float(list[1]); |
|||
buffer = incoming; |
|||
} |
|||
if ( (list.length > 0) && (list[0].equals("Temp:")) ) |
|||
{ |
|||
temp = float(list[1]); |
|||
buffer = incoming; |
|||
} |
|||
} |
|||
} |
|||
|
|||
// Set serial port to desired value. |
|||
void setSerialPort(String portName) { |
|||
// Close the port if it's currently open. |
|||
if (port != null) { |
|||
port.stop(); |
|||
} |
|||
try { |
|||
// Open port. |
|||
port = new Serial(this, portName, 115200); |
|||
port.bufferUntil('\n'); |
|||
// Persist port in configuration. |
|||
saveStrings(serialConfigFile, new String[] { portName }); |
|||
} |
|||
catch (RuntimeException ex) { |
|||
// Swallow error if port can't be opened, keep port closed. |
|||
port = null; |
|||
} |
|||
} |
|||
|
|||
// UI event handlers |
|||
|
|||
void handlePanelEvents(GPanel panel, GEvent event) { |
|||
// Panel events, do nothing. |
|||
} |
|||
|
|||
void handleDropListEvents(GDropList list, GEvent event) { |
|||
// Drop list events, check if new serial port is selected. |
|||
if (list == serialList) { |
|||
setSerialPort(serialList.getSelectedText()); |
|||
} |
|||
} |
|||
|
|||
void handleToggleControlEvents(GToggleControl checkbox, GEvent event) { |
|||
// Checkbox toggle events, check if print events is toggled. |
|||
if (checkbox == printSerialCheckbox) { |
|||
printSerial = printSerialCheckbox.isSelected(); |
|||
} |
|||
} |
|||
---- |
|||
|
|||
|
|||
|
|||
==== Run it |
|||
|
|||
- Run the AHRS Sketch on the Uno |
|||
- Run the Processing Sketch on the Processing |
|||
|
|||
|
|||
[NOTE] |
|||
==== |
|||
Make sure that the appropriate AHRS example sketch is running on the Uno (as described), and that the Serial Monitor is closed. |
|||
==== |
|||
|
|||
.And Voila! |
|||
video::CoyU3W925io[youtube] |
|||
image::ROOT:sensors_bunny.png[alt="Processing example"] |
|||
|
|||
|
|||
|
|||
|
|||
.Cockpit Simulator |
|||
[NOTE] |
|||
==== |
|||
With small changes we can make this too |
|||
|
|||
image::ROOT:sensors_Yaw_Axis_Corrected.png[Aeroplane,120,120,pdfwidth=25%,scaledwidth=25%] |
|||
|
|||
image::ROOT:HSI.png[alt="Cockpit"] |
|||
image::ROOT:TC.png[alt="Cockpit"] |
|||
==== |
|||
|
|||
|
|||
|
|||
|
|||
[appendix] |
|||
== Source Code |
|||
|
|||
- https://github.com/adafruit/Adafruit_AHRS[Adafruit_AHRS^] |
|||
- https://sourceforge.net/projects/g4p/files/?source=navbar[g4p^] |
|||
|
|||
|
|||
@ -0,0 +1,762 @@ |
|||
= Data collector! |
|||
|
|||
image::ROOT:swarmlab.png[swarmlab,150,float=right] |
|||
|
|||
This tutorial demonstrates: *a.* howto create a mote with Raspberry Pi and Arduino *b.* howto use it |
|||
|
|||
The data collector is a lightweight microservice applicatio that sends metadata collected from a system such as an IoT network, distributed system, data center, etc. |
|||
|
|||
The data are transmitted, stored, and can be retrieved at any time. |
|||
|
|||
== Start |
|||
|
|||
You can start it in the same way as you start any other application. |
|||
|
|||
Here you can find |
|||
http://docs.swarmlab.io/SwarmLab-HowTos/swarmlab/docs/swarmlab/docs/hybrid/start-microservices.html[here^} |
|||
|
|||
http://docs.swarmlab.io/SwarmLab-HowTos/swarmlab/docs/swarmlab/docs/hybrid/start-microservices.html |
|||
|
|||
|
|||
|
|||
|
|||
.Raspberry Pi 2 Model B |
|||
image::ROOT:Raspberry_Pi_2_Model_B_v1.1_top_new.jpg[alt="Raspberry Pi 2 Model B"] |
|||
|
|||
[NOTE] |
|||
.Remember |
|||
==== |
|||
A mote is a node but a node is not always a mote! |
|||
|
|||
image::ROOT:arduino-connect-pi.jpg[alt="Raspberry Pi and Arduino"] |
|||
|
|||
==== |
|||
|
|||
|
|||
=== Install Raspberry Pi |
|||
|
|||
==== Step 1: Download Raspbian |
|||
|
|||
https://www.raspberrypi.org/downloads/raspbian/[Download^] the Raspbian disc image - Choose Raspbian Lite |
|||
|
|||
[NOTE] |
|||
.Why Raspbian Lite? |
|||
==== |
|||
Because it is a lightweight version of the Raspbian and it doesn’t have a graphical user interface installed. |
|||
|
|||
This means that it doesn’t have any unnecessary software installed that we don’t need for our projects, so this makes it the perfect solution for future automation projects. |
|||
==== |
|||
|
|||
==== Step 2: Unzip the file |
|||
|
|||
|
|||
- Windows users, you’ll want 7-Zip. |
|||
- Linux users will use the appropriately named Unzip. |
|||
|
|||
|
|||
==== Step 3: Write the disc image to your microSD card |
|||
|
|||
Next, pop your microSD card into your computer and write the disc image to it. You’ll need a specific program to do this: |
|||
|
|||
- Windows users, your answer is https://sourceforge.net/projects/win32diskimager/[Win32 Disk Imager^]. |
|||
- Linux people, https://www.balena.io/etcher/[Etcher – which also works on Windows – is what the Raspberry Pi Foundation recommends^] |
|||
|
|||
The process of actually writing the image will be slightly different across these programs, but it’s pretty self-explanatory no matter what you’re using. |
|||
|
|||
- Each of these programs will have you select the destination (make sure you’ve picked your microSD card!) and the disc image (the unzipped Raspbian file). |
|||
- Choose, double-check, and then hit the button to write. |
|||
|
|||
|
|||
==== Step 4: Enabling SSH |
|||
|
|||
- Windows users |
|||
|
|||
.Create ssh file (no extension) |
|||
image::ROOT:ssh-file-to-sd-card.jpg[alt="Create ssh file"] |
|||
|
|||
- Linux Users |
|||
|
|||
.Create ssh file |
|||
[source,bash] |
|||
---- |
|||
sudo fdisk -l |
|||
# find dev and Boot partition |
|||
sudo mkdir /mnt/sdcardP1 |
|||
sudo mount /dev/device_partion_boot /mnt/sdcardP1 -rw |
|||
cd /mnt/sdcardP1 |
|||
sudo touch ssh |
|||
---- |
|||
|
|||
==== Step 5: Put the microSD card in your Pi and boot up |
|||
|
|||
Your default credentials are username **pi** and password **raspberry** |
|||
|
|||
|
|||
==== Step 6: Access via SSH |
|||
|
|||
|
|||
- The boot protocol for the ethernet interface is set to DHCP by default |
|||
|
|||
You can find the open SSH ports on your network using the nmap utility: |
|||
|
|||
|
|||
.find ports on Network |
|||
[source,bash] |
|||
---- |
|||
nmap -p 22 --open -sV 192.168.1.0/24 |
|||
---- |
|||
|
|||
You should find your pi listed in the output along with the IP assigned to the pi. |
|||
|
|||
|
|||
- You can change the boot protocol to static and define a static IP address for the pi by editing the ifcfg-eth0 file: |
|||
|
|||
.static IP address |
|||
[source,bash] |
|||
---- |
|||
sudo fdisk -l |
|||
# find dev and Boot partition |
|||
sudo mkdir /mnt/sdcardP1 |
|||
sudo mount /dev/device_partion_ext /mnt/sdcardP1 -rw |
|||
cd /mnt/sdcardP1 |
|||
vi /etc/sysconfig/network-scripts/ifcfg-eth0 |
|||
---- |
|||
|
|||
Then edit the file to suit your needs |
|||
|
|||
.static IP address |
|||
[source,bash] |
|||
---- |
|||
DEVICE=eth0 |
|||
BOOTPROTO=static |
|||
ONBOOT=yes |
|||
NETWORK=192.168.1.0 |
|||
NETMASK=255.255.255.0 |
|||
IPADDR=192.168.1.200 |
|||
GATEWAY=192.168.1.1 |
|||
---- |
|||
|
|||
|
|||
==== Step 7: Configure your Raspberry Pi. |
|||
|
|||
**raspi-config** is the Raspberry Pi configuration tool |
|||
|
|||
|
|||
.config Pi |
|||
[source,bash] |
|||
---- |
|||
sudo raspi-config |
|||
---- |
|||
|
|||
It has the following options available: |
|||
|
|||
.config options |
|||
[source,bash] |
|||
---- |
|||
|
|||
┌──────────┤ Raspberry Pi Software Configuration Tool (raspi-config) ├─┐ |
|||
│ │ |
|||
│ 1 Change User Password Change password for the current user │ |
|||
│ 2 Network Options Configure network settings │ |
|||
│ 3 Boot Options Configure options for start-up │ |
|||
│ 4 Localisation Options Set up language and regional settings │ |
|||
│ 5 Interfacing Options Configure connections to peripherals │ |
|||
│ 6 Overclock Configure overclocking for your Pi │ |
|||
│ 7 Advanced Options Configure advanced settings │ |
|||
│ 8 Update Update this tool to the latest version │ |
|||
│ 9 About raspi-config Information about this configuration tool │ |
|||
│ │ |
|||
│ <Select> <Finish> │ |
|||
│ │ |
|||
└──────────────────────────────────────────────────────────────────────┘ |
|||
|
|||
---- |
|||
|
|||
|
|||
=== Arduino Uno Raspberry Pi Serial Communication |
|||
|
|||
==== Serial config on Raspi |
|||
|
|||
|
|||
.config 1 (recommended) |
|||
[source,bash] |
|||
---- |
|||
whoami |
|||
sudo usermod -a -G dialout pi |
|||
reboot |
|||
---- |
|||
|
|||
This gives read/write permission for all users to the Raspberry Pi (potentially unsafe): |
|||
|
|||
.config 2 |
|||
[source,bash] |
|||
---- |
|||
sudo chmod 777 /dev/ttyACM0 |
|||
---- |
|||
|
|||
This provides some configuration for the Arduino serial connection: |
|||
|
|||
.configuration for the Arduino serial connection |
|||
[source,bash] |
|||
---- |
|||
sudo stty -F /dev/ttyACM0 cs8 9600 ignbrk -brkint -icrnl -imaxbel -opost -onlcr -isig -icanon -iexten -echo -echoe -echok -echoctl -echoke noflsh -ixon -crtscts |
|||
---- |
|||
|
|||
==== Reading in arduino |
|||
|
|||
.C code in the arduino |
|||
[source,bash] |
|||
---- |
|||
void loop() { |
|||
meas = analogRead(a); |
|||
if (Serial.available()) |
|||
{ |
|||
if (Serial.read() == '1') |
|||
{ |
|||
Serial.println(meas); |
|||
} |
|||
} |
|||
} |
|||
---- |
|||
|
|||
==== Python |
|||
|
|||
.Python code in Raspberry Pi |
|||
[source,python] |
|||
---- |
|||
import serial |
|||
from datetime import datetime |
|||
from time import sleep |
|||
now = datetime.now() |
|||
|
|||
ser = serial.Serial('/dev/ttyACM0', 9600) |
|||
ser.write("1".encode()) |
|||
sleep(0.05); |
|||
s = ser.readline() |
|||
|
|||
file = open("dataset", "a") |
|||
file.write(now.strftime("%Y-%m-%d %H:%M") + " Sensor Value:" + str(s)+ "\n") |
|||
file.close() |
|||
---- |
|||
|
|||
==== PHP |
|||
|
|||
[NOTE] |
|||
.PHP Class |
|||
==== |
|||
https://gist.github.com/gravataLonga/6c89821b845d15e939a0/archive/0d0063684d388a8ff53df8e73e55f4cb1187d7cd.zip[Download Class] |
|||
==== |
|||
|
|||
.PHP code in Raspberry Pi - read |
|||
[source,php] |
|||
---- |
|||
<?php |
|||
|
|||
include "php_serial.class.php"; |
|||
|
|||
$serial = new phpSerial(); |
|||
$serial->deviceSet("/dev/ttyACM0"); |
|||
$serial->confBaudRate(9600); |
|||
$serial->confParity("none"); |
|||
$serial->confCharacterLength(8); |
|||
$serial->confStopBits(1); |
|||
$serial->confFlowControl("none"); |
|||
|
|||
$serial->deviceOpen(); |
|||
$read = $serial->readPort(); |
|||
$serial->deviceClose(); |
|||
|
|||
echo $read |
|||
---- |
|||
|
|||
|
|||
Sends a string to the Arduino. |
|||
|
|||
.PHP code in Raspberry Pi - send |
|||
[source,php] |
|||
---- |
|||
<?php |
|||
|
|||
error_reporting(E_ALL); |
|||
ini_set('display_errors', '1'); |
|||
include "php_serial.class.php"; |
|||
|
|||
$serial = new phpSerial; |
|||
$serial->deviceSet("/dev/ttyAMA0"); |
|||
$serial->confBaudRate(115200); |
|||
$serial->confParity("none"); |
|||
$serial->confCharacterLength(8); |
|||
$serial->confStopBits(1); |
|||
$serial->deviceOpen(); |
|||
$serial->sendMessage("Hello from my PHP script, say hi back!"); |
|||
|
|||
$serial->deviceClose(); |
|||
|
|||
echo "I've sended a message! \n\r"; |
|||
---- |
|||
|
|||
==== NodeJS |
|||
|
|||
[NOTE] |
|||
==== |
|||
Read the writing carefully on your Raspberry Pi circuit board to confirm it indicates something like “Raspberry Pi 4 Model B” or “Raspberry Pi 2 Model B”. If in doubt, run the following command in the terminal: |
|||
|
|||
$ uname -m |
|||
|
|||
If the result returned starts with **“armv6”**, you are running a Raspberry Pi based on the older ARMv6 chipset and the next Node.js installation step **will not work**; otherwise, you are ready for the next step. |
|||
==== |
|||
|
|||
|
|||
.Install NodeJS |
|||
[source,bash] |
|||
---- |
|||
curl -sL https://deb.nodesource.com/setup_13.x | sudo -E bash - |
|||
sudo apt install -y nodejs |
|||
npm install raspi-serial |
|||
---- |
|||
|
|||
|
|||
.Install NodeJS - armv6 |
|||
[source,bash] |
|||
---- |
|||
cd ~ |
|||
wget http://nodejs.org/dist/v6.2.1/node-v6.2.1-linux-armv6l.tar.gz |
|||
tar -xzf node-v6.2.1-linux-armv6l.tar.gz |
|||
cd node-v6.2.1-linux-armv6l/ |
|||
sudo cp -R * /usr/local/ |
|||
export PATH=$PATH:/usr/local/bin |
|||
npm install raspi-serial |
|||
---- |
|||
|
|||
|
|||
.NodeJS code in Raspberry Pi - read |
|||
[source,c] |
|||
---- |
|||
mport { init } from 'raspi'; |
|||
import { Serial } from 'raspi-serial'; |
|||
|
|||
init(() => { |
|||
var serial = new Serial(); |
|||
serial.open(() => { |
|||
serial.on('data', (data) => { |
|||
process.stdout.write(data); |
|||
}); |
|||
serial.write('Hello from raspi-serial'); |
|||
}); |
|||
}); |
|||
---- |
|||
|
|||
|
|||
|
|||
=== Send data2server |
|||
|
|||
|
|||
==== NodeJS |
|||
|
|||
.NodeJS code in Raspberry Pi - send |
|||
[source,c] |
|||
---- |
|||
|
|||
... |
|||
var serverIOT=IP_SERVER |
|||
const socket = require('socket.io-client')('https://'+serverIOT+':9080'); |
|||
socket.on('connect', function () { |
|||
socket.emit('subscribe', log); |
|||
var obj = new Object(); |
|||
obj.room = log; |
|||
obj.message = data; |
|||
var text = JSON.stringify(obj); |
|||
var text1 = Buffer.from(text); |
|||
var text5 = text1.toString('base64'); |
|||
socket.emit('log', text5, log ) |
|||
//console.log(util.inspect(text5, false, null, true /* enable colors */)) |
|||
|
|||
res.json({ |
|||
'message':"ok" |
|||
}); |
|||
}); |
|||
|
|||
... |
|||
|
|||
---- |
|||
|
|||
TIP: You can find more information https://git.swarmlab.io:3000/zeus/iot-swarm-example/src/branch/master[here^] and http://docs.swarmlab.io/SwarmLab-HowTos/index-lab.adoc.html#_iot_swarm_implementation[here^] |
|||
|
|||
|
|||
|
|||
== How to communicate Arduino2Raspberry |
|||
|
|||
Blinking example (*) |
|||
|
|||
=== Arduino code |
|||
|
|||
|
|||
[source,c] |
|||
---- |
|||
|
|||
/* |
|||
* serial_usb_simple_arduino - For communicating over USB serial. Send it a '1' (character one) |
|||
* and it will make the builtin LED start blinking every one second. Send it a '0' |
|||
* (character zero) and it will make it stop blinking. |
|||
* |
|||
* Each time it receives one of the commands, it sends back an 'A' for acknowledge. |
|||
* But send it a commmand it doesn't recognize and it sends back an 'E' for error. |
|||
*/ |
|||
|
|||
bool blinking = false; |
|||
bool led_on = false; |
|||
int target_time; |
|||
|
|||
void setup() { |
|||
Serial.begin(115200); |
|||
while (!Serial) { |
|||
; // wait for serial port to connect. Needed for native USB |
|||
} |
|||
pinMode(LED_BUILTIN, OUTPUT); |
|||
} |
|||
|
|||
void loop() { |
|||
char c; |
|||
|
|||
if (Serial.available() > 0) { |
|||
c = Serial.read(); |
|||
switch (c) { |
|||
case '0': |
|||
// stop blinking |
|||
blinking = false; |
|||
if (led_on) { |
|||
digitalWrite(LED_BUILTIN, LOW); |
|||
} |
|||
Serial.write("A", 1); |
|||
break; |
|||
case '1': |
|||
// start blinking |
|||
if (blinking == false) { |
|||
blinking = true; |
|||
digitalWrite(LED_BUILTIN, HIGH); |
|||
led_on = true; |
|||
target_time = millis() + 100; // turn off in 1 tenth of a second (100 milliseconds) |
|||
} |
|||
Serial.write("A", 1); |
|||
break; |
|||
default: |
|||
Serial.write("E", 1); |
|||
break; |
|||
} |
|||
} else if (blinking) { |
|||
if (millis() >= target_time) { |
|||
if (led_on) { |
|||
digitalWrite(LED_BUILTIN, LOW); |
|||
led_on = false; |
|||
target_time = millis() + 100; // turn on in 1 tenth of a second (100 milliseconds) |
|||
} else { |
|||
digitalWrite(LED_BUILTIN, HIGH); |
|||
led_on = true; |
|||
target_time = millis() + 100; // turn off in 1 tenth of a second (100 milliseconds) |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
---- |
|||
|
|||
=== Raspberry Pi C language |
|||
|
|||
[source,c] |
|||
---- |
|||
|
|||
/* |
|||
* serial_usb_simple - Demo that communicates over USB using serial I/O |
|||
* from a Raspberry Pi to an Arduino. |
|||
* |
|||
* To show that it work, this writes a '1' to the Arduino which then |
|||
* blinks the builtin LED on and off. The Arduino also sends back an 'A' |
|||
* to acknowledge that it got the message. This does a read() to get |
|||
* the 'A', demonstrating that reading also works. Two seconds later, |
|||
* this writes a '0' to the Arduino which then stops the blinking. |
|||
* The Arduino again sends back an 'A' to acknowledge that it got the |
|||
* message and this reads the 'A'. |
|||
* |
|||
* This was tested between a Raspberry Pi 3B (running Raspbian) and |
|||
* an Arduino Mega 2560 and also between an NVIDIA Jetson TX1 (running |
|||
* Ubuntu) and the same Arduino. |
|||
*/ |
|||
|
|||
#include <errno.h> |
|||
#include <stdio.h> |
|||
#include <stdlib.h> |
|||
#include <string.h> |
|||
// for the serial I/O |
|||
#include <fcntl.h> |
|||
#include <termios.h> |
|||
#include <unistd.h> |
|||
#include <linux/serial.h> |
|||
#include <sys/ioctl.h> |
|||
#include <sys/stat.h> |
|||
|
|||
int open_serial_port(char *name) |
|||
{ |
|||
int fd, bits; |
|||
struct termios term; |
|||
struct serial_struct kernel_serial_settings; |
|||
|
|||
if ((fd = open(name, O_RDWR | O_NONBLOCK | O_NOCTTY )) == -1) { |
|||
fprintf(stderr, "open(%s) failed: %s\n", name, strerror(errno)); |
|||
return -1; |
|||
} |
|||
|
|||
/* |
|||
* Reset the Arduino's line. This is key to getting the write to work. |
|||
* Without it, the first few writes don't work. |
|||
* Clear DTR, wait one second, flush input, then set DTR. |
|||
* Without this, the first write fails. |
|||
*/ |
|||
if (ioctl(fd, TIOCMGET, &bits) < 0) { |
|||
close(fd); |
|||
perror("ioctl(TCIOMGET)"); |
|||
return -1; |
|||
} |
|||
bits &= ~(TIOCM_DTR | TIOCM_RTS); |
|||
if (ioctl(fd, TIOCMSET, &bits) < 0) { |
|||
close(fd); |
|||
perror("ioctl(TIOCMSET)"); |
|||
return -1; |
|||
} |
|||
sleep(1); |
|||
tcflush(fd, TCIFLUSH); |
|||
bits &= TIOCM_DTR; |
|||
if (ioctl(fd, TIOCMSET, &bits) < 0) { |
|||
close(fd); |
|||
perror("ioctl(TIOCMSET)"); |
|||
return -1; |
|||
} |
|||
|
|||
memset(&term, 0, sizeof(term)); |
|||
term.c_iflag = IGNBRK | IGNPAR; |
|||
term.c_cflag = CS8 | CREAD | HUPCL | CLOCAL; |
|||
cfsetospeed(&term, B115200); |
|||
cfsetispeed(&term, B115200); |
|||
if (tcsetattr(fd, TCSANOW, &term) < 0) { |
|||
perror("tcsetattr()"); |
|||
return -1; |
|||
} |
|||
if (ioctl(fd, TIOCGSERIAL, &kernel_serial_settings) == 0) { |
|||
kernel_serial_settings.flags |= ASYNC_LOW_LATENCY; |
|||
ioctl(fd, TIOCSSERIAL, &kernel_serial_settings); |
|||
} |
|||
tcflush(fd, TCIFLUSH); |
|||
|
|||
return fd; |
|||
} |
|||
|
|||
int read_from_serial(int fd, char *buf) |
|||
{ |
|||
int n; |
|||
|
|||
while (1) { |
|||
if ((n = read(fd, buf, 1)) == -1) { |
|||
if (errno != EAGAIN) { |
|||
fprintf(stderr, "read() failed: (%d) %s\n", errno, strerror(errno)); |
|||
return -1; |
|||
} |
|||
// errno == EAGAIN, loop around and read again |
|||
} else { |
|||
if (n == 1) { |
|||
return n; // stop reading |
|||
} |
|||
// read 0 bytes, loop around an read again |
|||
} |
|||
} |
|||
} |
|||
|
|||
int main(int argc, char **argv) |
|||
{ |
|||
int fd; |
|||
ssize_t n; |
|||
char buf[10]; |
|||
|
|||
if ((fd = open_serial_port("/dev/ttyACM0")) == -1) { |
|||
exit(EXIT_FAILURE); |
|||
} |
|||
|
|||
while (1) { |
|||
|
|||
printf("Telling the Arduino to start blinking...\n"); |
|||
|
|||
if ((n = write(fd, "1", 1)) == -1) { |
|||
fprintf(stderr, "write() failed: %s\n", strerror(errno)); |
|||
exit(EXIT_FAILURE); |
|||
} |
|||
|
|||
// read to get the acknowledgement from the Arduino |
|||
|
|||
if (read_from_serial(fd, buf) == -1) { |
|||
exit(EXIT_FAILURE); |
|||
} |
|||
buf[1] = '\0'; |
|||
printf("Arduino sent back '%s'\n", buf); |
|||
|
|||
sleep(2); |
|||
|
|||
printf("Telling the Arduino to stop blinking...\n"); |
|||
|
|||
if ((n = write(fd, "0", 1)) == -1) { |
|||
fprintf(stderr, "write() failed: %s\n", strerror(errno)); |
|||
exit(EXIT_FAILURE); |
|||
} |
|||
|
|||
// read to get the acknowledgement from the Arduino |
|||
|
|||
if (read_from_serial(fd, buf) == -1) { |
|||
exit(EXIT_FAILURE); |
|||
} |
|||
buf[1] = '\0'; |
|||
printf("Arduino sent back '%s'\n", buf); |
|||
|
|||
sleep(2); |
|||
} |
|||
|
|||
return EXIT_SUCCESS; |
|||
} |
|||
|
|||
---- |
|||
|
|||
=== Raspberry Pi Python |
|||
|
|||
|
|||
[source,c] |
|||
---- |
|||
|
|||
""" |
|||
serial_usb_simple.py Demo that communicates over USB using serial I/O |
|||
from a Raspberry Pi to an Arduino. |
|||
|
|||
To show that it work, this writes a '1' to the Arduino which then |
|||
blinks the builtin LED on and off. The Arduino also sends back an 'A' |
|||
to acknowledge that it got the message. This does a read() to get |
|||
the 'A', demonstrating that reading also works. Two seconds later, |
|||
this writes a '0' to the Arduino which then stops the blinking. |
|||
The Arduino again sends back an 'A' to acknowledge that it got the |
|||
message and this reads the 'A'. |
|||
|
|||
This was tested between a Raspberry Pi 3B (running Raspbian) and |
|||
an Arduino Mega 2560 and also between an NVIDIA Jetson TX1 (running |
|||
Ubuntu) and the same Arduino. |
|||
""" |
|||
|
|||
import serial |
|||
import time |
|||
|
|||
ser = serial.Serial("/dev/ttyACM0", 115200, timeout=1) |
|||
|
|||
# Reset the Arduino's line. This is key to getting the write to work. |
|||
# Without it, the first few writes don't work. |
|||
# Clear DTR, wait one second, flush input, then set DTR. |
|||
# Without this, the first write fails. |
|||
# This trick was learned from: |
|||
# https://github.com/miguelasd688/4-legged-robot-model |
|||
|
|||
ser.setDTR(False) |
|||
time.sleep(1) |
|||
ser.flushInput() |
|||
ser.setDTR(True) |
|||
time.sleep(2) |
|||
|
|||
while True: |
|||
|
|||
print('Telling the Arduino to start blinking...') |
|||
ser.write(b'1') |
|||
|
|||
# read to get the acknowledgement from the Arduino |
|||
while True: |
|||
ack = ser.read() |
|||
if ack == b'A': |
|||
break |
|||
print('Arduino sent back %s' % ack) |
|||
|
|||
time.sleep(2) |
|||
|
|||
print('Telling the Arduino to stop blinking...') |
|||
ser.write(b'0') |
|||
|
|||
# read to get the acknowledgement from the Arduino |
|||
while True: |
|||
ack = ser.read() |
|||
if ack == b'A': |
|||
break |
|||
print('Arduino sent back %s' % ack) |
|||
|
|||
time.sleep(2) |
|||
|
|||
---- |
|||
|
|||
(*) Original: https://rimstar.org/science_electronics_projects/raspberry_pi_to_arduino_serial_usb_communication.htm |
|||
|
|||
== Video |
|||
|
|||
=== Install Raspberry Pi |
|||
|
|||
**** |
|||
TIP: Learn how to How to install Raspbian on the Raspberry Pi - 1/5 |
|||
|
|||
video::646403546[vimeo] |
|||
**** |
|||
|
|||
**** |
|||
TIP: Learn how to How to install Raspbian on the Raspberry Pi - 2/5 |
|||
|
|||
video::646400963[vimeo] |
|||
**** |
|||
|
|||
|
|||
**** |
|||
TIP: Learn how to How to install Raspbian on the Raspberry Pi - 3/5 |
|||
|
|||
video::646477283[vimeo] |
|||
**** |
|||
|
|||
**** |
|||
TIP: Learn how to How to install Raspbian on the Raspberry Pi - 4/5 |
|||
|
|||
video::646479777[vimeo] |
|||
**** |
|||
|
|||
**** |
|||
TIP: Learn how to How to install Raspbian on the Raspberry Pi - 5/5 |
|||
|
|||
video::646473366[vimeo] |
|||
**** |
|||
|
|||
=== Raspberry to Arduino Serial Communication |
|||
|
|||
**** |
|||
TIP: Learn how to How to Setup Raspberry Pi to Arduino Serial Communication |
|||
|
|||
video::646526465[vimeo] |
|||
**** |
|||
|
|||
=== Upload Sketch |
|||
|
|||
A program designed for an Arduino board is called a sketch, and the process of transferring it to the board is called uploading. |
|||
|
|||
**** |
|||
TIP: Learn how to How to Upload Sketch (**) |
|||
|
|||
video::646562968[vimeo] |
|||
**** |
|||
|
|||
|
|||
|
|||
Windows: It will never be COM1 don't pick that one. You should only have one other option. |
|||
|
|||
Mac OS X and Linux: It will never be an option with 'bluetooth' in the name, look for /dev/cu.usbmodem or /dev/cu.usbserial or /dev/ttyUSB or similar! |
|||
|
|||
|
|||
(**) Original: https://learn.adafruit.com/ladyadas-learn-arduino-lesson-number-1?view=all |
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
@ -0,0 +1,4 @@ |
|||
antora --fetch /antora/site-intro.yml |
|||
antora /antora/site-intro.yml |
|||
ifconfig |
|||
http-server build/site -c-1 |
|||
@ -0,0 +1,4 @@ |
|||
antora --fetch /antora/site.yml |
|||
antora /antora/site.yml |
|||
ifconfig |
|||
http-server build/site -c-1 |
|||
@ -0,0 +1,21 @@ |
|||
site: |
|||
title: Swarmlab poc-datacollector |
|||
url: http://docs.swarmlab.io/SwarmLab-HowTos/swarmlab/docs |
|||
start_page: swarmlab_poc-datacollector::index.adoc |
|||
content: |
|||
sources: |
|||
- url: https://git.swarmlab.io:3000/docs/Documentation.git |
|||
branches: master |
|||
start_path: poc-datacollector |
|||
ui: |
|||
bundle: |
|||
url: https://git.swarmlab.io:3000/docs/docs/raw/branch/master/ui-bundle.zip |
|||
snapshot: true |
|||
supplemental_files: ./supplemental-ui |
|||
asciidoc: |
|||
attributes: |
|||
:plantuml-server-url: http://www.plantuml.com/plantuml |
|||
extensions: |
|||
- '@djencks/asciidoctor-mathjax' |
|||
- asciidoctor-plantuml |
|||
|
|||
Loading…
Reference in new issue