Fab Academy 2024

TEST WITH Hans

The first thing you do is download the program

MQTTX is a cross-platform desktop application that makes it easy to connect and interact with MQTT brokers. It allows you to publish and subscribe to MQTT topics, send and receive messages, and monitor MQTT broker activity visually.

To use MQTTX, you first need to download and install the application on your computer. Once installed, you can configure it to connect to your MQTT broker. This usually involves providing the MQTT broker's IP address, port number, and, if necessary, authentication credentials.

The process involves the following:
1. Open MQTTX on your computer.
2. Connect MQTTX to your MQTT broker.
3. Post MQTT messages to the corresponding topic to control the neopixel of your partner's board, in my case hans.
4. Observe the response of the neopixel on your partner's plate when the message is received.

It is a powerful way to demonstrate remote communication between devices via the MQTT protocol.

"a" was turned on and "b" was turned off

TEST WITH RONALD

Imagine that you are in Lima, your classmate, is in Huánuco. They are both working on projects for Fab Academy, but it turns out that you need to control Ronald's device from Lima for testing or demonstrations. To achieve this, they have used Arduino Cloud, which is a cloud platform that allows the connection and remote control of Arduino devices over the Internet. Here's how it works in simple terms:

Connecting devices to the Arduino Cloud: First, Ronald has configured his Arduino device to connect to the Arduino Cloud. This involves using the Arduino IoT library and setting up the appropriate credentials in your code so that the device can communicate with the cloud platform.

Here we can see that it is on

Developing an application on Arduino Cloud: Then, you have accessed Arduino Cloud from your respective locations. They have created an application that allows you to control device remotely. This involves defining the necessary controls in the Arduino Cloud user interface to perform the desired actions, such as turning lights on and off, moving motors, etc.

Here it is paid, with the video it is clearer.

Share Access: Ronald has shared access to his device and app with your Arduino Cloud account. This means I can view and control Ronald's device from your own account, even while in Lima.
Remote Control: Now, from Lima, I can log into my Arduino Cloud account and access the application that Ronald has shared with me. From this app, you can send commands to Ronald's device and watch the changes happening in real time, such as turning lights on and off, moving motors, etc.

So from my home in Lima, to open the app on the Arduino Cloud and control Ronald's device in real time!able to turn lights on and off, move motors, you name it! It was like I was right there in Huánuco, even though we were miles away! Technology is amazing

Here it is paid, with the video it is clearer.

• LCD_humedad_cloud.ino

LCD

#include "thingProperties.h"
#include < LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27,20,4);  // set the LCD address to 0x27 for a 16 chars and 2 line display


void setup() {
  // Initialize serial and wait for port to open:
  Serial.begin(9600);
  // This delay gives the chance to wait for a Serial Monitor without blocking if none is found
  delay(1500); 

  // Defined in thingProperties.h
  initProperties();

  // Connect to Arduino IoT Cloud
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);
  setDebugMessageLevel(2);
  ArduinoCloud.printDebugInfo();

  lcd.int();                      // initialize the lcd 
  lcd.backlight();
  lcd.setCursor(0,0);
  lcd.print("Hola Silvana :D :");
}

void loop() {
  ArduinoCloud.update();
  // Your code here 
  
  
}

void onMensajeSilvChange()  {
  // Add your code here to act upon MensajeSilv change
  lcd.setCursor(0,1);
  lcd.print(mensaje_silv);
  delay(500);
}
							 

• OLEDDISPLAY.ino

Let's explore MQTT

First we look for mqttx, you can download it here.

here we make a new connection

We enter the name and connect

We send messages to turn Hans' lights on and off

What I did before, I repeated it again by creating a new subscription

We enter the data, in this case my name, the password

I started making my scheme

Here making the LCD inputs

I am making the DTH11 pins, taking into account the 3.3V power and signal pins

Here I placed an input to feed my board.

Here add a 4 pin to add other outputs

Here I see the list of components that I am using.

an overview of how my scheme is going

General view diagram

We load the symbol

We see connection errors or that something is not connected correctly or is not connected.

Final result

Here in 3D plan of how the tracks would go

Now we go to the mods to be able to enter SVG

Here it is placed in red, depending on what you export from kicad

I reversed it so that it is black and the tracks come out well.

We can see it in black and white now.

Now I changed the values to be able to mill, only everything went wrong, so I did it again.

Lines of my board

The edge of my end plate will be rectangular

Milling & Soldering the Board

Here I am placing the point of origin with which I will start the machine

Here I am placing the new coordinates of origin, I understand more and more how to use it.

Now I download the .rml file, place ADD and give it Output

After carefully reviewing the values I entered, guess what was very deep and my first test was ruined, I wanted to cry because I only had that piece of plate left T_T

Here set the slice and then the origin point to 0 and just the home on the Z axis to 40mm remember that so it doesn't scratch your plate.

Now I changed the values to be able to mill, only everything went wrong, so I did it again.

This is the successful result I had for my board, later I will show you my mistake.

Here I gathered everything I was going to need, and you know that it was very useful for soldering, the soldering paste, which is very difficult to get in Peru.

beautiful soldering, here I almost forgot to tell you that I also have the resistors and the LEDs ready to place it, as I told you, super easy to place with the paste.

Final result of my welding, shiny

Gathering the things we were going to need for our connection, we can see Hans' plates on which he became slaves and a master.

My board would be a slave, and Hans's board would be the master, our first test will be wired.

CABLE COMMUNICATION Group activity

Programming

We made a connection in I2C communication so that both can work via cables. The XIAO RP2040 C3 was used on my board and a XIAO ESP32 was used on Hans' board. I will show you the programming on each board, first Hans's and then mine.

HANS BOARD

	#include Wire.h

	const int sensorPin = D10; // PIN OF XIAO ESP32 C3
	
	void setup() {
	  Wire.begin(); // Start I2C communication
	  pinMode(sensorPin, INPUT);
	}
	
	void loop() {
	  int sensorValue = digitalRead(sensorPin);
	  Wire.beginTransmission(9); // Slave address
	  Wire.write(sensorValue);
	  Wire.endTransmission();
	  delay(1000); // Wait for 1 second before reading the sensor again
	}
	
	

• hans_board_1.ino

SILVANA BOARD

#include < WiFi.h>
#include < PubSubClient.h>
#include < Adafruit_NeoPixel.h>

const char* ssid = "TuSSID";
const char* password = "TuContraseña";
const char* mqtt_server = "broker.emqx.io";

const char* topic = "hans/switch";

#define NEOPIXEL_PIN 10
#define NUM_PIXELS 1

WiFiClient espClient;
PubSubClient client(espClient);

Adafruit_NeoPixel pixels(NUM_PIXELS, NEOPIXEL_PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
  pixels.begin();
}

void setup_wifi() {
  delay(10);
  Serial.println();
  Serial.print("Conectando a ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi conectado");
  Serial.println("Dirección IP: ");
  Serial.println(WiFi.localIP());
}

void callback(char* topic, byte* payload, unsigned int length) {
  String message = "";
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }
  Serial.print("Mensaje recibido desde el topic ");
  Serial.print(topic);
  Serial.print(": ");
  Serial.println(message);

  if (message == "a") {
    pixels.setPixelColor(0, pixels.Color(255, 0, 0)); // Rojo
    pixels.show();
  } else {
    pixels.setPixelColor(0, pixels.Color(0, 255, 0)); // Verde
    pixels.show();
  }
}

void reconnect() {
  while (!client.connected()) {
    Serial.print("Conectando al servidor MQTT...");
    if (client.connect("neopixelClient")) {
      Serial.println("Conectado");
      client.subscribe(topic);
    } else {
      Serial.print("falló, rc=");
      Serial.print(client.state());
      Serial.println(" intentando nuevamente en 5 segundos");
      delay(5000);
    }
  }
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
}
									
								

• silvana_board_1.ino

WIFI + MQTTX

MESSAGE BETWEEN HANS BOARD WIFI + MQTTX

Connections of the 2 boards via WIFI, we recommend communicating between 2 XIAO ESP32 C3 microcontrollers, Hans' board was the editor and works as a switch and my board has a neopixel as an output. To achieve communication we use MQTTX, where we must have a master (Hans board) and a slave (me), where I receive information from the master, process and perform the action that was programmed. First we connect both boards to a different computer and begin to program it so that they have communication between them via MQTTX.

Hans Board

	#include WiFi.h
    #include PubSubClient.h
                        
    const char* ssid = "YourSSID";
    const char* password = "YourPassword";
    const char* mqtt_server = "broker.emqx.io";
                        
    const char* topic = "week13/wifi"; // Topic
                        
    const int switchPin = D2; // Switch Pin
                        
    WiFiClient espClient;
   PubSubClient client(espClient);
                        
    int lastSwitchState = HIGH; // Previous switch state
                        
    void setup() {
                        Serial.begin(115200);
                        pinMode(switchPin, INPUT_PULLUP);
                        setup_wifi();
                        client.setServer(mqtt_server, 1883);
                        }
                        
                        void setup_wifi() {
                        delay(10);
                        Serial.println();
                        Serial.print("Connecting to ");
                        Serial.println(ssid);
                        
                        WiFi.begin(ssid, password);
                        
                        while (WiFi.status() != WL_CONNECTED) {
                        delay(500);
                        Serial.print(".");
                        }
                        
                        Serial.println("");
                        Serial.println("WiFi connected");
                        Serial.println("IP Address: ");
                        Serial.println(WiFi.localIP());
                        }
                        
                        void reconnect() {
                        while (!client.connected()) {
                        Serial.print("Connecting to MQTT server...");
                        if (client.connect("switchClient")) {
                        Serial.println("Connected");
                        } else {
                        Serial.print("failed, rc=");
                        Serial.print(client.state());
                        Serial.println(" trying again in 5 seconds");
                        delay(5000);
                        }
                        }
                        }
                        
             void loop() {
                        if (!client.connected()) {
                        reconnect();
                        }
                        client.loop();
                        
                        int switchState = digitalRead(switchPin);
                        if (switchState != lastSwitchState) { // If there's a change in switch state
                        if (switchState == LOW) {
                        client.publish(topic, "a");
                        Serial.println("Switch pressed");
                        } else {
                        client.publish(topic, "b");
                        Serial.println("Switch released");
                        }
                        lastSwitchState = switchState;
                        }
                        
                        delay(100); // Small delay to avoid switch bounce
                        }
                        								
								

• hans_board_2 .ino

Silvana Board

  #include WiFi.h
                        #include PubSubClient.h
                        #include Adafruit_NeoPixel.h

                        const char* ssid = "YourSSID";
                        const char* password = "YourPassword";
                        const char* mqtt_server = "broker.emqx.io";

                        const char* topic = "week13/wifi"; // same topic to publisher

                        #define NEOPIXEL_PIN D10
                        #define NUM_PIXELS 1

                        WiFiClient espClient;
                        PubSubClient client(espClient);

                        Adafruit_NeoPixel pixels(NUM_PIXELS, NEOPIXEL_PIN, NEO_GRB + NEO_KHZ800);

                        void setup() {
                        Serial.begin(115200);
                        setup_wifi();
                        client.setServer(mqtt_server, 1883);
                        client.setCallback(callback);
                        pixels.begin();
                        }

                        void setup_wifi() {
                        delay(10);
                        Serial.println();
                        Serial.print("Connecting to ");
                        Serial.println(ssid);

                        WiFi.begin(ssid, password);

                        while (WiFi.status() != WL_CONNECTED) {
                        delay(500);
                        Serial.print(".");
                        }

                        Serial.println("");
                        Serial.println("WiFi connected");
                        Serial.println("IP Address: ");
                        Serial.println(WiFi.localIP());
                        }

                        void callback(char* topic, byte* payload, unsigned int length) {
                        String message = "";
                        for (int i = 0; i < length; i++) {
                        message += (char)payload[i];
                        }
                        Serial.print("Message received from topic ");
                        Serial.print(topic);
                        Serial.print(": ");
                        Serial.println(message);

                        if (message == "a") {
                        pixels.setPixelColor(0, pixels.Color(255, 0, 0)); // Red
                        pixels.show();
                        } else {
                        pixels.setPixelColor(0, pixels.Color(0, 255, 0)); // Green
                        pixels.show();
                        }
                        }

                        void reconnect() {
                        while (!client.connected()) {
                        Serial.print("Connecting to MQTT server...");
                        if (client.connect("neopixelClient")) {
                        Serial.println("Connected");
                        client.subscribe(topic);
                        } else {
                        Serial.print("Failed, rc=");
                        Serial.print(client.state());
                        Serial.println(" trying again in 5 seconds");
                        delay(5000);
                        }
                        }
                        }

                        void loop() {
                        if (!client.connected()) {
                        reconnect();
                        }
                        client.loop();
                        }
                    									
								 

• silvana board .ino

WIFI FAIL

Files

By connecting the Arduino XIAO to the Arduino Cloud, you can access and control your device from anywhere with Internet access. This gives you the flexibility to monitor and manage your projects from any location.

Arduino Cloud offers an easy-to-use interface to monitor and control connected devices. This makes it more accessible to beginners or people without advanced programming experience. I really think you can use it if it's your first time making these connections.

With Arduino Cloud, you can program automated rules and actions for your devices. This allows you to create more sophisticated systems and automate specific tasks based on predefined conditions.

MQTTX provides an intuitive user interface that makes publishing easy

MQTTX is a powerful and versatile tool for remote communication and control of devices via the MQTT protocol.

Libaries

• DHT11.zip
• DHT_sensor_library.zip
• DHT_sensor_library_for_ESPx.zip
• LiquidCrystal_I2C.zip
• Adafruit_NeoPixel.zip
• ArduinoCloudThing.zip

Link

• MQTTX
• ARDUINO CLOUD
• Seeed Studio XIAO ESP32C3
• A Wi-Fi Switch for Domoticz using a XIAO ESP32C3 - Part 1
• ADRIAN TORRES
• SPI
• Asynchronous Serial Communication
• I2C

• Back to Top
• Interface and application programming