# AQUARIOFILIA MARINHA > DIY - Faça Você Mesmo >  Pedido de Ajuda para configuração de hardware ARDUINO.

## Sérgio Paulo

Olá companheiros, já à algum tempo a esta parte que tinha deixado o meu pequeno oceano na "sombra", mas neste momento e como estou a remodelar tudo (desde aquário, móvel, iluminação, e controlo, venho aqui pedir a vossa opinião e ouvir aqueles que sabem, do que me aconselham para uma boa gestão de recursos/economias para que possa através de um *ARDUINO* fazer a gestão do que será o meu mais recente mundo aquático.

Assim sendo, apresento-vos o aquário que recentemente foi desmantelado e o novo que foi comprado e alterado e, fará dentro de pouco em breve, parte integrante do mobiliário.


*O antigo aquário e o** recente ainda em construção.*

   

Agora a minha questão é a seguinte:

Controlar o aquário com um ARDUINO para fazer o controlo de:

*Controlo das bombas*:

Controlar os dois boiadores que penso que se podem ligar directamente ao Arduino (na linha de (3.3V ou 5V), e quando algum deles actuar irá fornecer sinal a um input do Arduino que por sua vez irá armar cada um o seu relé (ordem gerada pelo Arduino que actua o relé mediante o boiador que for actuado.

Ex: Se o boiador "A" do aquário for actuado fará actuar o relé que desligará a bomba "A".
O mesmo acontecerá com o boiador e bomba "B", mas este além de desligar a bomba "B" deverá também desligar a bomba "A".

Em ambos os casos, eu pretendia que no display aparecesse a mensagem de erro, ou seja, no caso do boiador "B" a mensagem seria (ERROR - SUMP EMPTY) e no caso do boiador "A" a mensagem seria (ERROR - OVERFLOW FULL).

*Controlo de lâmpadas*:

As lâmpadas são geridas em três grupos, sendo estas também controladas por relés.
eX: O Arduino ligará a lâmpada "1" às 16:00, a lâmpada "3" às 16:15, e depois desligará a lâmpada "1" às 23:00 e a lâmpada 
"3" às 23:15 e, só ligará os Led´s "2" (através também de um relé) às 23:20 e só os desliga às 07:00.
Neste caso pretendo ter sempre o relógio certinho, daí lhe ter que incorporar um RTC (Real Time Clock, até para o caso de haver falha de luz e o relógio não se desfasar da hora real).

*Controlo do termóstato (por segurança, além do controlo do próprio)*:

Este controlo deverá ser possível editar no próprio Arduino (temperatura desejada), pois posso agora pretender ajustar (através de um relé) os valores do controlo para os 26,5 ºC e no inverno para os 27 ºC.

Agora passemos ao hardware que necessitava, e é aqui que peço a vossa ajuda, e pelo que tenho lido cada vez me vejo mais confuso.  :Admirado: 

Pelo que já li por aí, parece-me que existem umas réguas com relés que são shield e assim encaixam-se direitinhas no Arduino.

O ARDUINO MEGA e aqui estava a pensar em duas variantes:

Caso seja possível gostaria de trabalhar no MEGA com um LCD touch screen, mas caso o código dê muito trabalho ou seja complicado, terei de trabalhar com um normal (4 x 20 com retro-iluminação em azul) mas tenho de ter keypad, e no futuro poderei adicionar outro tipo de controlos, como sondas para a salinidade, PH, entre outros.

Penso que esteja uma explicação perceptível das minhas pretensões, caso tenham alguma duvida estejam à vontade para me questionarem.

Desde já obrigado pela ajuda que me possam prestar.

Desenho para ilustrar o texto:



Sou todo ouvidos às vossas sugestões.

----------


## Fernando Garcia

Sérgio, boa noite!

Não sou a melhor pessoa para falar do assunto mas, penso que para o que pretendes os 4 primeiros itens deste post é suficiente http://www.reefforum.net/showthread....l=1#post187953 além da placa com os relés como esta por exemplo http://iteadstudio.com/store/index.p...roducts_id=449.
Dê uma olhada neste tópico http://www.reefforum.net/showthread....l=1#post184746.

Uma observação para este trecho

"As lâmpadas são geridas em três grupos, sendo estas também controladas por relés.
eX: O Arduino ligará a lâmpada "1" às 16:00, a lâmpada "3" às 16:15, e depois desligará a lâmpada "1" às 23:00 e a lâmpada
"3" às 23:15 e, só ligará os Led´s "2" (através também de um relé) às 23:20 e só os desliga às 07:00."

Os horários de liga/desliga devem se sobrepor para não haver apagões momentaneos. Da forma que escreveu terá um apagão de 5 minutos entre 23:15 e 23:20.
Espero que ajude.
Abraço.
Fernando Garcia

----------


## Sérgio Paulo

Olá boa noite Fernando,

Desde já obrigado pela ajuda e colaboração, irei ver o hardware que indicaste e caso ainda tenha alguma duvida posto aqui e peço também ajuda ao Pedro Ferrer, pois pelo que pude passar os olhos pelos posts dele, deu-me a impressão que ele teve alguns problemas com o RTC dele.

No entanto e face ao que gostaria de ter (caso seja possível e a programação seja relativamente fácil), era o display ser touch screen, e mesmo o mega sou capaz de optar pelo de 2560 em vez do 1280.

Mas muito obrigado Fernando, assim já tenho uma noção do que irei necessitar, pois para quem começa a ler sobre o tema à uma semana apenas ainda há muitas duvidas.

Quem mais quiser comentar agradeço todas as ideias e opiniões.
Sérgio.

----------


## Fernando Garcia

Olá!
Dê uma olhada neste código só para um relógio.




// ITDB02_Analog_Clock (C)2010 Henning Karlsen
// web: http://www.henningkarlsen.com/electronics
//
// This program was made simply because I was bored.
//
// Hardware requirements:
//  - Arduino Mega
//  - ITDB02 module
//  - ITDB02 Mega Shield
//
// Software requirements:
//  - ITDB02_Graph16 or ITDB02_Graph libraries
//  - ITDB02_Touch library
//  - DS1307 library
//
// This program shuold work on the ITDB02-3.2WC module, but
// keep in mind that this program was made to work on
// the 240x320 modules, so it will not use the added 
// pixels of the ITDB02-3.2WC.
//

// Remember to change the next line if you are using an 8bit module!
#include <ITDB02_Graph16.h>
#include <DS1307.h>
#include <ITDB02_Touch.h>

// Declare which fonts we will be using
extern uint8_t SmallFont[];
extern uint8_t BigFont[];

ITDB02        myGLCD(38,39,40,41);   // Remember to add ASPECT_16x9 if you are using an ITDB02-3.2WC!
ITDB02_Touch  myTouch(6,5,4,3,2);

// Init the DS1307
DS1307 rtc(20, 21);

// Init a Time-data structure
Time  t;

int clockCenterX=119;
int clockCenterY=119;
int oldsec=0;

void setup()
{
  myGLCD.InitLCD(LANDSCAPE);
  myGLCD.setFont(BigFont);

  myTouch.InitTouch(LANDSCAPE);
  myTouch.setPrecision(PREC_HI);

  // Set the clock to run-mode
  rtc.halt(false);
}

void drawDisplay()
{
  // Clear screen
  myGLCD.clrScr();

  // Draw Clockface
  myGLCD.setColor(0, 0, 255);
  myGLCD.setBackColor(0, 0, 0);
  for (int i=0; i<5; i++)
  {
    myGLCD.drawCircle(clockCenterX, clockCenterY, 119-i);
  }
  for (int i=0; i<5; i++)
  {
    myGLCD.drawCircle(clockCenterX, clockCenterY, i);
  }

  myGLCD.setColor(192, 192, 255);
  myGLCD.print("3", clockCenterX+92, clockCenterY-8);
  myGLCD.print("6", clockCenterX-8, clockCenterY+95);
  myGLCD.print("9", clockCenterX-109, clockCenterY-8);
  myGLCD.print("12", clockCenterX-16, clockCenterY-109);
  for (int i=0; i<12; i++)
  {
    if ((i % 3)!=0)
      drawMark(i);
  }  
  t = rtc.getTime();
  drawMin(t.min);
  drawHour(t.hour, t.min);
  drawSec(t.sec);
  oldsec=t.sec;

  // Draw calendar
  myGLCD.setColor(255, 255, 255);
  myGLCD.fillRoundRect(240, 0, 319, 85);
  myGLCD.setColor(0, 0, 0);
  for (int i=0; i<7; i++)
  {
    myGLCD.drawLine(249+(i*10), 0, 248+(i*10), 3);
    myGLCD.drawLine(250+(i*10), 0, 249+(i*10), 3);
    myGLCD.drawLine(251+(i*10), 0, 250+(i*10), 3);
  }

  // Draw SET button
  myGLCD.setColor(64, 64, 128);
  myGLCD.fillRoundRect(260, 200, 319, 239);
  myGLCD.setColor(255, 255, 255);
  myGLCD.drawRoundRect(260, 200, 319, 239);
  myGLCD.setBackColor(64, 64, 128);
  myGLCD.print("SET", 266, 212);
  myGLCD.setBackColor(0, 0, 0);
}

void drawMark(int h)
{
  float x1, y1, x2, y2;

  h=h*30;
  h=h+270;

  x1=110*cos(h*0.0175);
  y1=110*sin(h*0.0175);
  x2=100*cos(h*0.0175);
  y2=100*sin(h*0.0175);

  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x2+clockCenterX, y2+clockCenterY);
}

void drawSec(int s)
{
  float x1, y1, x2, y2;
  int ps = s-1;

  myGLCD.setColor(0, 0, 0);
  if (ps==-1)
    ps=59;
  ps=ps*6;
  ps=ps+270;

  x1=95*cos(ps*0.0175);
  y1=95*sin(ps*0.0175);
  x2=80*cos(ps*0.0175);
  y2=80*sin(ps*0.0175);

  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x2+clockCenterX, y2+clockCenterY);

  myGLCD.setColor(255, 0, 0);
  s=s*6;
  s=s+270;

  x1=95*cos(s*0.0175);
  y1=95*sin(s*0.0175);
  x2=80*cos(s*0.0175);
  y2=80*sin(s*0.0175);

  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x2+clockCenterX, y2+clockCenterY);
}

void drawMin(int m)
{
  float x1, y1, x2, y2, x3, y3, x4, y4;
  int pm = m-1;

  myGLCD.setColor(0, 0, 0);
  if (pm==-1)
    pm=59;
  pm=pm*6;
  pm=pm+270;

  x1=80*cos(pm*0.0175);
  y1=80*sin(pm*0.0175);
  x2=5*cos(pm*0.0175);
  y2=5*sin(pm*0.0175);
  x3=30*cos((pm+4)*0.0175);
  y3=30*sin((pm+4)*0.0175);
  x4=30*cos((pm-4)*0.0175);
  y4=30*sin((pm-4)*0.0175);

  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x3+clockCenterX, y3+clockCenterY);
  myGLCD.drawLine(x3+clockCenterX, y3+clockCenterY, x2+clockCenterX, y2+clockCenterY);
  myGLCD.drawLine(x2+clockCenterX, y2+clockCenterY, x4+clockCenterX, y4+clockCenterY);
  myGLCD.drawLine(x4+clockCenterX, y4+clockCenterY, x1+clockCenterX, y1+clockCenterY);

  myGLCD.setColor(0, 255, 0);
  m=m*6;
  m=m+270;

  x1=80*cos(m*0.0175);
  y1=80*sin(m*0.0175);
  x2=5*cos(m*0.0175);
  y2=5*sin(m*0.0175);
  x3=30*cos((m+4)*0.0175);
  y3=30*sin((m+4)*0.0175);
  x4=30*cos((m-4)*0.0175);
  y4=30*sin((m-4)*0.0175);

  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x3+clockCenterX, y3+clockCenterY);
  myGLCD.drawLine(x3+clockCenterX, y3+clockCenterY, x2+clockCenterX, y2+clockCenterY);
  myGLCD.drawLine(x2+clockCenterX, y2+clockCenterY, x4+clockCenterX, y4+clockCenterY);
  myGLCD.drawLine(x4+clockCenterX, y4+clockCenterY, x1+clockCenterX, y1+clockCenterY);
}

void drawHour(int h, int m)
{
  float x1, y1, x2, y2, x3, y3, x4, y4;
  int ph = h;

  myGLCD.setColor(0, 0, 0);
  if (m==0)
  {
    ph=((ph-1)*30)+((m+59)/2);
  }
  else
  {
    ph=(ph*30)+((m-1)/2);
  }
  ph=ph+270;

  x1=60*cos(ph*0.0175);
  y1=60*sin(ph*0.0175);
  x2=5*cos(ph*0.0175);
  y2=5*sin(ph*0.0175);
  x3=20*cos((ph+5)*0.0175);
  y3=20*sin((ph+5)*0.0175);
  x4=20*cos((ph-5)*0.0175);
  y4=20*sin((ph-5)*0.0175);

  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x3+clockCenterX, y3+clockCenterY);
  myGLCD.drawLine(x3+clockCenterX, y3+clockCenterY, x2+clockCenterX, y2+clockCenterY);
  myGLCD.drawLine(x2+clockCenterX, y2+clockCenterY, x4+clockCenterX, y4+clockCenterY);
  myGLCD.drawLine(x4+clockCenterX, y4+clockCenterY, x1+clockCenterX, y1+clockCenterY);

  myGLCD.setColor(255, 255, 0);
  h=(h*30)+(m/2);
  h=h+270;

  x1=60*cos(h*0.0175);
  y1=60*sin(h*0.0175);
  x2=5*cos(h*0.0175);
  y2=5*sin(h*0.0175);
  x3=20*cos((h+5)*0.0175);
  y3=20*sin((h+5)*0.0175);
  x4=20*cos((h-5)*0.0175);
  y4=20*sin((h-5)*0.0175);

  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x3+clockCenterX, y3+clockCenterY);
  myGLCD.drawLine(x3+clockCenterX, y3+clockCenterY, x2+clockCenterX, y2+clockCenterY);
  myGLCD.drawLine(x2+clockCenterX, y2+clockCenterY, x4+clockCenterX, y4+clockCenterY);
  myGLCD.drawLine(x4+clockCenterX, y4+clockCenterY, x1+clockCenterX, y1+clockCenterY);
}

void printDate()
{
  Time t_temp;

  t_temp = rtc.getTime();
  myGLCD.setFont(BigFont);
  myGLCD.setColor(0, 0, 0);
  myGLCD.setBackColor(255, 255, 255);
  myGLCD.print(rtc.getDOWStr(FORMAT_SHORT), 256, 8);
  if (t_temp.date<10)
    myGLCD.printNumI(t_temp.date, 272, 28);
  else
    myGLCD.printNumI(t_temp.date, 264, 28);
  myGLCD.print(rtc.getMonthStr(FORMAT_SHORT), 256, 48);
  myGLCD.printNumI(t_temp.year, 248, 65);
}

void clearDate()
{
  myGLCD.setColor(255, 255, 255);
  myGLCD.fillRect(248, 8, 312, 81);
}

void waitForTouchRelease()
{
  // Wait for release
  while (myTouch.dataAvailable()==true)
    myTouch.read();
}

void drawUpButton(int x, int y)
{
  myGLCD.setColor(64, 64, 128);
  myGLCD.fillRoundRect(x, y, x+32, y+25);
  myGLCD.setColor(255, 255, 255);
  myGLCD.drawRoundRect(x, y, x+32, y+25);
  myGLCD.setColor(128, 128, 255);
  for (int i=0; i<15; i++)
    myGLCD.drawLine(x+6+(i/1.5), y+20-i, x+27-(i/1.5), y+20-i);
}

void drawDownButton(int x, int y)
{
  myGLCD.setColor(64, 64, 128);
  myGLCD.fillRoundRect(x, y, x+32, y+25);
  myGLCD.setColor(255, 255, 255);
  myGLCD.drawRoundRect(x, y, x+32, y+25);
  myGLCD.setColor(128, 128, 255);
  for (int i=0; i<15; i++)
    myGLCD.drawLine(x+6+(i/1.5), y+5+i, x+27-(i/1.5), y+5+i);
}

void buttonWait(int x, int y)
{
  myGLCD.setColor(255, 0, 0);
  myGLCD.drawRoundRect(x, y, x+32, y+25);
  waitForTouchRelease();
  myGLCD.setColor(255, 255, 255);
  myGLCD.drawRoundRect(x, y, x+32, y+25);
}

byte calcDOW(byte d, byte m, int y)
{
  int dow;
  byte mArr[12] = {6,2,2,5,0,3,5,1,4,6,2,4};

  dow = (y % 100);
  dow = dow*1.25;
  dow += d;
  dow += mArr[m-1];
  if (((y % 4)==0) && (m<3))
    dow -= 1;
  while (dow>7)
    dow -= 7;

  return dow;
}

void showDOW(byte dow)
{
  char* str[] = {"MON","TUE","WED","THU","FRI","SAT","SUN"};

  myGLCD.setColor(128, 128, 255);
  myGLCD.setBackColor(0, 0, 0);
  myGLCD.print(str[dow-1], 26, 167);
}

byte validateDate(byte d, byte m, word y)
{
  byte mArr[12] = {31,0,31,30,31,30,31,31,30,31,30,31};
  byte od;

  if (m==2)
  {
    if ((y % 4)==0)
    {
      if (d==30)
        od=1;
      else if (d==0)
        od=29;
      else
        od=d;
    }
    else
    {
      if (d==29)
        od=1;
      else if (d==0)
        od=28;
      else
        od=d;
    }
  }
  else
  {
    if (d==0)
      od=mArr[m-1];
    else if (d==(mArr[m-1]+1))
      od=1;
    else
      od=d;
  }

  return od;
}

byte validateDateForMonth(byte d, byte m, word y)
{
  byte mArr[12] = {31,0,31,30,31,30,31,31,30,31,30,31};
  byte od;
  boolean dc=false;

  if (m==2)
  {
    if ((y % 4)==0)
    {
      if (d>29)
      {
        d=29;
        dc=true;
      }
    }
    else
    {  
      if (d>28)
      {
        d=28;
        dc=true;
      }
    }
  }
  else
  {
    if (d>mArr[m-1])
    {
      d=mArr[m-1];
      dc=true;
    }
  }

  if (dc)
  {
    if (d<10)
    {
      myGLCD.printNumI(0, 122, 140);
      myGLCD.printNumI(d, 138, 140);
    }
    else
    {
      myGLCD.printNumI(d, 122, 140);
    }
  }

  return d;
}

void setClock()
{
  Time t_temp;
  int x, y;
  int res = 0;
  boolean ct=false;
  boolean cd=false;

  waitForTouchRelease();    

  myGLCD.clrScr();
  myGLCD.setFont(BigFont);

  // Draw Save button
  myGLCD.setColor(64, 64, 128);
  myGLCD.fillRoundRect(165, 200, 319, 239);
  myGLCD.setColor(255, 255, 255);
  myGLCD.drawRoundRect(165, 200, 319, 239);
  myGLCD.setBackColor(64, 64, 128);
  myGLCD.print("Save", 210, 212);
  myGLCD.setBackColor(0, 0, 0);
  // Draw Cancel button
  myGLCD.setColor(64, 64, 128);
  myGLCD.fillRoundRect(0, 200, 154, 239);
  myGLCD.setColor(255, 255, 255);
  myGLCD.drawRoundRect(0, 200, 154, 239);
  myGLCD.setBackColor(64, 64, 128);
  myGLCD.print("Cancel", 29, 212);
  myGLCD.setBackColor(0, 0, 0);

  // Draw frames
  myGLCD.setColor(0, 0, 255);
  myGLCD.drawRoundRect(0, 0, 319, 96);
  myGLCD.drawRoundRect(0, 100, 319, 196);
  myGLCD.print("Time:", 10, 40);
  myGLCD.print(":", 154, 40);
  myGLCD.print(":", 202, 40);
  myGLCD.print("Date:", 10, 140);
  myGLCD.print(".", 154, 140);
  myGLCD.print(".", 202, 140);

  // Draw Buttons
  drawUpButton(122, 10);
  drawUpButton(170, 10);
  drawUpButton(218, 10);
  drawDownButton(122, 61);
  drawDownButton(170, 61);
  drawDownButton(218, 61);
  drawUpButton(122, 110);
  drawUpButton(170, 110);
  drawUpButton(234, 110);
  drawDownButton(122, 161);
  drawDownButton(170, 161);
  drawDownButton(234, 161);

  // Print current time and date
  myGLCD.setColor(255, 255, 255);
  t_temp = rtc.getTime();
  if (t_temp.date==0)
  {
    t_temp.date=1;
    t_temp.mon=1;
    t_temp.year=2010;
    t_temp.dow=5;
    t_temp.hour=0;
    t_temp.min=0;
    t_temp.sec=0;
    ct=true;
    cd=true;
  }

  if (t_temp.hour<10)
  {
    myGLCD.printNumI(0, 122, 40);
    myGLCD.printNumI(t_temp.hour, 138, 40);
  }
  else
  {
    myGLCD.printNumI(t_temp.hour, 122, 40);
  }
  if (t_temp.min<10)
  {
    myGLCD.printNumI(0, 170, 40);
    myGLCD.printNumI(t_temp.min, 186, 40);
  }
  else
  {
    myGLCD.printNumI(t_temp.min, 170, 40);
  }
  if (t_temp.sec<10)
  {
    myGLCD.printNumI(0, 218, 40);
    myGLCD.printNumI(t_temp.sec, 234, 40);
  }
  else
  {
    myGLCD.printNumI(t_temp.sec, 218, 40);
  }
  if (t_temp.date<10)
  {
    myGLCD.printNumI(0, 122, 140);
    myGLCD.printNumI(t_temp.date, 138, 140);
  }
  else
  {
    myGLCD.printNumI(t_temp.date, 122, 140);
  }
  if (t_temp.mon<10)
  {
    myGLCD.printNumI(0, 170, 140);
    myGLCD.printNumI(t_temp.mon, 186, 140);
  }
  else
  {
    myGLCD.printNumI(t_temp.mon, 170, 140);
  }
  myGLCD.printNumI(t_temp.year, 218, 140);
  showDOW(t_temp.dow);

  while (res==0)
  {
    if (myTouch.dataAvailable())
    {
      myTouch.read();
      x=myTouch.getX();
      y=myTouch.getY();
      if ((y>=10) && (y<=35)) // Buttons: Time UP
      {
        if ((x>=122) && (x<=154))
        {
          buttonWait(122, 10);
          t_temp.hour+=1;
          if (t_temp.hour==24)
            t_temp.hour=0;
          if (t_temp.hour<10)
          {
            myGLCD.printNumI(0, 122, 40);
            myGLCD.printNumI(t_temp.hour, 138, 40);
          }
          else
          {
            myGLCD.printNumI(t_temp.hour, 122, 40);
          }
          if (ct==false)
          {
            ct=true;
            myGLCD.setColor(64, 64, 128);
            myGLCD.setFont(SmallFont);
            myGLCD.print("Changed!", 10, 10);
            myGLCD.setColor(255, 255, 255);
            myGLCD.setFont(BigFont);
          }
        }
        else if ((x>=170) && (x<=202))
        {
          buttonWait(170, 10);
          t_temp.min+=1;
          if (t_temp.min==60)
            t_temp.min=0;
          if (t_temp.min<10)
          {
            myGLCD.printNumI(0, 170, 40);
            myGLCD.printNumI(t_temp.min, 186, 40);
          }
          else
          {
            myGLCD.printNumI(t_temp.min, 170, 40);
          }
          if (ct==false)
          {
            ct=true;
            myGLCD.setColor(64, 64, 128);
            myGLCD.setFont(SmallFont);
            myGLCD.print("Changed!", 10, 10);
            myGLCD.setColor(255, 255, 255);
            myGLCD.setFont(BigFont);
          }
        }
        else if ((x>=218) && (x<=250))
        {
          buttonWait(218, 10);
          t_temp.sec+=1;
          if (t_temp.sec==60)
            t_temp.sec=0;
          if (t_temp.sec<10)
          {
            myGLCD.printNumI(0, 218, 40);
            myGLCD.printNumI(t_temp.sec, 234, 40);
          }
          else
          {
            myGLCD.printNumI(t_temp.sec, 218, 40);
          }
          if (ct==false)
          {
            ct=true;
            myGLCD.setColor(64, 64, 128);
            myGLCD.setFont(SmallFont);
            myGLCD.print("Changed!", 10, 10);
            myGLCD.setColor(255, 255, 255);
            myGLCD.setFont(BigFont);
          }
        }
      }
      else if ((y>=61) && (y<=86)) // Buttons: Time DOWN
      {
        if ((x>=122) && (x<=154))
        {
          buttonWait(122, 61);
          t_temp.hour-=1;
          if (t_temp.hour==255)
            t_temp.hour=23;
          if (t_temp.hour<10)
          {
            myGLCD.printNumI(0, 122, 40);
            myGLCD.printNumI(t_temp.hour, 138, 40);
          }
          else
          {
            myGLCD.printNumI(t_temp.hour, 122, 40);
          }
          if (ct==false)
          {
            ct=true;
            myGLCD.setColor(64, 64, 128);
            myGLCD.setFont(SmallFont);
            myGLCD.print("Changed!", 10, 10);
            myGLCD.setColor(255, 255, 255);
            myGLCD.setFont(BigFont);
          }
        }
        else if ((x>=170) && (x<=202))
        {
          buttonWait(170, 61);
          t_temp.min-=1;
          if (t_temp.min==255)
            t_temp.min=59;
          if (t_temp.min<10)
          {
            myGLCD.printNumI(0, 170, 40);
            myGLCD.printNumI(t_temp.min, 186, 40);
          }
          else
          {
            myGLCD.printNumI(t_temp.min, 170, 40);
          }
          if (ct==false)
          {
            ct=true;
            myGLCD.setColor(64, 64, 128);
            myGLCD.setFont(SmallFont);
            myGLCD.print("Changed!", 10, 10);
            myGLCD.setColor(255, 255, 255);
            myGLCD.setFont(BigFont);
          }
        }
        else if ((x>=218) && (x<=250))
        {
          buttonWait(218, 61);
          t_temp.sec-=1;
          if (t_temp.sec==255)
            t_temp.sec=59;
          if (t_temp.sec<10)
          {
            myGLCD.printNumI(0, 218, 40);
            myGLCD.printNumI(t_temp.sec, 234, 40);
          }
          else
          {
            myGLCD.printNumI(t_temp.sec, 218, 40);
          }
          if (ct==false)
          {
            ct=true;
            myGLCD.setColor(64, 64, 128);
            myGLCD.setFont(SmallFont);
            myGLCD.print("Changed!", 10, 10);
            myGLCD.setColor(255, 255, 255);
            myGLCD.setFont(BigFont);
          }
        }
      }
      if ((y>=110) && (y<=135)) // Buttons: Date UP
      {
        if ((x>=122) && (x<=154))
        {
          buttonWait(122, 110);
          t_temp.date+=1;
          t_temp.date=validateDate(t_temp.date, t_temp.mon, t_temp.year);
          if (t_temp.date<10)
          {
            myGLCD.printNumI(0, 122, 140);
            myGLCD.printNumI(t_temp.date, 138, 140);
          }
          else
          {
            myGLCD.printNumI(t_temp.date, 122, 140);
          }
          if (cd==false)
          {
            cd=true;
            myGLCD.setColor(64, 64, 128);
            myGLCD.setFont(SmallFont);
            myGLCD.print("Changed!", 10, 110);
            myGLCD.setColor(255, 255, 255);
            myGLCD.setFont(BigFont);
          }
        }
        else if ((x>=170) && (x<=202))
        {
          buttonWait(170, 110);
          t_temp.mon+=1;
          if (t_temp.mon==13)
            t_temp.mon=1;
          if (t_temp.mon<10)
          {
            myGLCD.printNumI(0, 170, 140);
            myGLCD.printNumI(t_temp.mon, 186, 140);
          }
          else
          {
            myGLCD.printNumI(t_temp.mon, 170, 140);
          }
          t_temp.date=validateDateForMonth(t_temp.date, t_temp.mon, t_temp.year);
          if (cd==false)
          {
            cd=true;
            myGLCD.setColor(64, 64, 128);
            myGLCD.setFont(SmallFont);
            myGLCD.print("Changed!", 10, 110);
            myGLCD.setColor(255, 255, 255);
            myGLCD.setFont(BigFont);
          }
        }
        else if ((x>=218) && (x<=250))
        {
          buttonWait(234, 110);
          t_temp.year+=1;
          if (t_temp.year==2100)
            t_temp.year=2000;
          myGLCD.printNumI(t_temp.year, 218, 140);
          t_temp.date=validateDateForMonth(t_temp.date, t_temp.mon, t_temp.year);
          if (cd==false)
          {
            cd=true;
            myGLCD.setColor(64, 64, 128);
            myGLCD.setFont(SmallFont);
            myGLCD.print("Changed!", 10, 110);
            myGLCD.setColor(255, 255, 255);
            myGLCD.setFont(BigFont);
          }
        }
        t_temp.dow=calcDOW(t_temp.date, t_temp.mon, t_temp.year);
        showDOW(t_temp.dow);
      }
      else if ((y>=161) && (y<=186)) // Buttons: Date DOWN
      {
        if ((x>=122) && (x<=154))
        {
          buttonWait(122, 161);
          t_temp.date-=1;
          t_temp.date=validateDate(t_temp.date, t_temp.mon, t_temp.year);
          if (t_temp.date<10)
          {
            myGLCD.printNumI(0, 122, 140);
            myGLCD.printNumI(t_temp.date, 138, 140);
          }
          else
          {
            myGLCD.printNumI(t_temp.date, 122, 140);
          }
          if (cd==false)
          {
            cd=true;
            myGLCD.setColor(64, 64, 128);
            myGLCD.setFont(SmallFont);
            myGLCD.print("Changed!", 10, 110);
            myGLCD.setColor(255, 255, 255);
            myGLCD.setFont(BigFont);
          }
        }
        else if ((x>=170) && (x<=202))
        {
          buttonWait(170, 161);
          t_temp.mon-=1;
          if (t_temp.mon==0)
            t_temp.mon=12;
          if (t_temp.mon<10)
          {
            myGLCD.printNumI(0, 170, 140);
            myGLCD.printNumI(t_temp.mon, 186, 140);
          }
          else
          {
            myGLCD.printNumI(t_temp.mon, 170, 140);
          }
          t_temp.date=validateDateForMonth(t_temp.date, t_temp.mon, t_temp.year);
          if (cd==false)
          {
            cd=true;
            myGLCD.setColor(64, 64, 128);
            myGLCD.setFont(SmallFont);
            myGLCD.print("Changed!", 10, 110);
            myGLCD.setColor(255, 255, 255);
            myGLCD.setFont(BigFont);
          }
        }
        else if ((x>=218) && (x<=250))
        {
          buttonWait(234, 161);
          t_temp.year-=1;
          if (t_temp.year==1999)
            t_temp.year=2099;
          myGLCD.printNumI(t_temp.year, 218, 140);
          t_temp.date=validateDateForMonth(t_temp.date, t_temp.mon, t_temp.year);
          if (cd==false)
          {
            cd=true;
            myGLCD.setColor(64, 64, 128);
            myGLCD.setFont(SmallFont);
            myGLCD.print("Changed!", 10, 110);
            myGLCD.setColor(255, 255, 255);
            myGLCD.setFont(BigFont);
          }
        }
        t_temp.dow=calcDOW(t_temp.date, t_temp.mon, t_temp.year);
        showDOW(t_temp.dow);
      }
      else if ((y>=200) && (y<=239)) // Buttons: CANCEL / SAVE
      {
        if ((x>=165) && (x<=319))
        {
          res=1;
          myGLCD.setColor (255, 0, 0);
          myGLCD.drawRoundRect(165, 200, 319, 239);
        }
        else if ((x>=0) && (x<=154))
        {
          res=2;
          myGLCD.setColor (255, 0, 0);
          myGLCD.drawRoundRect(0, 200, 154, 239);
        }
      }
    }
  }

  waitForTouchRelease();

  if (res==1)
  {
    if (ct)
      rtc.setTime(t_temp.hour, t_temp.min, t_temp.sec);
    if (cd)
    {
      rtc.setDate(t_temp.date, t_temp.mon, t_temp.year);
      rtc.setDOW(t_temp.dow);
    }
  }

  drawDisplay();
  printDate();
}

void loop()
{
  int x, y;

  t = rtc.getTime();
  if (t.date==0)
  {
    setClock();
  }
  else
  {
    drawDisplay();
    printDate();
  }

  t = rtc.getTime();

  while (true)
  {
    if (oldsec!=t.sec)
    {
      if ((t.sec==0) and (t.min==0) and (t.hour==0))
      {
        clearDate();
        printDate();
      }
      if (t.sec==0)
      {
        drawMin(t.min);
        drawHour(t.hour, t.min);
      }
      drawSec(t.sec);
      oldsec=t.sec;
    }

    if (myTouch.dataAvailable())
    {
      myTouch.read();
      x=myTouch.getX();
      y=myTouch.getY();
      if (((y>=200) && (y<=239)) && ((x>=260) && (x<=319)))
      {
        myGLCD.setColor (255, 0, 0);
        myGLCD.drawRoundRect(260, 200, 319, 239);
        setClock();
      }
    }

    delay(10);
    t = rtc.getTime();
  }
}



Fonte: http://henningkarlsen.com/electronic...alog_clock.php

Comprei este tft http://iteadstudio.com/store/index.p...roducts_id=263 que boa parte dos colegas de fórum têm.
Já te adianto que vai precisar deste shield http://www.reefforum.net/showthread....l=1#post188318 fale com o Baltasar.
Penso que a princípio não vou utilizar o tft pois, sou analfabeto quando se trata de programação.

Abraço.
Fernando Garcia

----------


## Sérgio Paulo

Olá novamente Fernando, e mais uma vez obrigado pela colaboração e ajuda.

Eu como não estou em casa (estou em casa de uns Amigos) não vou poder estar aqui muito mais tempo, mas lá para quarta feira, venho novamente cá e depois vejo melhor tudo o que me indicaste.

Mais uma vez obrigado e aproveito para desejar um bom e feliz final de semana a todos.
Abraço,
Sérgio.

----------


## Sérgio Paulo

Só para poder actualizar, o hardware está adquirido e assim que chegar e testar o mesmo certamente que virei cá solicitar ajuda aos prós na programação.

O material foi este:

http://cgi.ebay.de/ws/eBayISAPI.dll?ViewItem&item=250819736149 
 http://cgi.ebay.de/ws/eBayISAPI.dll?...m=250839068438
http://cgi.ebay.de/ws/eBayISAPI.dll?...m=250884446263
http://cgi.ebay.de/ws/eBayISAPI.dll?...m=250917312157
http://cgi.ebay.de/ws/eBayISAPI.dll?...m=260802253338
http://cgi.ebay.de/ws/eBayISAPI.dll?ViewItem&item=260835352650

Abraço,
Sérgio.

----------


## Baltasar Parreira

Boas, Sérgio tens ai uma coisa a mais e outra que não te vai servir para nada. Compras-te um RTC quando o shield para ligar o LCD já o trás, depois esse screw shield para alem de não ser o original que daria para encaixar outros shields por cima pois esse não dá, essa versão só funciona no Arduino normal (2009, Uno, etc.). 

O mega tem muitos mais pinos que esse screw shield como deves ter reparado só por olhar para as fotos, logo a não ser que queiras essas placas que mencionei para outro projecto qualquer não irás conseguir usar-las com o Mega e LCD que apresentas nos links.

----------


## Fernando Garcia

Olá!
Ainda bem que o prejuizo não é tão grande.
Para este LCD você vai precisar deste shield http://www.reefforum.net/showthread....l=1#post188318 conforme eu havia falado anteriormente.
Converse com o Baltasar sobre os preços.
Abraço.
Fernando Garcia

----------


## Sérgio Paulo

Obrigado Baltasar Parreira e Fernando Garcia,

Bem tendo em conta que já comecei a "meter a pata na poça", lá se foram 16,80 que vão ficar parados.  :yb620: 
Caso alguém necessite do material que não me vai servir, já sabe, é só enviar PM e acerta-se as coisas.

Entretanto já enviei PM ao Baltazar.

Obrigado a ambos,
Sérgio.

----------


## Sérgio Paulo

Agora venho, além de agradecer ao Baltasar por dispensar a screw shield para o MEGA (*obrigado Baltasar*), venho também questionar-vos se não é benéfico ter uma fonte deste género a alimentar o Arduino, pois além de poder fornecer os 12V DC para o MEGA, pode ao mesmo tempo fornecer os 5V DC para a placa de relés.

*Imagem:* 281-3.jpg

*CARACTERISTÍCAS:*
Input Voltage: DC10-14V10A
input Voltage: AC110V-240V to Out dc 12v-24v
Output DC Voltage: 12v 16v 18v 19v 20v 22v 24v (adjustable)
Output DC current: 12v-20v:5A ,22V-24V :4A
8 pcs different standard connectors
with USB CHARGING PORT/DC 5V
(CNA CHARGE LAPTOP COMPUTER AND MOBILE PHONE AT THE SAME TIME)

*DESCRIÇÃO GERAL*
This model is a swithching mode power supply, operation at input AC voltage 95v to 265v
And output DC voltage of 12v-20v /4.5A max 22-24v/4 A max, with many protections, use for the notebook computer power supply.

(como é óbvio, neste modelo por segurança o botão selector de 12V deverá ser colado ou, o "rasgo" após estar nos 12V ser bloqueado para que acidentalmente não se seleccione outra voltagem) 

Ou então este modelo:

*Imagem:* power-9.jpg

*CARACTERISTÍCAS:*
AC input 	100v~240v / 50~60hz
Output : 	5V DC, 2.5A + 12V DC, 2.5A 

Acham que é de todo benéfico (separar o consumo dos 5V e 12V) para não sub-carregar o regulador do arduino?

----------


## Baltasar Parreira

Sérgio, tens varias hipóteses, mas penso que a mais indicada e simples em virtude de todos os circuitos a volta do Arduino e ele em si trabalham a 5V DC, logo para mim o melhor é teres uma boa fonte estável no mínimo com 1A a 2A consoante a quantidade de circuitos que vais alimentar logo o que irá puxar por ela. 
Assim ligas estes 5V no input do Mega screw shield e dai se tiveres outros circuitos externos vais retirando os mesmos 5V para eles.

É certo que o Arduino seja que modelo for tem um regulador integrado internamente e usando  no pino VIN podes colocar qualquer voltagem de 7V a 12V, mas o mesmo vai aquecer um pouco e não suporta depois tanta amperagem a passar por ele se tiveres muitos outros circuitos a puxar dai.

Se queres usar as fonte de 12V por que vais ter outros circuitos a usarem essa voltagem, então faz com um bom regulador integrado um circuito a parte para dos 12V teres 5V a injectar novamente no Mega shield. Penso que encontras boards até já feitas só para isto bastante baratas.

----------


## Fernando Garcia

Transformei uma fonte atx de pc numa fonte de bancada como o Baltasar sugeriu neste post http://www.reefforum.net/showthread....l=1#post185010.
Utilzei esta  explicação como base http://www.temadigital.com.br/doku.p...nte_de_bancada

A minha fonte não tinha chave de liga/desliga então comprei um botão e liguei no fio verde e num preto.
Aproveito a oportunidade para perguntar se é necessário limitar a corrente que chega ao arduino visto que a fonte fornece cerca de 9 A.

Seguem duas fotos de como ficou minha fonte.





O primeiro e o último parafuso são de fixação.
Abraço.
Fernando Garcia

----------


## Baltasar Parreira

Pois é excelente essa ideia eheheh... e não precisas de limitar nada, ela só fornece o que os circuitos no total consumirem e como essas fontes tem realmente muita amperagem estas mais que safo.

----------


## Fernando Garcia

> Pois é excelente essa ideia eheheh... e não precisas de limitar nada, ela só fornece o que os circuitos no total consumirem e como essas fontes tem realmente muita amperagem estas mais que safo.


Baltasar, obrigado pela resposta.
Abraço.
Fernando Garcia

----------


## Sérgio Paulo

Obrigado *Baltasar* e *Fernando Garcia* pelas dicas, mas acabei por encontrar aqui em casa uma fonte estabilizada com isolamento galvânico de 5V.  :SbSourire2: 

Agora gostava da vossa opinião no seguinte:

Eu sei que o DS18B20 é 1-wire e assim libertamos inputs na board, mas como estou folgado a nível de inputs, o que me dizem de utilizar o LM35?

Entretanto deixo já aqui um esboço, de como estou a organizar a montagem e, caso encontrem algo mal, estejam à vontade para comentarem.

DFRobot MEGA 2560_3.jpg

----------


## bebiano_tiago

Interessante o teu projecto! 

Da minha parte posso oferecer ajuda na programação. É a minha área e apesar de nunca ter programado concretamente para um Arduino já programei para muitas outras coisas.


Qualquer coisa avisa. Se não precisares, fica a intenção.


Cumprimentos e boa sorte!

----------


## Baltasar Parreira

Boas o problema é que o LM35 funciona por voltagem, ou seja vais ter de andar a fazer leituras que voltagem tens no pino do Arduino, depois fazer cálculos para teres o valor da temperatura isto não falando da calibração inicial que é preciso.
Alem que tens de usar variáveis float que gastam muita memoria e não são precisas em microcontroladores como estes logo podem originar valores errados mesmo arredondando, etc. As contas com float no ATMEL falham muito mesmo, esta documentado mesmo !!!

Terias de fazer algo assim (exemplo para mandar os valores de x em x segundos para o serial do PC):

//declare variables
float tempC;
int tempPin = 0;
void setup()
{
Serial.begin(9600); //opens serial port, sets data rate to 9600 bps
}
void loop()
{
tempC = analogRead(tempPin);           //read the value from the sensor
tempC = (5.0 * tempC * 100.0)/1024.0;  //convert the analog data to temperature
Serial.print((byte)tempC);             //send the data to the computer
delay(1000);                           //wait one second before sending new data
}

O DS18B20, manda-te já tudo em digital, o valor que leres no serial é a temperatura medida sem contas e etc. e podes comunicar com ele por comandos para recalibrar e muitas outras coisas, para alem da vantagem que já falaste que no mesmo barramento podes por N a ler temperaturas em locais diferente e usares sempre os mesmo pinos do Arduino sem gastar outros.

----------


## Sérgio Paulo

> Interessante o teu projecto! 
> 
> Da minha parte posso oferecer ajuda na programação. É a minha área e apesar de nunca ter programado concretamente para um Arduino já programei para muitas outras coisas.
> 
> 
> Qualquer coisa avisa. Se não precisares, fica a intenção.
> 
> 
> Cumprimentos e boa sorte!


Obrigado *bebiano_tiago*, certamente que irei necessitar.

Depois digo algo.
Obrigado,
Sérgio.




> Boas o problema é que o LM35 funciona por voltagem, ou seja vais ter de andar a fazer leituras que voltagem tens no pino do Arduino, depois fazer cálculos para teres o valor da temperatura isto não falando da calibração inicial que é preciso.
> Alem que tens de usar variáveis float que gastam muita memoria e não são precisas em microcontroladores como estes logo podem originar valores errados mesmo arredondando, etc. As contas com float no ATMEL falham muito mesmo, esta documentado mesmo !!!
> 
> Terias de fazer algo assim (exemplo para mandar os valores de x em x segundos para o serial do PC):
> 
> //declare variables
> float tempC;
> int tempPin = 0;
> void setup()
> ...


Estou convencido *Baltasar*, vou optar pelo DS, sem qualquer sombra de duvidas.

Obrigado,
Sérgio.

----------


## Sérgio Paulo

Tal como indicado pelo Baltasar, já vêm a caminho as ditas sondas.

Link: DS18B20

*Obrigado mais uma vez Baltasar*.

----------


## Hugo Figueiredo

Para quem estiver interessado: http://www.reefforum.net/showthread....652#post189652

----------


## Sérgio Paulo

> Para quem estiver interessado: http://www.reefforum.net/showthread....652#post189652


Olá Hugo, sou capaz de vir a necessitar, mas primeiro tenho de meter o meu arduino a mexer e a fazer o que tenho em mente. :JmdRienVoir:

----------


## JoaoCAlves

A tecnologia 1-wire é sem duvida uma grande vantagem, pode-se ter vários sensores no mesmo pino do arduino. Além que simplifica um pouco as ligações. Tb penso comprar sondas dessas. Força nisso.  :Wink:

----------


## Sérgio Paulo

*JoaoCAlves*, tentei enviar-te PM mas tens a cx cheia.

Se te for possível eu gostaria de te enviar uma PM para te cravar.  :Coradoeolhos:

----------


## JoaoCAlves

Pois, limpei à pouco, não sei o que se passa, mas não recebi aviso... Acho que ainda não me habituei bem ao novo forum!  :Big Grin: 

Chuta! :P

----------


## Sérgio Paulo

> Pois, limpei à pouco, não sei o que se passa, mas não recebi aviso... Acho que ainda não me habituei bem ao novo forum! 
> 
> Chuta! :P


Já te enviei a PM.

----------


## Sérgio Paulo

Ora bem camaradas,

Depois de andar a "vasculhar" por aqui e por ali, deixo-vos mais um esquema que poderá ser útil:

----------


## Sérgio Paulo

Dúvida como ligar correctamente o sensor de temperatura DS18B20 ao Mega 2560?


_Será desta forma:_



_Desta:_



_Ou desta?_

----------


## Baltasar Parreira

A ultima funciona bem é a que já testei e uso para alem que poupas um fio logo só precisas de um par até aos sensores.

Não esqueças que no inicio tens de ligar somente um sensor de cada vez e correr o código para sacar o seu endereço pois cada sensor tem um endereço único mesmo e nunca se repetem, depois com esse código podes ler os dados de ou outro consoante passas esse endereço.

----------


## Sérgio Paulo

Ok Baltasar, obrigado.

 :SbOk:

----------


## carlos pacheco

Bom dia. 

Tenho seguido o tópico com muita atenção hehe, visto que ando mais ou menos no mesmo barco. 

Esses esquemas estão porreiros Sérgio Paulo  :SbOk: 

Tenho uma duvida no esquema do sensor hehe neste caso no ultimo esquema  :HaEbouriffe: 

O que e o AK7??  :Whistle:  :SbLangue6: 

Isto quando um gajo e leigo na matéria :yb624: 

cumps

----------


## Sérgio Paulo

Olá Carlos Pacheco,

Não é AK7, é sim a designação para uma resistência de 4,7K.

----------


## carlos pacheco

> Olá Carlos Pacheco,
> 
> Não é AK7, é sim a designação para uma resistência de 4,7K.


hehe esta explicado hehe 

Ando a pensar meter um sensor para as ventoinhas da calha e esse esquema caiu do céu. :SbOk:

----------


## Sérgio Paulo

Ok Carlos,

E caso queiras fazer o controlo com FANs PWM, tens *destas* ou no caso de quereres que funcionem sem controlador tens *destas*.  :SbOk:

----------


## carlos pacheco

> hehe esta explicado hehe 
> 
> Ando a pensar meter um sensor para as ventoinhas da calha e esse esquema caiu do céu.


Obrigada Sérgio.
No meu caso com já tenho a calha feita, vai ter que ser com as Fans de Pc 60x60 que neste caso já estão montadas.

----------


## Sérgio Paulo

Ok Carlos, era só uma ideia.

 :SbOk5:

----------


## carlos pacheco

> Ok Carlos, era só uma ideia.


E na boa Sérgio, todas as dicas são bem vindas. 
Neste caso não serve muito bem para mim, mas pode servir para outra pessoa que leia o tópico hehe

cumps

----------


## Fernando Garcia

Sérgio, boa tarde!
Fiz uma modificação no código do controle de velocidade das ventoinhas e consegui economizar 2 pinos do arduino, sei que por hora você tem muitos pinos sobrando mas, talvez no futuro vai precisar de mais alguns.
Aqui esta um desenho de como fiz a  ligação.

 

Utilizei uma ventoinha comum de pc 80x80 ela consome 140mA e o ULN2003A pode fornecer até 500 mA.
No teste que fiz percebi que este minha ventoinha precisa de no mínimo 30mA para começar ou seja ela só começou a girar à partir dos 33°C e não dos 30°C como consta no código. 
Este impecilho pode ser superado usando uma ventoinha com PWM como a que você postou anteriormente e também dispensará o uso do ULN2003A.   

Aqui está o código original:

  int tempval = int(tempH*10);
  int fanSpeed = map(tempval, (HtempMin*10), (HtempMax*10), 170, 255);      
  if (fanSpeed<=0) 
     fanSpeed = 0;
  if (fanSpeed>255)
     fanSpeed=255;
  if (fanSpeed>=190)
     digitalWrite(fanTranzPin, HIGH);
  if (fanSpeed<=171)
     digitalWrite(fanTranzPin, LOW);
  analogWrite(fan1PWMpin, fanSpeed);
  analogWrite(fan2PWMpin, fanSpeed);

E este é o código alterado:

int tempval = int(tempH*10);
  int fanSpeed = map(tempval, (HtempMin*10), (HtempMax*10), 0, 255);      
  if (fanSpeed<=0)                                                        
     fanSpeed = 0;                                                          
  if (fanSpeed>255)
     fanSpeed=255;
  analogWrite(fan1PWMpin, fanSpeed);

Caso você queira ligar 2 ventoinhas poderá "jumpear" as entradas 1 e 2 do ULN2003A ao pino PWM e ligar o negativo da segunda ventoinha na saída 15 do ULN2003A.

Abraço.
Fernando Garcia

----------


## Sérgio Paulo

Obrigado Fernando Garcia, mas eu vou utilizar (ainda não está acabado) as que já têm controlo PWM.

São estas:



Mas é interessante, e assim para quem não queira comprar já com PWM sempre pode utilizar as normais.

 :SbOk:

----------


## Nuno Prazeres

> Obrigado *Baltasar* e *Fernando Garcia* pelas dicas, mas acabei por encontrar aqui em casa uma fonte estabilizada com isolamento galvânico de 5V. 
> 
> Agora gostava da vossa opinião no seguinte:
> 
> Eu sei que o DS18B20 é 1-wire e assim libertamos inputs na board, mas como estou folgado a nível de inputs, o que me dizem de utilizar o LM35?
> 
> Entretanto deixo já aqui um esboço, de como estou a organizar a montagem e, caso encontrem algo mal, estejam à vontade para comentarem.
> 
> Anexo 14219


Boas

Estava a ver este esquema que está com muito bom aspeto mas, atendendo à minha experiência pessoal sugeria duas coisas no circuito das boias:

1 - usar pins digitais correntes por exemplo o 39 e 41 nas boias já que estás a "gastar" uns que, além de serem de pwm, normalmente até são requeridos por muitos shields, nomeadamente de LCD.

2 - em vez de usares as boias a fazer switch de LOW para HIGH fazer ao contrário.

Esclareço melhor o ponto 2.

Ao ligares duas resistências entre os pins delas e a massa estás a fazer o que tecnicamente se chama pull-down. Boia desligada dá LOW no respetivo pin.

Ora podes fazer com que boia desligada dê HIGH usando apenas software e poupando o trabalho de usar as resistências.
Com a boia ligada, passa o estado a LOW. Continuas a poder controlar a reposição, apenas terás que ter o código ajustado.
Chama-se a isso fazer um pull-up ao pino.

No circuito, as saídas das boias que tens ligadas aos 5V, passas a ligar à massa.

Apenas tens que no código, mais concretamente no setup(), fazer algo como isto (para as duas boias)

pinMode(PinodaBoia, INPUT);
digitalWrite(PinodaBoia, HIGH);

Parece estranho fazer um write num pin de INPUT mas é assim que se liga a resistência interna de pull-up que cada pino tem disponível.

Não sei se ajuda. Se calhar já está bem adiantado fece a este tema...

----------


## JoaoCAlves

> Obrigado Fernando Garcia, mas eu vou utilizar (ainda não está acabado) as que já têm controlo PWM.
> 
> São estas:
> 
> 
> 
> Mas é interessante, e assim para quem não queira comprar já com PWM sempre pode utilizar as normais.


Boas Sérgio.

Ando tb à procura de ventoinhas para uma pequena calha que estou a fazer e tb tava a pensar nesse modelo, mas a de 92mm.

Agora só uma questão, tens a certeza que controlas o pwm dessa fan com o arduino?

É que pelo que andei a "rabiscar", o pwm delas é suposto trabalhar a 25KHz, e o arduibo, trabalha a 500Hz!!

Já testas-te a ver se dá?

Eu testei aqui com a pequenina dos coolers de cpu, mas do mesmo modelo que essa, e não deu! Tb não inssisti mt, mas pareceu-me que não ia correr bem...

----------


## JoaoCAlves

Ok, esquece, devia estar a fazer alguma coisa mal, funcionou...  :Admirado: 

Usei os timers de default e deu, embora o comportamento seja estranho. O zero do pwm é o máximo. Depois sobe-se cerca de 10% do percurso do pwm e ela desce ao minimo. Depois daí para a frente, então sim vai aumentando gradualmente até ao máximo.

O que quer dizer que nunca se vai ter velocidade 0. MAs pelo menos, no minimo, não faz barulho nenhum.

A ver se descubvro do tachometro agora. É uma mariquice, ams fica giro!  :Big Grin:

----------

