CODING TIME

1ST ATTEMPT

For practice the first concept about serial communications, i decided to follow the arduino reference at their Official Website and was researching in other students assignments for have new conclusions and understand better the things to do.

After i had clear my RX and TX pin at my boards i decided to connect boths following the correspondance learned from datasheet read :

For serial communication, i need the SoftwareSerial Library installed at my Arduino IDE, so here are the references followed :

The Arduino hardware has built-in support for serial communication on pins 0 and 1 (which also goes to the computer via the USB connection). The native serial support happens via a piece of hardware (built into the chip) called a UART. This hardware allows the Atmega chip to receive serial communication even while working on other tasks, as long as there room in the 64 byte serial buffer.

The SoftwareSerial library has been developed to allow serial communication on other digital pins of the Arduino, using software to replicate the functionality (hence the name "SoftwareSerial"). It is possible to have multiple software serial ports with speeds up to 115200 bps. A parameter enables inverted signaling for devices which require that protocol.

The version of SoftwareSerial included in 1.0 and later is based on the NewSoftSerial library by Mikal Hart.

The SoftwareSerial Library has been developed to allow serial communication to take place on the other digital pins of your boards, using software to replicate the functionality of the hardwired RX and TX lines. This can be extremely helpful when the need arises to communicate with two serial enabled devices, or to talk with just one device while leaving the main serial port open for debugging purpose.

My Co2 Sensor Board was giving me a short noisy range of values. Then, for test if the Serial Communication is working properly, I hand-shacked the values to send over serial between the two boards.

In the example at his refrence web page, digital pins 10 and 11 on your Arduino or Genuino boards are used as virtual RX and TX serial lines. The virtual RX pin is set up to listen for anything coming in on via the main serial line, and to then echo that data out the virtual TX line. Conversely, anything received on the virtual RX is sent out over the hardware TX.

My boards are using 0 and 1 for RX and TX so i modiffied the example for have appropiate pins to this numbers, the other thing i made was change the baudrate to 9600 and add a custom message for know that my sensor is living.

SOFTWARE SERIAL EXAMPLE MODIFFIED

First i made a test for blink the mosi led

2. I modiffied the Software serial example for practice the monitor serial communication :

/*
 Software serial multiple serial test

 Receives from the hardware serial, sends to software serial.
 Receives from software serial, sends to hardware serial.

 The circuit:
 * RX is digital pin 0 (connect to TX of other device)
 * TX is digital pin 1 (connect to RX of other device)

 created back in the mists of time
 modified 25 May 2012
 by Tom Igoe
 based on Mikal Hart's example

 This example code is in the public domain.

 */
#include 

SoftwareSerial mySerial(0,1); // RX, TX

void setup() {
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for native USB port only
  }


  Serial.println("Hi I´m a Air Pollution detector!");

  // set the data rate for the SoftwareSerial port
  mySerial.begin(9600);
  mySerial.println("Hello, world?");
}

void loop() { // run over and over
  if (mySerial.available()) {
    Serial.write(mySerial.read());
  }
  if (Serial.available()) {
    mySerial.write(Serial.read());
  }
}

2nd ATTEMPT

THE MASTER SEND DATA TO THE SLAVE FOR INTERACT WITH THE COMPUTER

Here are some references programs which o adapted for use with my boards.

void setup() {
  // initialize
  Serial.begin(9600);
}

void loop() {
  Serial.print('0');
  delay(100);
  Serial.print('1');
  delay(100);

}

READ DATA FROM SERIAL TO ANOTHER BOARD

// Arduino read data from serial from another Arduino

const int ledPin =  11;      // the number of the LED pin where i attached my led MOSI

char data;

void setup() {
  // initialize
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  data = Serial.read();
  
  if (data == '1') {
    digitalWrite(ledPin, HIGH);
    // Debug if the data check works
    Serial.print("ok");
} else {
 digitalWrite(ledPin, LOW);
  }
  delay(100);
}

CO2 SENSOR SEND VALUES TO A LED

I wrote this program for test the Master Board with the sensor with the idea to approximate to the final idea

float MQ 135 = 7;  
int gas = 0; 
int valgas = 0; 
int LED = 11;
void setup () {
  Serial.begin (9600);
  pinMode (LED, OUTPUT);
  //digitalWrite (LED, 0); 
}

void loop () {
  // We read the gas data, and behave accordingly
  valgas = analogRead(MQ 135);
  Serial.println(valgas);
  
  if (valgas <= 200){
      digitalWrite (LED, LOW); 
      delay (1000); 
    }
    else if (valgas > 200) {

     digitalWrite (LED, HIGH); 
     delay (1000); 
   } 
}

PRINTING POLLUTION RISK AT SERIAL

void valgas () {
  gas = analogRead (MQ 135);
  Serial.println (PollutionRisk);
}

USING INPUT AND OUTPUT BOARDS AS SLAVES

The idea is use my computer as a Master, so i must to connect my boards in serie so TX from my Input board must to be connected to the TX from my Output Board. The first Slave will be coonnect to the computer trought RX.

So here is the program for the first Slave :

 
int led = 11;

char activar = 0;
char name = '1';
int Tx = 1; 

void setup () {

pinMode (led, OUTPUT);
Serial.begin (9600);

}

void loop () {

digitalWrite (Tx, LOW); // Tx in tristate
pinMode (Tx, OUTPUT); 

 if (Serial.available ()) {
    activar = Serial.read ();
    Serial.println (activar);
    
  if (activar == name) {
  pinMode (Tx, OUTPUT);
  digitalWrite (led,HIGH);
  Serial.print ("nodo 1");
  delay (1000);
  digitalWrite (led,LOW);
    }
   else { 
   digitalWrite (Tx, LOW);
   }
    }
     }   

 

int led = 11;

char activar = 0;
char name = '2'; 
int Tx = 1; 

void setup () {
pinMode (led, OUTPUT);
Serial.begin (9600);
}

void loop () {
  // Tx in tristate
digitalWrite (Tx, LOW);
pinMode (Tx, OUTPUT); 
pinMode (Tx, INPUT);



 if (Serial.available ()) {
 activar = Serial.read ();
    Serial.println (activar);
    if (activar == name) {
    pinMode (Tx, OUTPUT);
    digitalWrite (led,HIGH);
    Serial.println ("nodo 2");
    delay (1000);

  digitalWrite (led,LOW);
    }
    else{digitalWrite (Tx, LOW);}
}
 } 
 

For finnish i connected both boards : RX to RX and TX to TX and GND to GND and VCC to VCC and the NODE 1 (The CO2 board ) to the computer trying to send message from monitor and see how them is ocmmunicates :

WEEK PROBLEMS

I have a problem designing my slave board, i forgot the DTR pin so as my instructor learned to me, i miss all the logic of the board so she suggested me, focuss in my final project and design a possible final board. So the rest of teh assignment i finished with this board.

This weeks i have some problems to understand correctly the task to do. why? the Neil example is really clear and i wont to fabricate the boards suggested but my instructor suggested me focuss in my final project and use another board fabricated in previous assignment so this cause me some confussions but thanks to Cova and her simple explanations finally i made my programs.

THINGS LEARNED

As i never made something similar, all the assignment learned me a lot and now i can connect more than 3 processors using my terminal as a master.

WEEK FILES

Node 1 design

Node 2 Design

All Programming files

MY FINAL PROJECT

Thinking in my final Project i begin with the CO2 Sensor Callibration explained in my

Final Project Process Page at Programming processes section.

MY SENSOR:

References about Gas Sensors

I found at the Arduino Offical Web page some refrences about the use of this kind of sensors, there you can find basic overwiew with data sheets about the family but i decided copied to this page for never forget the basics things :

Introduction

The MQ series of gas sensors use a small heater inside with an electro-chemical sensor. They are sensitive for a range of gasses and are used indoors at room temperature.

They can be calibrated more or less (see the section about "Load-resistor" and "Burn-in") but a know concentration of the measured gas or gasses is needed for that.

The output is an analog signal and can be read with an analog input of the board i designed.

Read the datasheet

Try to find a few datasheets for the sensor, and read them careful.

Since there are no electronic components inside, therefor most sensors can be used with AC and DC voltages.

Be careful when connecting it for the first time. If the pins are connected wrong, the sensor could get damaged, or it could be broken instantly. There are also shields available with these sensors pre-installed.

Wiring

The preferred wiring is to connect both 'A' pins together and both 'B' pins together. It is safer and it is assumed that is has more reliable output results. Although many schematics and datasheets show otherwise, you are advised to connect both 'A' pins together and connect both 'B' pins together.

In the picture, the heater is for +5V and is connected to both 'A' pins. This is only possible if the heater needs a fixed +5V voltage.

The variable resistor in the picture is the load-resistor and it can be used to determine a good value. A fixed resistor for the load-resistor is used in most cases.

The Vout is connected to an analog input of the Board designed

The heater

The voltage for the internal heater is very important.

Some sensors use 5V for the heater, others need 2V. The 2V can be created with a PWM signal, using analogWrite() and a transistor or logic-level mosfet.

The heater may not be connected directly to an output-pin of the Arduino, since it uses too much current for that.

Some sensors need a few steps for the heater. This can be programmed with an analogWrite() function and delays. A transistor or logic-level mosfet should also in this situation be used for the heater.

If it is used in a battery operated device, a transistor or logic-level mosfet could also be used to switch the heater on and off.

The sensors that use 5V or 6V for the internal heater do get warm. They can easily get 50 or 60 degrees Celcius.

After the "burn-in time", the heater needs to be on for about 3 minutes (tested with MQ-2) before the readings become stable.

Load-resistor

The sensor needs a load-resistor at the output to ground. It's value could be from 2kOhm to 47kOhm. The lower the value, the less sensitive. The higher the value, the less accurate for higher concentrations of gas.

If only one specific gas is measured, the load-resistor can be calibrated by applying a know concentration of that gas. If the sensor is used to measure any gas (like in a air quality detector) the load-resistor could be set for a value of about 1V output with clean air.

Choosing a good value for the load-resistor is only valid after the burn-in time.

Burn-in

Some datasheets use the term "preheat", but it is the time to burn-in the sensor. This is meant to make the sensor readings more consistent. A time of 12 or 24 hours is usually used for the burn-in time.

The Burn-in is achieved by applying normal power to the sensor (to the heater and with the 'A' and 'B' pins connected, and with a load-resistor). In some special cases a specific burn-in is needed. See the datasheet if the sensor needs such a specific burn-in.

Interesting links

Machine olfaction (electronic nose) using MQ-series gas sensors:Electronic Noise

This instructable uses a Figaro sensor and explains how to use them: http://www.instructables.com/id/How-To-Smell-Pollutants/

The Figaro sensors work the same as the MQ series sensors.

Wikipedia has an article about electrochemical gas sensors: http://en.wikipedia.org/wiki/Electrochemical_gas_sensor

MQ135 : A Sensor For Air Quality

- The heater uses 5V.

An example how to use it:

Learning Basics

An example with calculation of the CO2 value:

Meter Using MQ 135.

Search for datasheet:

Meter Using MQ 135.

Networking: Master Test I from Pilu Caballero on Vimeo.

Faito v. 01 : High Bright Led Board from Pilu Caballero on Vimeo.

1TESTVOLTAGE_SERIAL from Pilu Caballero on Vimeo.

PROGRAMING INPUT DEVICES : TEST MQ135 WITH LITHIUM ION POWER SUPPLY from Pilu Caballero on Vimeo.

The processes for callibrated the sensors was a fight but finally i can detect some differents atmospherics gases. You can know more about this process in my Final Project Process Page :

Process Web Page

OUTPUT DEVICES Receives information data from INPUT DEVICE blinking bright Leds described at Electronics section with mapped values from the analog sensor.

High Bright Leds from Pilu Caballero on Vimeo.

Testing Slave Board with a Bright Led from Pilu Caballero on Vimeo.

All the Files about this programs are at my :

Final Project Page at WEEK FILES SECTION.