Week 13: Embedded Networking and Communications

Group assignment: Click here

• Send a message between two projects.
• Document your work to the group work page and reflect on your individual page what you learned.

Since, There is now one working with me for this week so I have no other project or team member to do the group assignment with him, I decide to talk about the opportunity to talk about two communication methods, SPI and I2C.

An important part is the communication between devices and/or projects, so today I will take the opportunity to talk about two communication methods, SPI and I2C.

1. SPI (Serial Peripheral Interface):

The SPI (Serial Peripheral Interface) bus was developed by Motorola in 1980. It has a master-slave architecture. The master device (master) can initiate communication with one or more slave devices (slave), and send or receive data from them. On the SPI bus, data communication between masters and slaves is carried out on two independent lines, one from the master to the slaves, and another from the slaves to the master. Therefore, the communication is Full Duplex, that is, the master can send and receive data simultaneously.

The SPI bus requires a minimum of 3 lines:

1. MOSI (Master-out, slave-in) for communication from master to slave.
2. MISO (Master-in, slave-out) for communication from the slave to the master.
3. SCK (Clock) clock signal sent by the master.



SPI characteristics:

1. High transmission speed and Full Duplex.
2. It can send bit streams of any size, without splitting and without interruptions.
3. 3 cables (SCK, MOSI and MISO) + 1 additional cable (SS) are required for each slave device.
4. There is no control mechanism available, that is, we cannot know if the message has been received and even less if it has been - received correctly.

2. I2C (Inter-Integrated Circuit):

The I2C (Inter-Integrated Circuit) standard was developed by Philips in 1982 for the internal communication of electronic devices in its articles. The I2C bus requires only two cables for its operation, one for the clock signal (CLK) and another for the data transmission (SDA), which is an advantage over the SPI bus. The I2C bus has a master-slave architecture. The master device initiates communication with the slaves, and can send or receive data from the slaves. Slaves cannot start communication (master has to ask them).

The SPI bus requires of 2 lines:

1. SDA (Serial Data)
2. SCL (Serial CLock)



I2C characteristics:

1. Requires few cables
2. It has mechanisms to verify that the signal has arrived
3. His speed is medium-low
4. It isn’t full duplex

SPI (Serial Peripheral Interface):

for Group assigment I will use SPI method to connect to Arduino UNO board together as one is Master and other is slave, since I use I2C in the Individual assigment.

Connection layout

and I connect the RED led to pin 3 in the slave board

Conde it:

Slave code:

String Message;  // Declare a string variable to store incoming serial messages

void setup() {
  Serial.begin(9600);  // Initialize serial communication at 9600 baud
  Serial.setTimeout(50);  // Set the timeout for reading serial data to 50 milliseconds (default is 1 second)
  delay(100);  // Delay for stability
  pinMode(3, OUTPUT);  // Set digital pin 3 as an output
}  // setup

void loop() {
  // put your main code here, to run repeatedly:

  if (Serial.available()) {
    Message = Serial.readString();  // Read the incoming serial message and store it in the 'Message' variable
  }

  delay(4);  // Introduce a small delay to avoid continuous checking and improve performance

  if (Message == "on") {
    digitalWrite(3, HIGH);  // If the received message is "on", set digital pin 3 to HIGH
  }

  if (Message == "off") {
    digitalWrite(3, LOW);  // If the received message is "off", set digital pin 3 to LOW
  }
  // Message = "\0";  // Uncomment if you want to reset the Message variable after each loop iteration
}  // loop

Master code:

String Message;  // Declare a string variable to store incoming serial messages

void setup() {
  Serial.begin(9600);  // Initialize serial communication at 9600 baud
  delay(100);  // Delay for stability
}

void loop() {
  // Print "on" and "off" messages to serial every 2.5 seconds
  Serial.print("on");
  delay(2500);
  Serial.print("off");
  delay(2500);

  // Check if there's any serial data available
  if (Serial.available()) {
    Message = Serial.readString();  // Read the incoming serial message and store it in the 'Message' variable
  }

  // Uncomment the line below to print the received message to the serial monitor
  // Serial.println(Message);
}

Code Explanation:

The idea behind these Arduino code snippets is to showcase a simple serial communication scenario between two Arduino programs. The first code snippet is intended to control a digital output (pin 3) based on the messages received through the serial port. The second code snippet is a simple sender that continuously sends "on" and "off" messages to the serial port every 2.5 seconds.

Test it :

#include 

void setup() {
  Wire.begin(9);                  // Initialize I2C communication as Slave with address 9
  Wire.onReceive(receiveEvent);   // Register event function for incoming data
  Serial.begin(9600);              // Initialize serial communication
  pinMode(D1, OUTPUT);
}

void loop() {
  // Additional processing can be done in the loop if needed
}

void receiveEvent(int bytes) {
  char receivedChar = Wire.read();  // Read the character sent by the master
  Serial.print("Received character: ");
  Serial.println(receivedChar);

    if (receivedChar == 'O') {
        digitalWrite(D1, HIGH);  // Assuming D1 is the correct pin
      } else if (receivedChar == 'F'){
        digitalWrite(D1, LOW);   // Assuming D1 is the correct pin
      } 
  // Add your logic based on the received data
}

#include 

void setup() {
  Wire.begin();        // Initialize I2C communication as Master
  Serial.begin(9600);  // Initialize serial communication
}

void loop() {
  Wire.beginTransmission(9);  // Address of the slave
  Wire.write('O');           // Send a character to the slave
  Wire.endTransmission();     // Stop transmitting

  delay(2000);  // Wait for a second before sending the next command

  Wire.beginTransmission(9);  // Address of the slave
  Wire.write('F');           // Send a character to the slave
  Wire.endTransmission();     // Stop transmitting
    delay(2000);
}