Week 14. Networking and Communications

Like the previous week, there are two types of assignments, one group and one individual. In my case being alone in the Fab Lab, I do both.

  • Design, build, and connect wired or wireless node(s) with network or bus addresses. ✔
  • Send a message between two projects. You need to send a message between any combination of boards, computers and/or mobile devices. ✔
  • Linked to the group assignment page. ✔
  • Documented your project. ✔
  • Documented what you have learned from implementing networking and/or communication protocols. ✔
  • Explained the programming process/es you used. ✔
  • Outlined problems and how you fixed them. ✔
  • Included design files (or linked to where they are located if you are using a board you have designed and fabricated earlier) and original code. ✔

Like every week, my weekly schedule. 😊

This week I will try to communicate my phototransistor board created in week 09 with the servo board created in week 11 with a Serial Bus communication. If it works, my next step is to use this networking for my final project, for this I will make new boards integrating everything I need. 😊

Group Assignment

The Group Assignment page is at the following link.

If you click on this link, you go to the Group Assignment section that I have done for this week.

Serial Bus.

For this assignment I am going to use a cable communication, for this I am going to use the Serial Bus. As Neil explains in class, the serial communication consists of two cables, TX (Transmitter) and RX (Receiver). Through these cables we can send information to other microcontrollers.

Phototransistor + Servo

To perform serial communication, I will use the boards designed and manufactured in the week of inputs and outputs. In this case, the sensor I use is the phototransistor and the actuator is the servo.

For this I am going to connect the Phototransistor through the FTDI connector, using the TX and RX pins (I had to have placed other pins higher, learned the lesson 😅) and the Servo through the pins that I connected to the Serial Bus. To learn a little more about this form of communication, I am guided by the documentation of Paco Gonzalez de Deusto from 2016 and Elena Cardiel from Fab Lab León of 2019.

- First attempt (It didn't work)

Looking at the documentation, I realize that I have to cross the TX and the RX on one of the two boards. In other words, the TX of the photransistor with the RX of the servo and the RX of the phototransistor with the TX of the servo. Later in the Arduino program, I will use the Software Serial library, to use this library I have to declare which are the TX and RX pins of the ATtiny1614. Going back to my Embedded Programming documentation for the week, the ATtiny1614 uses the TX on pin 5 and the RX on pin 4.

So this would be the connection with my cables.

    Phototransistor (Node).
  • Brown-> GND.
  • Red -> VCC.
  • Orange -> TX.
  • Yellow -> RX.
    Servo (Bridge).
  • Brown -> GND.
  • Red -> VCC.
  • Orange -> RX.
  • Yellow -> TX.

This is the real connection.

Using the Arduino codes of Elena and Paco, I test to see if it works and communicates one board with the other. The servo will move depending on the values that the phototransistor emits.

And it does not work. 😭 The sevo vibrates, but does not move. I check the physical connections, I check the program, changing the speed (from 115200 to 9600, in case a slower speed is necessary), I invert the TX and RX values in the Servo program. Neither.

I speak to my super programming guru and instructor, Pablo Nuñez. We review together the first program, the phototransistor program. I tell him that when I connect it with the FTDI to the computer, no sensor values appear. Weird first thing. For this I use the program that I use in the input week. I also used the Serial.write(); this serves to send binary values (true or false, 0 or 1) does not serve to send ASCI values. For this you have to use the Serial.println().

Once the phototransistor program has been corrected, I check if I have values for the serial via the FTDI and it is correct. I go to the servo program, from the original program I remove the serial.print(), because it is not necessary and can create confusion for the servo. I reload the program to ATtiny1614 and plug the FTDI into the board. The servo continues to vibrate and no data comes through the serial. Pablo asks me how the TX and RX connections are, I tell him they are crossed and he asks me why?

- Second attempt (Works)

The reason is because I saw that in Paco's scheme he did it this way; and Pablo tells me that being a bus the TX connects to the TX and the RX to the RX. So you can hang as many nodes on the bus as you want, otherwise it would be a point to point. Important: You do not have to cross the TX and RX cables.

In addition, following the assignment of Hugo F. Garcia, IED student of the year 2019, I use the address in the Node with the number 1, so that the Bridge receives it. In the code below it can be seen.

So I connect the cables well and it works. As the light varies a lot, and although the value is mapped, the servo moves a lot, but it works.

This is the correct connection.

    Phototransistor (Node).
  • Brown-> GND.
  • Red -> VCC.
  • Orange -> TX.
  • Yellow -> RX.
    Servo (Bridge).
  • Brown -> GND.
  • Red -> VCC.
  • Orange -> TX.
  • Yellow -> RX.

These are the two programs:

Phototransistor Node

//Original code of Adrián Torres. Fab Academy 2020
//Fab Lab León
//ATtiny1614

int sensorPin = 1;    // analog input pin to hook the sensor to
int sensorValue = 0;  // variable to store the value coming from the sensor
int adress = 1;  // addressing number for the bus. 
 
void setup() {
  Serial.begin(115200); // initialize serial communications
}
 
void loop() {
  sensorValue = analogRead(sensorPin); // read the value from the sensor
  sensorValue = map(sensorValue, 0, 1024, 1024, 0);
  Serial.println(sensorValue); // print value to Serial Monitor
  Serial.print(adress); //ID of the other board
  Serial.print(",");
  Serial.println(sensorValue);
  //mySerial.println("x"); // print value "x" to Serial Monitor
  delay(500); // short delay so we can actually see the numbers

}  

Servo Bridge

//Original code made by Paco Gonzalez. Fab Academy 2016 and Hugo F. Garcia. Fab Academy 2019.
//Modified Adrián Torres. Fab Academy 2020
//Fab Lab León
//ATtiny1614

#include 
SoftwareSerial serial_servo(5,4); //tx, rx
#include 
Servo myservo;  // create servo object to control a servo
// twelve servo objects can be created on most boards

int id, value; // this is going to be the variable that we read. 
int MyId = 1; //  variable that we will compare with what comes to us from the bus. The bus will send us a 1.


//int pos = 0;    // variable to store the servo position

void setup() {
  serial_servo.begin(115200);
  myservo.attach(3);  // attaches the servo on pin 3 to the servo object
 
}

void loop(){
  int value;
   if (serial_servo.available()){
    id = serial_servo.parseInt();
    if (id == MyId){
    value = serial_servo.parseInt();
    }
    else {
    value = 0;
    }
  }
  if (value > 0) { // if we are receiving data from de sensor...
  int angle=map(value,0,1024,0,120); //the servo angle, using the values from 0 to 1024 and from 0 to 120 degrees.
  myservo.write(angle);
  }
}

Phototransistor + Servo + Led's

Once I have managed to communicate two boards, the next spiral development is to connect another board, in this case the Hello Led that I had designed in the week of outputs.

The connection of the wiring will be as follows, continuing with the wiring of the Phototransistor and the Servo, through the FTDI connector I connect the TX and RX to the Bus connector of the Hello LED. For the ATtiny412 the TX and RX pins correspond to 2 and 3 respectively.

In the Arduino program, I configure it to light up the LED when there are values greater than 100 on the Bus. And this is the video. I think it takes a while for the LED to glow because there is too much information on the BUS, or noise.

The Arduino code.

//code made by Adrián Torres
//Fab Academy 2020
//Fab Lab León
//ATtiny412

#include 
SoftwareSerial serial_led(2, 3); //tx, rx

int id, value; // this is going to be the variable that we read. 
int MyId = 1; //  variable that we will compare with what comes to us from the bus. The bus will send us a 1.

int ledPin1 = 0; //led1

 
void setup() {
  serial_led.begin(115200);
  pinMode(ledPin1, OUTPUT);

}
 
void loop(){
   int average;
   if (serial_led.available()){
    id = serial_led.parseInt();
    if (id == MyId){
    average = serial_led.parseInt();
    }
    else {
    average = 0;
    }
  }
    if (average > 100) {
       digitalWrite(ledPin1, HIGH); // led on
    }
    else if (average <= 100) {
      digitalWrite(ledPin1, LOW); // led off
  }
}

Conclusions:

Bus Serial communication becomes a bit complicated if you do not follow the instructions well (problem of crossing the TX, RX cables). But then it seems simple, you send a lot of information on the bus and the Bridge has to manage it. Also try disconnecting the node from the Bridge, and the Bridge does nothing.

For the project, now I have to filter the data of the nodes, and send only with the Serial.write() function a character or a 1 or 0; so there is not so much information on the Bus.

Here is the files to download.

Group Assignment

The week of Interface and Application Programming I was using ESP32 to communicate via wifi with a webserver in different programming languages.

Send a message from my board to the computer

Using the phototransistor board, I will tell you that when the values are less than 20, I will print the message "Train passing" on the screen. It could serve to warn me in my project that a train is coming.

This would be the result.

This would be the Arduino code.


//code made by Adrián Torres
//Fab Academy 2020
//Fab Lab León
//ATtiny1614

#include 

int sensorPin = 1;    // analog input pin to hook the sensor to
int sensorValue = 0;  // variable to store the value coming from the sensor

int adress = 1;
 
void setup() {
  Serial.begin(115200); // initialize serial communications
}
 
void loop() {
  sensorValue = analogRead(sensorPin); // read the value from the sensor
  sensorValue = map(sensorValue, 0, 1024, 1024, 0);
  if (sensorValue <= 20) {
    Serial.print(adress);
    Serial.print(","); 
    Serial.println ("TRAIN PASSING"); //the train is passing.
    delay(500);
    }
}

Here is the files to download.

Littlebits. CloudBit

Nuria told me about the possibility of using LittleBits, since there is a board that allows you to connect to the internet via Wifi and you can send sensor signals or activate actuators.

LittleBits are small electronic modules that join together to create and prototype projects very quickly. The "Poderosas" or the "Jovenes Makers" use them to discover the electronics. Also by its colors you can know if it is power, an input or an output.

One of the modules is the CloudBit. This module integrates a Wifi module to which we can connect it to a Wifi and interact from the computer or smartphone with the LittleBits.

The first thing we do is connect the power, a button and a CloudBit. We open the next page where we create a project, in my case I have called it FABACADEMY.

Once we open, we follow the steps that it asks of us. There is a point where we have to connect to the Wifi that the CloudBit creates, and then tell it that Wifi must connect. Once it is connected, we will disconnect from the Wifi of the CloudBit and we will return to the usual Wifi (it will be the same that we use for the Cloudbit). When we have the CloudBit connected to the Wifi, the LED on the board will turn green and the following screen will appear, where we can interact with the different Bits.

Once I have tested that the CloudBit receives and sends information if I press the button, I decide to create an API with the IFTTT platform. IFTTT is a platform that is used for IOT and applications. For example, you receive a sound alert to your CloudBit every time an email arrives. Unfortunately, this union between LittleBits and IFTTT worked very well before, but since the absorption of LittleBits by Sphero there are things that no longer work.

So I can only use LittleBits Cloud Control, which allows me to measure a sensor and run an actuator. In this case I use a pressure sensor and an LED matrix. This is the result. 😍

This is the arrangement of the Bits.

Files

Find below the files that I made for this assignment.

Final Project. Networking.

For my final project I am going to try to use networking to communicate through the Serial Bus two nodes (which are two phototransistors) with a brigde (which is the board with the servos for the barriers). This is my scheme.

After testing the Serial Bus, I decide to use it to communicate my boards in the Final Project. For this I design two new boards.

The first one is an ATtiny412 with a phototransistor. It will be a node, and there will be two boards to detect the passage of the train. I take advantage of the leftover pins of the ATtiny412 to place connectors. As a trick, I frame with yellow paint where the yellow cable (GND) is connected and in the red power connector where the positive of the external power goes. Like the board in the picture, I have made two.

The second is a bridge, which will use an ATtiny1614 to connect the servos of the level crossing barriers. In addition, a digital output will activate the other board that it manufactures for the level crossing lights.

As Plan B, I have placed two connectors for two phototransistors, in case I cannot achieve Networking, that the board serves me for the final project in the same way, by incorporating inputs and outputs.

This would be the connection of the new boards, it is important to check on the flat cable, which are the positions of VCC, GND, TX and RX. For this I paint the VCC pin red.

Now there is the programming part, for me the hardest, I hope to get it. 😅 💪 Working progress...

Files

Find below the files that I made for the final project.

  • Node Phototransistor Schematic and Board ATtiny412
  • Bridge Servos Schematic and Board ATtiny1614
  • Node Phototransistor Traces
  • Node Phototransistor Interior
  • Bridge Servos Traces
  • Bridge Servos Interior