The field of networking and communication includes the analysis, design, implementation, and use of local, wide-area, and mobile networks that link computers together. The Internet itself is a network that makes it feasible for nearly all computers in the world to communicate.
Group assignment
- Send a message between two projects
Individual assignment
- Design, build, and connect wired or wireless node(s) with network or bus addresses
Find out the details of our common work al ZOI Here.
In embedded systems, the communication means the exchange of data between two microcontrollers in the form of bits.
This exchange of data bits in microcontroller is done by some set of defined rules know as communication protocols.
If the data is sent in series (one after the other) then the communication protocol is known as serial communication protocol.
This means the data bits are transmitted one at the time in sequetial manner over the data bus or communication channel in Serial Communication.
There are different types of data transfer avaliable, such as serial and parallel communication. Same way, protocols are
divided in two types, serial and parallel communication protocols.
Serial communication data is sent in the form of bits (binary pulses), and binary one represents the logic HIGH and zero represents the logic LOW. Depending on the type of transmission mode and data transfer there are several types of serial communication. Transmission modes are classified as:
Serial communication protocols
Fort his networking assignment, I want to connect my inputs (the white one) and outputs boards. The first one will receive information from the soil moisture sensor and the second one will turn red of the soil
needs water and green if it is ok.
Here you can find my inputs and outputs boards:
It is neccesary to develop two codes and to programm each board individually: one for the sensors board (white one) and another one for the led board and upload them individually.
I based this code on our group assignment and my final project programming.
For the inputs board there is neccesary a "Send Only Software Serial" library for Arduino, which is used for situations where you need to do something sending but don't need to receive anything.
This lets you avoid tying up the pin-change interrupts for the receiving code. You can also download it Here.
One important varible used here is CustomSerial.println('a') and CustomSerial.println('a') because this characters will be interpreted by the outputs board later. The vood loop conditions are set to determine
if the soil is dry or wet and depending on this condition the led will turn on red or green according to the soil conditions.
For the outputs board the code reads the caracter = Serial.read and interpret the values, if it is 'a' the led will turn red, since it didn't reach the parameters of humidity set before, or
green if the soil is wet, also according to the parameters set on the inputs code.
Here you can download both files:
The outputs board is connected to the white board (inputs) through the FTDI adapter, using 4 pins: VCC, GND, TX and RX (remember that Tx and Rx must be swapped).
The white board is connected through the terminal block to the programmer using VCC and GND. The programmer is connected through the USB to the computer to power the entire system.
This is the result of both of them working together:
At first, the led only showed red, I realized that there was an inconsistency in the input variables vs. the outputs. In inputs I had the rgb determined as
"pinMode 'PinR, OUTPUT' and in outputs as 'int redpin = 11' (same for the other pins). So the first thing to do is to unify the name of the variables, leaving in both Codes like
'redpin', 'greenpin' and 'bluepin'.
Then, the led only shoed blue, I realized that in the void setup I had analogWrite for red and green, and digital for blue, but all of my pins are digital, changed them all to digital.
After another test, I realized in the outputs I had foor characters with its own conditions while in the inputs I had just set two. So I changed it and just left it to be defined by 'a' and 'b'.
It is finaly working properlly.
For this assignment Im going to use I2C Serial Bus to send and receive data between two micros just using two cables SCL for the clock signal and SDA (to send data).
The following image taken from Luis Llamas shows how this works
Each "secondary" has an address which is used to access the devices individually. The I2C bus has a master-slave architecture or as Neil recomends to call them a master-secondary architecture.
The master device initiates communication with the secondaries and can send or receive data from them. Secondaries can not initiate communication or talk to each other directly, the master has to ask them.
The I2C bus is synchronous which means that the master provides a clock signal that keeps all devices on the bus in sync.
Each pulse on the SCL pin tells the receiving device to read the value from the SDA pin . In this way the bits are put into SDA one by one. The following image shows a transfer of the value 77, where the message is made
up of several frames or sections. A message is made up of an address frame which indicates to with secondary the information is sent.
The board I designed and produced for my final project will act as master and I will use an Arduino UNO and Arduino MEGA as secondaries, since my outputs board does not have SDA and SCL pins avaliable and my inputs
board has a loose trace which causes unstable functioning.
To try the example we found we started using just an Arduino MEGA (as master) and an Arduino UNO (as secondary) to try the communication between them.
Programming is pretty simple with Arduino IDE, and once both are connected they send data that can be read trough th serial monitor.
To generate the code it is neccesary the wire library to interact with the I2C bus with Arduino, it does not need to be installed since it comes b default with the Arduino IDE software.
#include "Wire.h"
const byte I2C_SLAVE_ADDR = 0x20;
long data = 100;
long response = 0;
void setup()
{
Serial.begin(115200);
Wire.begin();
}
void loop()
{
sendToSlave();
requestToSlave();
delay(2000);
}
void sendToSlave()
{
Wire.beginTransmission(I2C_SLAVE_ADDR);
Wire.write((byte*)&data, sizeof(data));
Wire.endTransmission();
}
void requestToSlave()
{
response = 0;
Wire.requestFrom(I2C_SLAVE_ADDR, sizeof(response));
uint8_t index = 0;
byte* pointer = (byte*)&response;
while (Wire.available())
{
*(pointer + index) = (byte)Wire.read();
index++;
}
Serial.println(response);
}
#include "Wire.h"
const byte I2C_SLAVE_ADDR = 0x20;
void setup()
{
Serial.begin(115200);
Wire.begin(I2C_SLAVE_ADDR);
Wire.onReceive(receiveEvent);
Wire.onRequest(requestEvent);
}
long data = 0;
long response = 200;
void receiveEvent(int bytes)
{
data = 0;
uint8_t index = 0;
while (Wire.available())
{
byte* pointer = (byte*)&data;
*(pointer + index) = (byte)Wire.read();
index++;
}
}
void requestEvent()
{
Wire.write((byte*)&response, sizeof(response));
}
void loop() {
if (data != 0)
{
Serial.println(data);
data = 0;
}
}
You can find this ino files here:
What I understand/learned from this outcome:
Next thing we tryed was setting my board as master and both Arduinos as secondaries. To upload the code to my board I used the ISP programmer developed in previous weeks
which uses MISO, SCK, RST, VCC, MOSI and GND.
Powered the Arduino UNO with an USB cable, powered the Arduino MEGA through a proto board and powered my board through FTDI with a programmer connected to the USB Port (I just have two ports on my computer).
Also, added the resistors following the previous diagram.
Using the previous code we made some modifications to set a second seconday in this case the Arduino Mega.
For the secondary's code we added the void luces taken from Arduino blink examples in order the turn on the leds when receiving data. We set the Arduino UNO
as the secondary 1 and the Arduino MEGA as secondary 2.
This is the result:
In Arduino IDE it is important to remember:
These sites have been really usefull troughout this process:
AranaCorpMultiple Arduinos with I2C Bus
Luis Llamas How to connect two Arduinos with I2C Bus
Programar fácilArduino - I2C Communication
Some times it turns so hard to discover where the problem is.
This task was very challenging for me, since code generation is a language that I have not mastered yet. For this reason I have left it to the end. After developing my final project, Diego's support, constant consultations about the concepts, a lot of time connecting and disconnecting my boards, correct answers, mistakes, tests and more tests, I have finally achieved it. It is still a long way to go but I am glad I made it.