Display16x2 LCD com comunicação I2C - Arquivo 023

Referência:
http://www.arduinoecia.com.br/2014/12/modulo-i2c-display-16x2-arduino.html

Lista de Materiais:
IDE Arduino 1.0
1x  Board Arduino UNO
1x  Protoboard 830 furos
1x  Cabo USB-A male to USB-B male 
1x  Conj. de fios jumper p/ protoboard
1x  Display 16x2 ITM1602B
1x  PCI Display LCD comunicação I2C
2x  Resistor 10K

Montagem:

PCI LCD COMUNICAÇÃO I2C

Circuito Eletrônico da PCI

Firmware:

#include <Wire.h>
#include <LiquidCrystal_I2C.h>


// Inicializa o display no endereco 0x3F
LiquidCrystal_I2C lcd(0x3F,5,6,7,4,0,1,2,3, POSITIVE);

void setup()
{
 lcd.begin (20,4);
}

void loop()
{
  lcd.setBacklight(HIGH);
  lcd.setCursor(3,0);
  lcd.print("MRM Automacao");
  lcd.setCursor(0,2);
  lcd.print("PCI LCD");
  lcd.setCursor(0,3);
  lcd.print("COMUNICACAO I2C");
  delay(1000);
  lcd.setBacklight(LOW);
  delay(1000);
}

Download: Wire.h  

Download: LiquidCrystal_I2C.h

Sensor de Pressão MPX5050GP - Arquivo 022

Referência: 
http://www.practicalarduino.com/projects/water-tank-depth-sensor

Lista de Materiais:
IDE Arduino 1.0
1x  Board Arduino UNO
1x  Protoboard 830 furos
1x  Cabo USB-A male to USB-B male 
1x  Conj. de fios jumper p/ protoboard
1x  Sensor de pressão MPX5050GP
1x  Resistor 470R 1/4w
1x  Trimpot 10k
1x  Display ITM1602B
1x  Mangueira de Silicone (p/ testes)
1x  Seringa 5ml (p/ testes)

Montagem:

Firmware:

#include <LiquidCrystal.h>

int sensorPin = A0;
int sensorValue = 0;
float Vout, Value_Kpa, Value_mmHg;

LiquidCrystal lcd(2,3,4,5,6,7);

void setup() {
  lcd.begin(16, 2);
  lcd.display();
}

void loop() {
  sensorValue = analogRead(sensorPin);
  Vout = (sensorValue * 0.00459);         //0.004594330400782013
  Value_Kpa = (Vout - 0.2)/0.09;
  Value_mmHg = Value_Kpa * 7.50061;       //7.50061561303

  if(Value_Kpa < 0) Value_Kpa = 0, Value_mmHg = 0;

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(Value_Kpa, 0);
  lcd.print("Kpa");
  lcd.setCursor(11, 0);
  lcd.print(Vout);
  lcd.print("V");

  lcd.setCursor(0, 1);
  lcd.print(Value_mmHg, 0);
  lcd.print("mmHg");
  delay(500);
}

Download: MPX5050GP   
Download: ITM1602B

GLCD I2C LCM12864J - Arquivo 021

Referência:
http://www.gammon.com.au/forum/?id=10940

Lista de Materiais:
IDE Arduino 1.0.6
1x  Board Arduino UNO
1x  Protoboard 830 furos
1x  Cabo USB-A male to USB-B male 
1x  Conj. de fios jumper p/ protoboard
1x  C.I. MCP23017 Microchip
1x  Trimpot 10k
1x  GLCD LCM12864J

Montagem:

Firmware:

#include <Wire.h>

#include <SPI.h>

#include <I2C_graphical_LCD_display.h>

I2C_graphical_LCD_display lcd;

byte picture [] PROGMEM = {

 0x1C, 0x22, 0x49, 0xA1, 0xA1, 0x49, 0x22, 0x1C,  // face  

 0x10, 0x08, 0x04, 0x62, 0x62, 0x04, 0x08, 0x10,  // star destroyer

 0x4C, 0x52, 0x4C, 0x40, 0x5F, 0x44, 0x4A, 0x51,  // OK logo

};

void setup () {

  lcd.begin ();  

  for (int i = ' '; i <= 0x7f; i++)

    lcd.letter (i);

    lcd.clear (6, 40, 30, 63, 0xFF);

    lcd.gotoxy (40, 40);

    lcd.string ("Nick Gammon.", true);

    lcd.gotoxy (40, 56);

    lcd.blit (picture, sizeof picture);

    lcd.frameRect (40, 49, 60, 53, 1, 1);

    lcd.line (6, 40, 30, 63, 0);   

} 

void loop () {

} 

Download: I2C_graphical_LCD_display.h

LDR 10mm - Arquivo 020

Referência:
https://inovabots.wordpress.com/tutoriais/arduino/contrle-de-luminosidade-ldrleds/

Lista de Materiais:
IDE Arduino 1.0.6
1x  Board Arduino UNO
1x  Protoboard 830 furos
1x  Cabo USB-A male to USB-B male 
1x  Conj. de fios jumper p/ protoboard
1x  LDR 5mm
1x  Resistor 10k 1/4w

Montagem:

Firmware:
int PinoLeitura = A0;
int ValueLDR;

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

void loop(){
  ValueLDR = analogRead(PinoLeitura);
  Serial.print("Leitura LDR (0 a 1023):");
  Serial.println(ValueLDR);
  delay(500);
}

Download: não necessário

Sensor de temperatura MLX90615 - Arquivo 019

Referência:
http://www.artilhariadigital.com/2014/11/Medir-temperatura-com-sensor-infravermelho-MLX90614-e-Arduino.html

Lista de Materiais:
IDE Arduino 1.0.6
1x  Board Arduino UNO
1x  Protoboard 830 furos
1x  Cabo USB-A male to USB-B male 
1x  Conj. de fios jumper p/ protoboard
1x  Sensor de temperatura MLX90615
2x  Resistor 4,7k 1/4w
1x  Capacitor cerâmico 0,1uF

Montagem:

Firmware:
#include <i2cmaster.h>

void setup(){
Serial.begin(9600);
Serial.println("Setup...");

i2c_init(); //Inicializa a comunicação I2C
PORTC = (1 << PORTC4) | (1 << PORTC5);// Habilita os pullups
}

void loop(){
int dev = 0x5B<<1;
int data_low = 0;
int data_high = 0;
int pec = 0;

i2c_start_wait(dev+I2C_WRITE);
i2c_write(0x07);

i2c_rep_start(dev+I2C_READ);
data_low = i2c_readAck(); //Faz a leitura de 1 byte e depois envia ack
data_high = i2c_readAck(); //Faz a leitura de 1 byte e depois envia ack
pec = i2c_readNak();
i2c_stop();

//Converte os bytes high e low juntos e processa a temperatura, MSB é um bit de erro que é ignorado para temperaturas
double tempFactor = 0.02; // 0.02 graus por LSB (resolução do MLX90615)
double tempData = 0x0000; // Zera os dados 
int frac; // dados apos o ponto decimal

// Mascara o bit de erro do high byte, e depois move para esquerda 8 bits e soma o low byte.
tempData = (double)(((data_high & 0x007F) << 8) + data_low);
tempData = (tempData * tempFactor)-0.01;

float celcius = tempData - 273.15;

Serial.print("Celcius: ");
Serial.println(celcius);

delay(1000); // Espera 1 segundo antes de fornecer uma nova saida.
}

Download: i2cmaster.h

Sensor de efeito hall SS41 - Arquivo 018

Referência:
http://labdegaragem.com/profiles/blogs/tutorial-como-utilizar-o-sensor-de-efeito-hall-com-arduino

Lista de Materiais:
IDE Arduino 1.0.6
1x  Board Arduino UNO
1x  Protoboard 830 furos
1x  Cabo USB-A male to USB-B male 
1x  Conj. de fios jumper p/ protoboard
1x  Sensor hall Ss41
1x  Resistor 330R 1/4w

Montagem:

Firmware:
int hallPin = 13;
int statePin = 1, oldstatePin = 1;

void setup(){
  pinMode(hallPin,INPUT);
  Serial.begin(9600);
}

void loop(){
  statePin = digitalRead(hallPin);
  if(statePin == HIGH && oldstatePin == LOW){
    Serial.println("North");
  }
  else if (statePin == LOW && oldstatePin == HIGH){
    Serial.println("South");
  }
  oldstatePin = statePin;
  delay(500);
}

Download: não necessário

SD Card Shield DFR0165 - Arquivo 017

Referência:
http://www.dfrobot.com/wiki/index.php/Mega_IO_Expansion_Shield_V2.3_(SKU:DFR0165)

Lista de Materiais:
IDE Arduino 1.0.6
1x  Board Arduino MEGA 2560
1x  Cabo USB-A male to USB-B male 
1x  Mega IO Expansion Shield V.2.3
1x  Mini SD Card

Montagem:

Firmware:
#include <SPI.h>
#include <SD.h>

const int chipSelect = 4;

void setup(){
  Serial.begin(9600);
  while (!Serial) {
    ;
  }


  Serial.print("Initializing SD card...");

  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
    return;
  }
  Serial.println("card initialized.");
}

void loop(){
  String dataString = "";

  for (int analogPin = 0; analogPin < 3; analogPin++) {
    int sensor = analogRead(analogPin);
    dataString += String(sensor);
    if (analogPin < 2) {
      dataString += ",";
    }
  }

  File dataFile = SD.open("datalog.txt", FILE_WRITE);

  if (dataFile) {
    dataFile.println(dataString);
    dataFile.close();
    Serial.println(dataString);
  }
  else {
    Serial.println("error opening datalog.txt");
  }
}

Download: não necessário

Button I2C PCF8547 - Arquivo 016

Referência: 
http://www.dfrobot.com/

Montagem:

Firmware:
#include <Wire.h>

int NewX=0, OldX=0, y=0;
int ExitReadButton = 1,
    oldstate1 = 0,
    oldstate2 = 0,
    oldstate3 = 0,
    oldstate4 = 0,
    oldstate5 = 0,
    oldstate6 = 0,
    oldstate7 = 0,
    oldstate8 = 0;

const int Addr_Button = 0x38;

void setup(){
  Wire.begin();
  Serial.begin(9600);
}

void loop(){
  Wire.requestFrom(Addr_Button,1);    
  ReadButton();
  Serial.println(y);                                            
}

void ReadButton(){
  byte x;
  do{
   Wire.requestFrom (Addr_Button,1);
   if(Wire.available()) x = Wire.read();
   
   if (x == 254 && oldstate1 == 0) oldstate1 = 1;
   if (x == 255 && oldstate1 == 1){
     y = 0;
     oldstate1 = 0;
     ExitReadButton = 0;
   }
   
   if (x == 253 && oldstate2 == 0) oldstate2 = 1;
   if (x == 255 && oldstate2 == 1){
     y = 1;
     oldstate2 = 0;
     ExitReadButton = 0;
   }
   
   if (x == 251 && oldstate3 == 0) oldstate3 = 1; 
   if (x == 255 && oldstate3 == 1){
     y = 2;
     oldstate3 = 0;
     ExitReadButton = 0;
   }
   
   if (x == 247 && oldstate4 == 0) oldstate4 = 1; 
   if (x == 255 && oldstate4 == 1){
     y = 3;
     oldstate4 = 0;
     ExitReadButton = 0;
   }
   
   if (x == 239 && oldstate5 == 0) oldstate5 = 1; 
   if (x == 255 && oldstate5 == 1){
     y = 4;
     oldstate5 = 0;
     ExitReadButton = 0;
   }
   
   if (x == 223 && oldstate6 == 0) oldstate6 = 1; 
   if (x == 255 && oldstate6 == 1){
     y = 5;
     oldstate6 = 0;
     ExitReadButton = 0;
   }
   
   if (x == 191 && oldstate7 == 0) oldstate7 = 1; 
   if (x == 255 && oldstate7 == 1){
     y = 6;
     oldstate7 = 0;
     ExitReadButton = 0;
   }
   if (x == 127 && oldstate8 == 0) oldstate8 = 1; 
   if (x == 255 && oldstate8 == 1){
     y = 7;
     oldstate8 = 0;
     ExitReadButton = 0;
   }
  }while(ExitReadButton);
  delay(200);
  ExitReadButton = 1;
}

Download: Schematic Mega Shield

Como Scannear dispositivos no barramento I2C - Arquivo 015

Referêcia:
http://www.arduinoecia.com.br/2015/04/arduino-lcd-16x2-modulo-i2c-rtc-ds1307.html

Lista de Materiais:
IDE Arduino 1.0.6
1x  Board Arduino UNO
1x  Protoboard 830 furos
1x  Cabo USB-A male to USB-B male 
1x  Conj. de fios jumper p/ protoboard
1x  Sensor de temperatura MLX90615
1x  C.I. DS1307 RTC
1x  Display I2C / Drive PCF8574AP

Montagem:
Esse programa varre o barramento I2C e mostra no serial monitor o endereço dos dispositivos conectados.

Firmware:
#include <Wire.h>
//****************************************************************************
void setup(){
  Wire.begin();
  Serial.begin(9600);
  Serial.println("\nI2C Scanner");
}
//****************************************************************************
void loop(){
  byte error, address;
  int nDevices;
  Serial.println("Scanning...");
  nDevices = 0;
  for(address = 1; address < 127; address++ ) {
    // The i2c_scanner uses the return value of
    // the Write.endTransmisstion to see if
    // a device did acknowledge to the address.
    Wire.beginTransmission(address);
    error = Wire.endTransmission();

    if (error == 0){
      Serial.print("I2C device found at address 0x");
      if (address<16) 
        Serial.print("0");
      Serial.print(address,HEX);
      Serial.println("  !");
      nDevices++;
    }
    else if (error==4) {
      Serial.print("Unknow error at address 0x");
      if (address<16) 
        Serial.print("0");
      Serial.println(address,HEX);
    }    
  }
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");
  delay(5000);         
}

Download: não necessário

Sensor Monóxido de Carbono MQ-7 - Arquivo 014

Referência:
http://arduino.rechena.com/?p=313

Lista de Materiais:
IDE Arduino 1.0.6
1x  Board Arduino NANO
1x  Protoboard 830 furos
1x  Cabo USB-A male to USB-Mini male 
1x  Conj. de fios jumper p/ protoboard
1x  Sensor monóxido de carbono MQ-7

Montagem:

Firmware:
int sensorValue; 
//*********************************************************************** 
void setup(){
  Serial.begin(9600);                           // sets the serial port to 9600
}
//*********************************************************************** 
void loop(){
  sensorValue = analogRead(0);         // read analog input pin 0
  Serial.print("Value: ");
  Serial.println(sensorValue, DEC);   // prints the value read
  delay(250);                                       // wait 250ms for next reading
}

Download: não necessário

Acelerômetro ADXL330 - Arquivo 013

Referência:
http://playground.arduino.cc/Portugues/LearningADXL3xx

Lista de Materiais:
IDE Arduino 1.0.6
1x  Board Arduino UNO
1x  Protoboard 830 furos
1x  Cabo USB-A male to USB-B male 
1x  Acelerômetro ADXL330

Montagem:

Firmware:
int groundPin = 18;             // pino de entrada analógica 4
int powerPin = 19;              // pino de entrada analógica 5
int xpin = 3;                   // eixo x do acelerômetro
int ypin = 2;                   // eixo y
int zpin = 1;                   // eixo z (disponível só em modelos triaxiais)

void setup()
{
  Serial.begin(9600);

  // Fornecer terra e energia mediante o uso das entradas analógicas
  // como pinos digitais comuns. Isso permite conectar a placa de
  // prototipagem diretamente no Arduino. No caso de se usar os pinos
  // normais GND e 5V do Arduino, pode-se remover as quatro linhas
  // abaixo.
  pinMode(groundPin, OUTPUT);
  pinMode(powerPin, OUTPUT);
  digitalWrite(groundPin, LOW); 
  digitalWrite(powerPin, HIGH);
}

void loop()
{
  Serial.print(analogRead(xpin));
  Serial.print(" ");
  Serial.print(analogRead(ypin));
  Serial.print(" ");
  Serial.print(analogRead(zpin));
  Serial.println();
  delay(1000);
}

Download: não necessário

Controlando Led RGB com Arduino e Processing - Arquivo 012

Referência:
http://blog.bsoares.com.br/processing/controlling-rgb-led-with-arduino-and-processing

Lista de Materiais:
IDE Arduino 1.0.6
IDE Processing 3 3.0b6 Alpha
1x  Board Arduino NANO
1x  Protoboard 830 furos
1x  Cabo USB-A male to USB-mini male 

1x  Conj. de fios jumper p/ protoboard
1x  Bolinha de ping-pong
1x  Led RGB - Catodo comum
2x  Resistor 90R 1/4w
1x  Resistor 150R 1/4w

Montagem:

Firmware - Arduino:
#define START_COLOR_CHAR '^'
#define END_COLOR_CHAR '$'
#define COLOR_SIZE 8
#define PIN_RED 9
#define PIN_GREEN 11
#define PIN_BLUE 10
//******************************************************************************* char serialMessage[COLOR_SIZE];
unsigned int readChar;
unsigned int count;
unsigned long color;
unsigned int r;
unsigned int g;
unsigned int b;
boolean readingSerial;
//******************************************************************************* void setup() {
  Serial.begin(9600);
  readingSerial = false;
}
//******************************************************************************* void loop() {
  if (Serial.available() > 0 && !readingSerial) {
    if (Serial.read() == START_COLOR_CHAR) {
      serialReadColor();
    }
  }
}
//******************************************************************************* void serialReadColor() {
  readingSerial = true;
  count = 0;
  
  iniReading:
  if (Serial.available() > 0) {
    readChar = Serial.read();
    if (readChar == END_COLOR_CHAR || count == COLOR_SIZE) {
      goto endReading;
    } else {
      serialMessage[count++] = readChar;
      goto iniReading;
    }
  }
  goto iniReading;
  
  endReading:
  readingSerial = false;
  serialMessage[count] = '\0';
  
  setColor(serialMessage);
}
//******************************************************************************* void setColor(char* value)
{
  // Convert Char* to Long
  color = atol(value);
  
  // Extract RGB
  r = color >> 16 & 0xFF;
  g = color >>  8 & 0xFF;
  b = color >>  0 & 0xFF;
  
  // Send values to analog pins
  analogWrite(PIN_RED, r);
  analogWrite(PIN_GREEN, g);
  analogWrite(PIN_BLUE, b);

}

Firmware - Processing:
import processing.serial.*;

Serial port;
//******************************************************************************* void setup() {
  size(100, 150);
  noStroke();
  // Background
  colorMode(HSB, 100);
  for (int i = 0; i < 100; i++) {
    for (int j = 0; j < 100; j++) {
      stroke(i, j, 100);
      point(i, j);
    }
  }
  // Select port
  println(Serial.list());
  //port = new Serial(this, Serial.list()[1], 9600);
  port = new Serial(this, "COM16", 9600);        
}
//******************************************************************************* void draw() {
  // Only to enable the method mouseDragged
}
//******************************************************************************* void mouseClicked() {
  processColor();
}
//******************************************************************************* void mouseDragged() {
  processColor();
}
//*******************************************************************************
void processColor() {
  color c = get(mouseX, mouseY);
  noStroke();
  fill(c);
  rect(0, 100, 100, 50);
  sendColorToSerial(c);
}
//******************************************************************************* void sendColorToSerial(color colour) {
  // Get HEX
  String hexColor = hex(colour, 6);
  
  // Convert HEC to Number
  long numColor = unhex(hexColor);
  
  // Send color number to serial port
  port.write("^" + numColor + "$");
}

Download: https://processing.org

Módulo RF 434MHz - Arquivo 011

Referência:
http://labdegaragem.com/profiles/blogs/como-utilizar-os-modulos-rf-link-315mhz-434mhz
https://www.pjrc.com/teensy/td_libs_VirtualWire.html

Lista de Materiais:
IDE Arduino 1.0.6
1x  Board Arduino UNO
1x  Board Arduino NANO
2x  Protoboard 830 furos
1x  Cabo USB-A male to USB-B male 
1x  Cabo USB-A male to USB-Mini male
1x  Conj. de fios jumper p/ protoboard
1x  Módulo receptor 434MHz
1x  Módulo transmissor 434MHz
2x  Antena telescópica
4x  Push Button
4x  Led vermelho
4x  Resistor 220R 1/4w
4x  Resistor 10k 1/4w

Montagem:

Firmware:
RF Transmitter
#include <VirtualWire.h> 

char *nibble = "0000"; 

int le_pino; 

void setup(){
  vw_set_ptt_inverted(true);
  vw_setup(2000);
  vw_set_tx_pin(2);

  for(int i=3; i<=6; i++){
    pinMode(i, INPUT_PULLUP);
  }
}
void loop(){
  int j=0;
  for(int i=3;i<=6;i++,j++){
    le_pino = digitalRead(i);
    if(le_pino == 1){
      while(le_pino == 1) le_pino = digitalRead(i); 
      nibble[j] = '1'; 
    }
    else nibble[j] = '0'; 
  }
vw_send((uint8_t *)nibble, strlen(nibble)); 
  vw_wait_tx(); 

}

RF Receiver
#include <VirtualWire.h>

void setup(){
  vw_set_ptt_inverted(true);
  vw_setup(2000);
  vw_set_rx_pin(2);
  vw_rx_start();

  for(int i=3;i<=6;i++){
    pinMode(i, OUTPUT);
  }
}

void loop(){
  uint8_t buf[VW_MAX_MESSAGE_LEN]; 
  uint8_t buflen = VW_MAX_MESSAGE_LEN; 

  if(vw_get_message(buf, &buflen)){
    int j=3;
    for (int i = 0; i < buflen; i++,j++){
      buf[i] = buf[i] - 48; 
      if(buf[i] == 1){
        digitalWrite(j,!digitalRead(j));
      }
    }
  }
}

Download: VirtualWire.h