Added Serial protocols

Missing example for UART with image (will add when I have a sensor)

Author: pedromsousalima

content/micropython/03.micropython/05.communication/i2c/assets/circuitAccelerometer.png

@@ -0,0 +1,106 @@
+---
+title: Communication Protocol - I2C  
+description: Learn how to use I2C on Micropython
+author: Pedro Sousa Lima
+---
+
+#### Introduction
+Inter-Integrated Circuit, or **I2C**, is one of the most widely used serial communication protocols, especially in the Arduino ecosystem. It enables multiple devices to communicate over just two wires, making it both efficient and versatile as you can easily add new modules more easily as the connections all happen across the same bus and standetizes them across manufacturers (and product lines).
+
+
+#### How I2C Works
+I2C communication relies on two wires:
+- **SDA (Serial Data):** Transfers data between devices.
+- **SCL (Serial Clock):** Synchronizes data transmission.
+
+Each device on an I2C bus has a unique address, allowing the controller to communicate directly with a specific device. This capability makes it possible to connect up to 128 devices on the same two wires (128 is the maximum number of different adresses you can have as the adress is a 7 bit value and you can only express 128 unique values using 7 bits).
+
+![I2C Diagram](assets/i2c.png)
+
+
+#### Key Features of I2C
+1. **Two-Wire Simplicity:** Reduces hardware complexity.
+2. **Address-Based Communication:** Each device has a unique address.
+3. **Bidirectional Communication:** Enables data transfer in both directions.
+
+
+#### Example: Reading Sensor Data Using I2C
+In this example, we will connect an **LIS3DHTR accelerometer** to an Arduino and read its data via I2C.
+
+**Circuit Diagram:**
+![LIS3DHTR circuit.](assets/circuitAccelerometer.png)
+
+**Setup Instructions:**
+1. Connect the LIS3DHTR to your board as shown in the circuit diagram.
+2. Install the required `lis3dh` module by running the following command:
+
+   ```python
+   mip.install("https://raw.githubusercontent.com/tinypico/tinypico-micropython/master/lis3dh%20library/lis3dh.py")
+   ```
+
+3. Copy the following code to your `main.py` file and run it.
+
+**Code:**
+```python
+import lis3dh, time, math
+from machine import Pin, I2C
+
+i2c = I2C(sda=Pin(8), scl=Pin(9))
+imu = lis3dh.LIS3DH_I2C(i2c, address=0x19)
+
+last_convert_time = 0
+convert_interval = 100 #ms
+pitch = 0
+roll = 0
+
+# Convert acceleration to Pitch and Roll
+def convert_accell_rotation( vec ):
+    x_Buff = vec[0] # x
+    y_Buff = vec[1] # y
+    z_Buff = vec[2] # z
+
+    global last_convert_time, convert_interval, roll, pitch
+
+    # We only want to re-process the values every 100 ms
+    if last_convert_time < time.ticks_ms():
+        last_convert_time = time.ticks_ms() + convert_interval
+
+        roll = math.atan2(y_Buff , z_Buff) * 57.3
+        pitch = math.atan2((- x_Buff) , math.sqrt(y_Buff * y_Buff + z_Buff * z_Buff)) * 57.3
+
+    # Return the current values in roll and pitch
+    return ( roll, pitch )
+
+# If we have found the LIS3DH
+if imu.device_check():
+    # Set range of accelerometer (can be RANGE_2_G, RANGE_4_G, RANGE_8_G or RANGE_16_G).
+    imu.range = lis3dh.RANGE_2_G
+
+    # Loop forever printing values
+    while True:
+        # Read accelerometer values (in m / s ^ 2).  Returns a 3-tuple of x, y,
+        # z axis values.  Divide them by 9.806 to convert to Gs.
+        x, y, z = [value / lis3dh.STANDARD_GRAVITY for value in imu.acceleration]
+        print("x = %0.3f G, y = %0.3f G, z = %0.3f G" % (x, y, z))
+
+        # Convert acceleration to Pitch and Roll and print values
+        p, r = convert_accell_rotation( imu.acceleration )
+        print("pitch = %0.2f, roll = %0.2f" % (p,r))
+
+        # Small delay to keep things responsive but give time for interrupt processing.
+        time.sleep(0.1)
+```
+
+**Expected Output:**
+In the REPL terminal, you will see accelerometer data displayed every second. For example:
+![Expected Output](assets/repl-i2c-sensor.gif)
+
+```
+x = 0.001 G, y = -0.002 G, z = 1.000 G
+pitch = -0.12, roll = 0.04
+```
+
+
+#### Summary
+I2C is a highly efficient protocol that enables multiple devices to communicate on just two wires. In this example, we demonstrated how to read data from an I2C-connected sensor, opening the door to integrating even more devices into your Arduino projects.
+

content/micropython/03.micropython/05.communication/i2c/assets/i2c.png

@@ -0,0 +1,54 @@
+---
+title: Communication Protocol - SPI  
+description: Learn how to use SPI on Micropython
+author: Pedro Sousa Lima
+---
+
+#### Introduction
+The **Serial Peripheral Interface (SPI)** is a high-speed serial communication protocol widely used in embedded systems, including Arduino. It allows data exchange between devices using a straightforward and fast four-wire setup. Having a known and stadertized pinout makes easier to add new modules to your project as they remain the same across manufacturers (and product lines).
+
+
+
+#### How SPI Works
+SPI communication uses four main lines:
+- **COPI (Controller Out, Peripheral In):** Sends data from the controller to the peripheral.
+- **CIPO (Controller In, Peripheral Out):** Sends data from the peripheral to the controller.
+- **SCK (Serial Clock):** Synchronizes data transfer between devices.
+- **CS (Chip Select):** Activates a specific peripheral for communication.
+
+The controller initiates communication by enabling the peripheral through the **CS** line. Data is transmitted bit by bit in synchronization with the clock signal on the **SCK** line.
+
+
+
+#### Key Features of SPI
+1. **Full-Duplex Communication:** Simultaneous data transmission and reception.
+2. **High Speed:** Faster than I2C, suitable for performance-critical applications.
+3. **Multiple Devices:** Supports multiple peripherals, each with a dedicated **CS** line.
+4. **Simple Protocol:** No addressing required, reducing communication overhead.
+
+
+
+#### Example: Connecting an SPI Device
+In this example, we explore how to wire and interact with SPI devices using an Arduino. Many sensors and displays use SPI for their speed and reliability.
+
+**Wiring Diagram:**
+![How to wire SPI devices.](assets/spi.png)
+
+**Key Pins:**
+1. **COPI** (Controller Out, Peripheral In) – Sends data to the peripheral.
+2. **CIPO** (Controller In, Peripheral Out) – Receives data from the peripheral.
+3. **SCK** (Serial Clock) – Synchronizes data transfer.
+4. **CS** (Chip Select) – Enables the specific peripheral.
+
+**Example Operation:**
+SPI communication involves enabling a peripheral via the **CS** line, sending data through **COPI**, and receiving responses via **CIPO**.
+
+
+
+#### SPI in Practice
+Many common devices, such as high-speed sensors, displays, and memory modules, utilize SPI for its speed and efficient design. The protocol's simplicity makes it a go-to choice for connecting peripherals requiring high data throughput.
+
+
+
+#### Summary
+SPI is a robust, high-speed protocol that provides an efficient means of communication between an Arduino and peripherals. Its simplicity, speed, and flexibility make it an indispensable tool for a wide variety of electronics projects. With SPI, you can reliably handle everything from sensors to displays in performance-critical environments.

content/micropython/03.micropython/05.communication/i2c/assets/repl-i2c-sensor.gif

@@ -0,0 +1,43 @@
+---
+title: Communication Protocol - UART  
+description: Learn how to use UART on Micropython
+author: Pedro Sousa Lima
+---
+
+#### Introduction
+The **Universal Asynchronous Receiver-Transmitter (UART)** protocol is one of the simplest and most commonly used communication protocols. It is ideal for straightforward one-to-one communication between devices, making it a staple in embedded systems, including Arduino projects.
+
+
+#### How UART Works
+UART operates using two main lines:
+- **TX (Transmit):** Sends data from one device to another.
+- **RX (Receive):** Receives data from the transmitting device.
+
+Unlike protocols like I2C or SPI, UART is asynchronous, meaning it does not require a clock signal to synchronize communication. Instead, both devices agree on a common baud rate, which determines the speed of data transmission.
+
+
+#### Key Features of UART
+1. **Two-Wire Simplicity:** Minimal wiring requirements with only TX and RX lines.
+2. **Asynchronous Communication:** No clock line needed.
+3. **Configurable Baud Rates:** Common rates include 9600, 115200, and others.
+4. **One-to-One Communication:** Designed for direct communication between two devices.
+
+
+#### Example: Communicating via UART
+UART is widely used for debugging, serial monitors, and communication with modules like GPS or GSM. In this example, we connect an Arduino to a UART-enabled device.
+
+**Wiring Diagram:**
+![How to wire UART devices.](assets/uart.png)
+
+**Key Pins:**
+1. **TX:** Connects to the RX pin of the receiving device.
+2. **RX:** Connects to the TX pin of the transmitting device.
+3. **GND:** Establishes a common ground between devices.
+
+
+#### Practical Example
+The example provided in the original article demonstrates how UART facilitates direct, real-time communication between devices. When implemented, UART ensures reliable transmission of data, making it invaluable for basic communication needs.
+
+
+#### Summary
+UART remains a cornerstone protocol for simple, direct communication between devices. Its ease of use and minimal hardware requirements make it an essential tool for debugging and connecting peripherals in Arduino and other embedded systems.