Projecto FanController

[almamater]

Mas esse código que estás a usar, gera saídas para o display de 7 segmentos.
Tu estás a usá-los?

Sim gera,  queria usar os displays de 7 segmentos e o LCD ao mesmo tempo! Seria esse o objectivo

[microbyte]

Então posso perguntar para que é que queres pôr um delay no código?

[almamater]

Então posso perguntar para que é que queres pôr um delay no código?

Bom, se reparares o código do Ricardo tem um delay:

Código: [Seleccione]

#
// Obtemos 8 samples da temperatura
  for(i = 0; i<=7; i++){
  samples[i] = ( 5.0 * analogRead(sensorPin) * 100.0) / 1024.0;
  tempc = tempc + samples[i];
 --> delay(50);
  }
Dessa forma não funciona bem, pq o LCD recebe a info com bastante atraso..

Alterei essa parte por (interval=50):

Código: [Seleccione]

if(currentMillis - previousMillis > interval) {
         previousMillis = currentMillis;
       }
Desta forma os digitos dos Segmentos ficam assim meios estranhos nas passagens qdo o LCD está a receber info da porta serial.. mas secalhar tem mesmo de ser assim..  () (a partir do minuto 1:21 nota-se)

Possivelmente vou ter de usar apenas o LCD c/ o LcdSmartie à parte! Com 1 arduino só para isso

[microbyte]

Então posso perguntar para que é que queres pôr um delay no código?

Bom, se reparares o código do Ricardo tem um delay:

Código: [Seleccione]

#
// Obtemos 8 samples da temperatura
  for(i = 0; i<=7; i++){
  samples[i] = ( 5.0 * analogRead(sensorPin) * 100.0) / 1024.0;
  tempc = tempc + samples[i];
 --> delay(50);
  }
Dessa forma não funciona bem, pq o LCD recebe a info com bastante atraso..

Alterei essa parte por (interval=50):

Código: [Seleccione]

if(currentMillis - previousMillis > interval) {
         previousMillis = currentMillis;
       }
Desta forma os digitos dos Segmentos ficam assim meios estranhos nas passagens qdo o LCD está a receber info da porta serial.. mas secalhar tem mesmo de ser assim..  () (a partir do minuto 1:21 nota-se)

Possivelmente vou ter de usar apenas o LCD c/ o LcdSmartie à parte! Com 1 arduino só para isso

Lol, caso ainda não tenhas reparado, eu sou o Ricardo... 

Tu não precisas de outro Arduino coisa nenhuma...
Ao retirares o delay, ficas com o sensor demasiado reactivo. E como sabes, tudo o que é analógico tem ruído.

O que está a acontecer é que estás com oscilações na leitura, pois estás a fazê-la demasiado rápida.
A leitura pode ser feita como tu tens... Mas a passagem para os display's de 7 Seg não.

Só temos de garantir que só passas um valor novo para os display's de X em X tempo.
Não querendo desviar-te da ideia, proponho-te a seguinte solução... A substituição não chega, temos de fazer uns "tweaks" ao código.

Adicionamos estas variáveis:

Código: [Seleccione]

int nLeituras = 0;
int maxLeituras = 8;
int interval = 50;
E agora no loop metes assim:

Código: [Seleccione]

  if(currentMillis - previousMillis > interval) {
    previousMillis = currentMillis;
   
    nleituras++;
    samples[i] = ( 5.0 * analogRead(sensorPin) * 100.0) / 1024.0;
   
    // Se atingimos o maximo de leituras que queremos
    if(nLeituras == maxLeituras){
      nleituras = 0; // recomecamos no proximo ciclo
     
      // vamos calcular a media
      for(i = 0; i<=7; i++) tempc = tempc + samples[i];
      tempc = tempc/8.0; // Calcula-se a média
           
      // para mostrar nos displays de 7 segmentos...
     
      // Calcula-se o dígito da esquerda e da direita
      int num1 = 0;
      do{
        num1++;
        tempc = tempc - 10;
      }while(tempc >= 10);
      dataEsq = esq[num1];
      dataDir = dir[tempc];
     
      // Enquanto estivermos a transmitir, o pino "latch" tem de estar a LOW
      digitalWrite(latchPin, 0);
      // Enviar os bytes
      shiftOut(dataPin, clockPin, dataDir);   
      shiftOut(dataPin, clockPin, dataEsq);
      // Voltamos a por o pino "latch" do CI a HIGH para lhe indicar que já acabámos
      // de transmitir os dados
      digitalWrite(latchPin, 1);
     
    }
  }
Esta parte serve só para a parte dos displays de 7 segmentos, não bloqueia o que puseres depois disto.

Podes voltar a usar a variável "tempc" para calculares o necessário a enviar para o LCD Smartie. (Essa parte não vi muito bem, tens de ser tu a juntar as peças) 

[almamater]

Lol, caso ainda não tenhas reparado, eu sou o Ricardo... 

  Muito bom!! Nem tinha reparado/associado 

Tu não precisas de outro Arduino coisa nenhuma...
Ao retirares o delay, ficas com o sensor demasiado reactivo. E como sabes, tudo o que é analógico tem ruído.

O que está a acontecer é que estás com oscilações na leitura, pois estás a fazê-la demasiado rápida.
A leitura pode ser feita como tu tens... Mas a passagem para os display's de 7 Seg não.

Só temos de garantir que só passas um valor novo para os display's de X em X tempo.
Não querendo desviar-te da ideia, proponho-te a seguinte solução... A substituição não chega, temos de fazer uns "tweaks" ao código.

Adicionamos estas variáveis:

Código: [Seleccione]

int nLeituras = 0;
int maxLeituras = 8;
int interval = 50;
E agora no loop metes assim:

Código: [Seleccione]

  if(currentMillis - previousMillis > interval) {
    previousMillis = currentMillis;
   
    nleituras++;
    samples[i] = ( 5.0 * analogRead(sensorPin) * 100.0) / 1024.0;
   
    // Se atingimos o maximo de leituras que queremos
    if(nLeituras == maxLeituras){
      nleituras = 0; // recomecamos no proximo ciclo
     
      // vamos calcular a media
      for(i = 0; i<=7; i++) tempc = tempc + samples[i];
      tempc = tempc/8.0; // Calcula-se a média
           
      // para mostrar nos displays de 7 segmentos...
     
      // Calcula-se o dígito da esquerda e da direita
      int num1 = 0;
      do{
        num1++;
        tempc = tempc - 10;
      }while(tempc >= 10);
      dataEsq = esq[num1];
      dataDir = dir[tempc];
     
      // Enquanto estivermos a transmitir, o pino "latch" tem de estar a LOW
      digitalWrite(latchPin, 0);
      // Enviar os bytes
      shiftOut(dataPin, clockPin, dataDir);   
      shiftOut(dataPin, clockPin, dataEsq);
      // Voltamos a por o pino "latch" do CI a HIGH para lhe indicar que já acabámos
      // de transmitir os dados
      digitalWrite(latchPin, 1);
     
    }
  }
Esta parte serve só para a parte dos displays de 7 segmentos, não bloqueia o que puseres depois disto.

Podes voltar a usar a variável "tempc" para calculares o necessário a enviar para o LCD Smartie. (Essa parte não vi muito bem, tens de ser tu a juntar as peças) 

Muito obrigado pela dica!!! Logo já vou testar! Adoro este fórum!

[microbyte]

LOL. 
Dá notícias!! 

[almamater]

LOL. 
Dá notícias!! 

Ena pá!!

Tive de alterar só uma pequena coisa.. estava a devolver valores de 10º ou 13º, ficou assim:

Código: [Seleccione]

void loop() {
 unsigned long currentMillis = millis();

   if(currentMillis - previousMillis > interval) {
    previousMillis = currentMillis;
    nleituras++;
      // Se atingimos o maximo de leituras que queremos
       if(nleituras == maxLeituras){
      nleituras = 0; // recomecamos no proximo ciclo
      // vamos calcular a media
      for(i = 0; i<=7; i++){
    samples[i] = ( 5.0 * analogRead(sensorPin) * 100.0) / 1024.0;
    tempc = tempc + samples[i];
             }
      tempc = tempc/8.0; // Calcula-se a média
     
      // para mostrar nos displays de 7 segmentos...
     
      // Calcula-se o dígito da esquerda e da direita
      int num1 = 0;
      do{
        num1++;
        tempc = tempc - 10;
      }while(tempc >= 10);
      dataEsq = esq[num1];
      dataDir = dir[tempc];
     
      // Enquanto estivermos a transmitir, o pino "latch" tem de estar a LOW
      digitalWrite(latchPin, 0);
      // Enviar os bytes
      shiftOut(dataPin, clockPin, dataDir);   
      shiftOut(dataPin, clockPin, dataEsq);
      // Voltamos a por o pino "latch" do CI a HIGH para lhe indicar que já acabámos
      // de transmitir os dados
      digitalWrite(latchPin, 1);
         }
  }
So alterei a localização do:
 

Código: [Seleccione]

samples[i] = ( 5.0 * analogRead(sensorPin) * 100.0) / 1024.0;
que meti dentro do ciclo FOR

 
Agora demora mais tempo a actualizar os valores da temperatura (mas acho que tem a ver com o código do LCD pq qdo ligo o LcdSmartie e ele recebe dados já fica à velocidade normal) mas está bom assim.. fica tudo a funcionar ao mesmo tempo!!

Obrigadão!! Assim já posso continuar no meu código...! 

[microbyte]

LOL. 
Dá notícias!! 

Ena pá!!

Tive de alterar só uma pequena coisa.. estava a devolver valores de 10º ou 13º, ficou assim:

Código: [Seleccione]

void loop() {
 unsigned long currentMillis = millis();

   if(currentMillis - previousMillis > interval) {
    previousMillis = currentMillis;
    nleituras++;
      // Se atingimos o maximo de leituras que queremos
       if(nleituras == maxLeituras){
      nleituras = 0; // recomecamos no proximo ciclo
      // vamos calcular a media
      for(i = 0; i<=7; i++){
    samples[i] = ( 5.0 * analogRead(sensorPin) * 100.0) / 1024.0;
    tempc = tempc + samples[i];
             }
      tempc = tempc/8.0; // Calcula-se a média
     
      // para mostrar nos displays de 7 segmentos...
     
      // Calcula-se o dígito da esquerda e da direita
      int num1 = 0;
      do{
        num1++;
        tempc = tempc - 10;
      }while(tempc >= 10);
      dataEsq = esq[num1];
      dataDir = dir[tempc];
     
      // Enquanto estivermos a transmitir, o pino "latch" tem de estar a LOW
      digitalWrite(latchPin, 0);
      // Enviar os bytes
      shiftOut(dataPin, clockPin, dataDir);   
      shiftOut(dataPin, clockPin, dataEsq);
      // Voltamos a por o pino "latch" do CI a HIGH para lhe indicar que já acabámos
      // de transmitir os dados
      digitalWrite(latchPin, 1);
         }
  }
So alterei a localização do:
 

Código: [Seleccione]

samples[i] = ( 5.0 * analogRead(sensorPin) * 100.0) / 1024.0;
que meti dentro do ciclo FOR

 
Agora demora mais tempo a actualizar os valores da temperatura (mas acho que tem a ver com o código do LCD pq qdo ligo o LcdSmartie e ele recebe dados já fica à velocidade normal) mas está bom assim.. fica tudo a funcionar ao mesmo tempo!!

Obrigadão!! Assim já posso continuar no meu código...! 

Podes reduzir o tempo diminuindo o nº de samples ou diminuindo o tempo de intervalo.

De nada

[almamater]

Bom.. após 3 dias a tentar descobrir a solução para isto não sou capaz 

A minha questão está associada ao código e Loop do Arduino..:

Código: [Seleccione]

//LCD
#include <avr/interrupt.h>
#include <avr/io.h>
#include "LCD4Bit_mod.h"

LCD4Bit_mod lcd = LCD4Bit_mod(2);


//LM35       
      //Pin ST_CP (latch) do CI 74HC595
        int latchPin = 3;
      //Pin SH_CP (clock) do CI 74HC595
        int clockPin = 2;
      //Pin de dados do CI 74HC595
        int dataPin = 12;

int nleituras = 0;
int maxLeituras = 8;
int interval = 50;
long previousMillis = 0;
 
     
     //variáveis que ficam com os dados que vão ser passados para o ShiftOut()
        byte dataEsq;
        byte dataDir;
        byte esq[10];
        byte dir[10];
   
      int sensorPin = 4; // Pin Analógico
      int tempc = 0;     // Variável para a temperatura
      int samples[8];    // Variáveis para ter uma maior precisão
      int i;
 
       void setup() {
 
        pinMode(latchPin, OUTPUT);
        Serial.begin(19200);
       
  lcd.init();
  lcd.clear();
  lcd.printIn("TESTE");
  lcd.cursorTo(2,2);
  lcd.printIn("Linha 2");
 
        esq[0] = B11000000;
        esq[1] = B11111001; 
        esq[2] = B10100100;
        esq[3] = B10110000;
        esq[4] = B10011001;
        esq[5] = B10010010;
        esq[6] = B10000010; 
        esq[7] = B11111000; 
        esq[8] = B10000000;
        esq[9] = B10011000;       

        dir[0] = B11000000;
        dir[1] = B11111001; 
        dir[2] = B10100100; 
        dir[3] = B10110000;
        dir[4] = B10011001;
        dir[5] = B10010010;
        dir[6] = B10000010;
        dir[7] = B11111000;
        dir[8] = B10000000; 
        dir[9] = B10011000;
       }
 
 //LCD
 byte serial_getch(){
 
  int incoming; 
  while (Serial.available()==0){}
// read the incoming byte:
  incoming = Serial.read();
  return (byte) (incoming &0xff);
 }

 

void loop() {
 
  //TEMPERATURA E DISPLAYS DE SEGMENTOS
 unsigned long currentMillis = millis();

   if(currentMillis - previousMillis > interval) {
    previousMillis = currentMillis;
    nleituras++;
      // Se atingimos o maximo de leituras que queremos
       if(nleituras == maxLeituras){
      nleituras = 0; // recomecamos no proximo ciclo
      // vamos calcular a media
      for(i = 0; i<=7; i++){
    samples[i] = ( 5.0 * analogRead(sensorPin) * 100.0) / 1024.0;
    tempc = tempc + samples[i];
       
      }
      tempc = tempc/8.0; // Calcula-se a média
     
      // para mostrar nos displays de 7 segmentos...
     
      // Calcula-se o dígito da esquerda e da direita
      int num1 = 0;
      do{
        num1++;
        tempc = tempc - 10;
      }while(tempc >= 10);
      dataEsq = esq[num1];
      dataDir = dir[tempc];
     
      // Enquanto estivermos a transmitir, o pino "latch" tem de estar a LOW
      digitalWrite(latchPin, 0);
      // Enviar os bytes
      shiftOut(dataPin, clockPin, dataDir);   
      shiftOut(dataPin, clockPin, dataEsq);
      // Voltamos a por o pino "latch" do CI a HIGH para lhe indicar que já acabámos
      // de transmitir os dados
      digitalWrite(latchPin, 1);
     
    }
  }
         
      //LCD:
byte rxbyte;
byte temp;
rxbyte = serial_getch();

  if (rxbyte == 254) //Matrix Orbital uses 254 prefix for commands
{
switch (serial_getch())
{
case 66: //backlight on (at previously set brightness)
                                // not implemented

break;
case 70: //backlight off
// not implemented
                                break;
case 71:  //set cursor position
temp = (serial_getch() - 1);  //get column byte
switch (serial_getch())  //get row byte
{
//line 1 is already set up
case 2:
temp += 0x40;
break;
case 3:
temp += 0x14;
break;
case 4:
temp += 0x54;
break;
default:
break;
}
lcd.commandWrite(0b10000000 + temp);
break;
case 72:  //cursor home (reset display position)
lcd.commandWrite(2);
break;
case 74:  //show underline cursor
lcd.commandWrite(0b00001110);
break;
case 75:  //underline cursor off
case 84:  //block cursor off
lcd.commandWrite(0b00001100);
break;
case 76:  //move cursor left
lcd.commandWrite(16);
break;
case 77:  //move cursor right
lcd.commandWrite(20);
break;
case 78:  //define custom char
lcd.commandWrite(64 + (serial_getch() * 8));  //get+set char address
for (temp = 7; temp != 0; temp--)
{
lcd.print(serial_getch()); //get each pattern byte
}
break;
case 83:  //show blinking block cursor
lcd.commandWrite(0b00001111);
break;
case 86:  //GPO OFF
//implement later
break;
case 87:  //GPO ON
/*temp = serial_getch();
if (temp == 1)
{
GPO1 = GPO_ON;
}*/
break;
case 88:  //clear display, cursor home
lcd.commandWrite(1);
break;
case 152: //set and remember (doesn't save value, though)
case 153: //set backlight brightness
//not implemented
break;

//these commands ignored (no parameters)
case 35: //read serial number
case 36: //read version number
case 55: //read module type
case 59: //exit flow-control mode
case 65: //auto transmit keypresses
case 96: //auto-repeat mode off (keypad)
case 67: //auto line-wrap on
case 68: //auto line-wrap off
case 81: //auto scroll on
case 82: //auto scroll off
case 104: //init horiz bar graph
case 109: //init med size digits
case 115: //init narrow vert bar graph
case 118: //init wide vert bar graph
break;
default:
//all other commands ignored and parameter byte discarded
temp = serial_getch();  //dump the command code
break;
}
return;
} //END OF COMMAND HANDLER

//change accented char to plain, detect and change descenders
//NB descenders only work on 5x10 displays. This lookup table works
//  with my DEM-20845 (Display Elektronik GmbH) LCD using KS0066 chip.
switch (rxbyte)
{
//chars that have direct equivalent in LCD charmap
/* case 0x67: //g
rxbyte = 0xE7;
break;
case 0x6A: //j
rxbyte = 0xEA;
break;
case 0x70: //p
rxbyte = 0xF0;
break;
case 0x71: //q
rxbyte = 0xF1;
break;
case 0x79: //y
rxbyte = 0xF9;
break;
*/ case 0xE4: //ASCII "a" umlaut
rxbyte = 0xE1;
break;
case 0xF1: //ASCII "n" tilde
rxbyte = 0xEE;
break;
case 0xF6: //ASCII "o" umlaut
rxbyte = 0xEF; //was wrong in v0.86
break;
case 0xFC: //ASCII "u" umlaut
rxbyte = 0xF5;
break;

//accented -> plain equivalent
//and misc symbol translation
case 0xA3: //sterling (pounds)
rxbyte = 0xED;
break;
/* case 0xB0: //degrees symbol
rxbyte = 0xDF;
break;
*/ case 0xB5: //mu
rxbyte = 0xE4;
break;
case 0xC0: //"A" variants
case 0xC1:
case 0xC2:
case 0xC3:
case 0xC4:
case 0xC5:
rxbyte = 0x41;
break;
case 0xC8: //"E" variants
case 0xC9:
case 0xCA:
case 0xCB:
rxbyte = 0x45;
break;
case 0xCC: //"I" variants
case 0xCD:
case 0xCE:
case 0xCF:
rxbyte = 0x49;
break;
case 0xD1: //"N" tilde -> plain "N"
rxbyte = 0x43;
break;
case 0xD2: //"O" variants
case 0xD3:
case 0xD4:
case 0xD5:
case 0xD6:
case 0xD8:
rxbyte = 0x4F;
break;
case 0xD9: //"U" variants
case 0xDA:
case 0xDB:
case 0xDC:
rxbyte = 0x55;
break;
case 0xDD: //"Y" acute -> "Y"
rxbyte = 0x59;
break;
/* case 0xDF: //beta  //mucks up LCDSmartie's degree symbol??
rxbyte = 0xE2;
break;
*/ case 0xE0: //"a" variants except umlaut
case 0xE1:
case 0xE2:
case 0xE3:
case 0xE5:
rxbyte = 0x61;
break;
case 0xE7: //"c" cedilla -> "c"
rxbyte = 0x63;
break;
case 0xE8: //"e" variants
case 0xE9:
case 0xEA:
case 0xEB:
rxbyte = 0x65;
break;
case 0xEC: //"i" variants
case 0xED:
case 0xEE:
case 0xEF:
rxbyte = 0x69;
break;
case 0xF2: //"o" variants except umlaut
case 0xF3:
case 0xF4:
case 0xF5:
case 0xF8:
rxbyte = 0x6F;
break;
case 0xF7: //division symbol
rxbyte = 0xFD;
break;
case 0xF9: //"u" variants except umlaut
case 0xFA:
case 0xFB:
rxbyte = 0x75;
break;
default:
break;
}
lcd.print(rxbyte);  //otherwise a plain char so we print it to lcd

       
      }       

      // A função shiftOut (o coração do programa) 
      // Mais informações sobre o ShiftOut em:
      // http://www.arduino.cc/en/Tutorial/ShiftOut
      void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {

        int i=0;
        int pinState;
        pinMode(myClockPin, OUTPUT); 
        pinMode(myDataPin, OUTPUT);
       digitalWrite(myDataPin, 0);
       digitalWrite(myClockPin, 0);
   
        for (i=7; i>=0; i--)  {
          digitalWrite(myClockPin, 0);
          if ( myDataOut & (1<<i) ) {
            pinState= 1;
          }
 
          else {     
            pinState= 0;
          }
          digitalWrite(myDataPin, pinState); 
          digitalWrite(myClockPin, 1);
          digitalWrite(myDataPin, 0);
        }
         digitalWrite(myClockPin, 0);
                 
return;     
        }               }


O sistema está sempre a verificar se recebe algo através da porta série com a função  byte serial_getch(), acontece o seguinte:

Quando não está a receber nada [programa LcdSmartie OFF] :

• O loop parece que não é feito da mesma forma, a actualização parece ser de minuto a minuto.., pois os displays de temperatura demoram imenso tempo a actualizar.
• Fica a enviar  um caracter para o LCD indefenidamente, neste caso o "6"

Quando está a receber info [programa LcdSmartie ON] :

• O loop fica normal, a actualização da temperatura (execução do respectivo código) é feita normal
• Para o LCD vai apenas a info recebida, tudo ok+

Portanto, o problema resume-se apenas qdo ele não recebe nada vindo do PC, para além de enviar um caracter para o LCD não me executa o restante código (temperatura).

-> Fiz vários testes, um deles é se tiver a janela do "Serial Monitor", do software do arduino, aberta ele já não envia o "6", parece que é apenas qdo não tem nenhuma ligação activa. Reparei tb que se alterar o data rate o  carecter enviado muda tb.. em vez de ser "6" é um "u" 

Mesmo não estando a receber e enviar info para o LCD o arduino não devia de executar o restante código (temperatura) ao mesmo ritmo de sempre?

Obg

[microbyte]

O que deve acontecer é que ele pára na função "serial_getch()" porque tens lá um while...

Mete assim:

Código: [Seleccione]

if(Serial.available() > 0)
  rxbyte = serial_getch();
Assim, garantes que a função é executada apenas quando tens alguma coisa no buffer para ler...

[almamater]

O que deve acontecer é que ele pára na função "serial_getch()" porque tens lá um while...

Mete assim:

Código: [Seleccione]

if(Serial.available() > 0)
  rxbyte = serial_getch();
Assim, garantes que a função é executada apenas quando tens alguma coisa no buffer para ler...

Bom.. quase que resultava    mas isto está a ser teimoso.

Com o código

Código: [Seleccione]

if(Serial.available() > 0)
      rxbyte = serial_getch();

ele de facto já me executa todo o outro código e apenas vai à função serial_getch() quando recebe algo.

Mas desta forma o LCD não apresenta bem as coisas.. está sempre a limpar as linhas qdo deixa de receber info e não devia.

Testei meter tb o mesmo IF aqui:

Código: [Seleccione]

if(Serial.available() > 0)
lcd.print(rxbyte);  //otherwise a plain char so we print it to lcd
e de facto ficou a funcionar a 90%, apresenta as coisas sem apagar as linhas mas fica sempre um caracter (quadrado) no final que não desaparece.. grrr

Tou farto deste código 

[microbyte]

Tem calma, não tinha reparado que a variável era iniciada dentro do Loop.

Passa isto:
byte rxbyte;

para fora do loop(), para ao pé das variáveis que tens declaradas no início do código.

Testa da forma que te disse, com o tal if.

[almamater]

Tem calma, não tinha reparado que a variável era iniciada dentro do Loop.

Passa isto:
byte rxbyte;

para fora do loop(), para ao pé das variáveis que tens declaradas no início do código.

Testa da forma que te disse, com o tal if.

Tem calma, não tinha reparado que a variável era iniciada dentro do Loop.

Passa isto:
byte rxbyte;

para fora do loop(), para ao pé das variáveis que tens declaradas no início do código.

Testa da forma que te disse, com o tal if.

Troquei o byte rxbyte; para fora do Loop e mantive IF dentro, o resultado é o LCD sempre a limpar as linhas e a aparecer caracteres estranhos..
Fiz um vídeo com o resultado da alteração:

Resolvi depois meter tb o IF na linha que envia para o LCD:

Código: [Seleccione]

if(Serial.available() > 0)
  lcd.print(rxbyte);  //otherwise a plain char so we print it to lcd

O resultado é o mesmo, fica a aparecer +/- bem senão fosse o raio dum caracter no final da 2ª linha do lado direito, parece que não actualiza aquele bloco. Vídeo:

Código actual:

Código: [Seleccione]

//LCD
#include <avr/interrupt.h>
#include <avr/io.h>
#include "LCD4Bit_mod.h"

LCD4Bit_mod lcd = LCD4Bit_mod(2);

byte rxbyte;
byte temp;


//LM35       
      //Pin ST_CP (latch) do CI 74HC595
        int latchPin = 3;
      //Pin SH_CP (clock) do CI 74HC595
        int clockPin = 2;
      //Pin de dados do CI 74HC595
        int dataPin = 12;

int nleituras = 0;
int maxLeituras = 8;
int interval = 50;
long previousMillis = 0;
 
 

     
     //variáveis que ficam com os dados que vão ser passados para o ShiftOut()
        byte dataEsq;
        byte dataDir;
        byte esq[10];
        byte dir[10];
   
      int sensorPin = 4; // Pin Analógico
      int tempc = 0;     // Variável para a temperatura
      int samples[8];    // Variáveis para ter uma maior precisão
      int i;
 
void setup() {
pinMode(latchPin, OUTPUT);
Serial.begin(19200); //Alterei valor para o do LCD
       
  lcd.init();
  lcd.clear();
  lcd.printIn("FanController v2");
  lcd.cursorTo(2,2);
  lcd.printIn(" *GrcByte*");
 
        // A forma de escrever em binário no Arduino é pondo um 'B' atrás 
        // Aqui serão os códigos equivalentes aos dígitos 0 - 9
        // ATENCAO - estes códigos devem ser ajustados, pois dependem das
        // ligações que foram feitas ao CI.

        esq[0] = B11000000;
        esq[1] = B11111001; 
        esq[2] = B10100100;
        esq[3] = B10110000;
        esq[4] = B10011001;
        esq[5] = B10010010;
        esq[6] = B10000010; 
        esq[7] = B11111000; 
        esq[8] = B10000000;
        esq[9] = B10011000;       

        dir[0] = B11000000;
        dir[1] = B11111001; 
        dir[2] = B10100100; 
        dir[3] = B10110000;
        dir[4] = B10011001;
        dir[5] = B10010010;
        dir[6] = B10000010;
        dir[7] = B11111000;
        dir[8] = B10000000; 
        dir[9] = B10011000;
       }
 

 //LCD
 byte serial_getch(){
  int incoming; 
  while (Serial.available() == 0){}
// read the incoming byte:
  incoming = Serial.read();
  return (byte) (incoming &0xff);
 }

 void loop() {
 
  //TEMPERATURA E DISPLAYS DE SEGMENTOS
 unsigned long currentMillis = millis();

   if(currentMillis - previousMillis > interval) {
    previousMillis = currentMillis;
    nleituras++;
      // Se atingimos o maximo de leituras que queremos
       if(nleituras == maxLeituras){
      nleituras = 0; // recomecamos no proximo ciclo
      // vamos calcular a media
      for(i = 0; i<=7; i++){
    samples[i] = ( 5.0 * analogRead(sensorPin) * 100.0) / 1024.0;
    tempc = tempc + samples[i];
       
      }
      tempc = tempc/8.0; // Calcula-se a média
     
      // para mostrar nos displays de 7 segmentos...
     
      // Calcula-se o dígito da esquerda e da direita
      int num1 = 0;
      do{
        num1++;
        tempc = tempc - 10;
      }while(tempc >= 10);
      dataEsq = esq[num1];
      dataDir = dir[tempc];
     
      // Enquanto estivermos a transmitir, o pino "latch" tem de estar a LOW
      digitalWrite(latchPin, 0);
      // Enviar os bytes
      shiftOut(dataPin, clockPin, dataDir);   
      shiftOut(dataPin, clockPin, dataEsq);
      // Voltamos a por o pino "latch" do CI a HIGH para lhe indicar que já acabámos
      // de transmitir os dados
      digitalWrite(latchPin, 1);
     
    }
  }
         
//LCD
if(Serial.available() > 0)
rxbyte = serial_getch();

  if (rxbyte == 254) //Matrix Orbital uses 254 prefix for commands
{
switch (serial_getch())
{
case 66: //backlight on (at previously set brightness)
                                // not implemented

break;
case 70: //backlight off
// not implemented
                                break;
case 71:  //set cursor position
temp = (serial_getch() - 1);  //get column byte
switch (serial_getch())  //get row byte
{
//line 1 is already set up
case 2:
temp += 0x40;
break;
case 3:
temp += 0x14;
break;
case 4:
temp += 0x54;
break;
default:
break;
}
lcd.commandWrite(0b10000000 + temp);
break;
case 72:  //cursor home (reset display position)
lcd.commandWrite(2);
break;
case 74:  //show underline cursor
lcd.commandWrite(0b00001110);
break;
case 75:  //underline cursor off
case 84:  //block cursor off
lcd.commandWrite(0b00001100);
break;
case 76:  //move cursor left
lcd.commandWrite(16);
break;
case 77:  //move cursor right
lcd.commandWrite(20);
break;
case 78:  //define custom char
lcd.commandWrite(64 + (serial_getch() * 8));  //get+set char address
for (temp = 7; temp != 0; temp--)
{
lcd.print(serial_getch()); //get each pattern byte
}
break;
case 83:  //show blinking block cursor
lcd.commandWrite(0b00001111);
break;
case 86:  //GPO OFF
//implement later
break;
case 87:  //GPO ON
/*temp = serial_getch();
if (temp == 1)
{
GPO1 = GPO_ON;
}*/
break;
case 88:  //clear display, cursor home
lcd.commandWrite(1);
break;
case 152: //set and remember (doesn't save value, though)
case 153: //set backlight brightness
//not implemented
break;

//these commands ignored (no parameters)
case 35: //read serial number
case 36: //read version number
case 55: //read module type
case 59: //exit flow-control mode
case 65: //auto transmit keypresses
case 96: //auto-repeat mode off (keypad)
case 67: //auto line-wrap on
case 68: //auto line-wrap off
case 81: //auto scroll on
case 82: //auto scroll off
case 104: //init horiz bar graph
case 109: //init med size digits
case 115: //init narrow vert bar graph
case 118: //init wide vert bar graph
break;
default:
//all other commands ignored and parameter byte discarded
temp = serial_getch();  //dump the command code
break;
}
return;
} //END OF COMMAND HANDLER

//change accented char to plain, detect and change descenders
//NB descenders only work on 5x10 displays. This lookup table works
//  with my DEM-20845 (Display Elektronik GmbH) LCD using KS0066 chip.


switch (rxbyte)
{
//chars that have direct equivalent in LCD charmap
/* case 0x67: //g
rxbyte = 0xE7;
break;
case 0x6A: //j
rxbyte = 0xEA;
break;
case 0x70: //p
rxbyte = 0xF0;
break;
case 0x71: //q
rxbyte = 0xF1;
break;
case 0x79: //y
rxbyte = 0xF9;
break;
*/ case 0xE4: //ASCII "a" umlaut
rxbyte = 0xE1;
break;
case 0xF1: //ASCII "n" tilde
rxbyte = 0xEE;
break;
case 0xF6: //ASCII "o" umlaut
rxbyte = 0xEF; //was wrong in v0.86
break;
case 0xFC: //ASCII "u" umlaut
rxbyte = 0xF5;
break;

//accented -> plain equivalent
//and misc symbol translation
case 0xA3: //sterling (pounds)
rxbyte = 0xED;
break;
/* case 0xB0: //degrees symbol
rxbyte = 0xDF;
break;
*/ case 0xB5: //mu
rxbyte = 0xE4;
break;
case 0xC0: //"A" variants
case 0xC1:
case 0xC2:
case 0xC3:
case 0xC4:
case 0xC5:
rxbyte = 0x41;
break;
case 0xC8: //"E" variants
case 0xC9:
case 0xCA:
case 0xCB:
rxbyte = 0x45;
break;
case 0xCC: //"I" variants
case 0xCD:
case 0xCE:
case 0xCF:
rxbyte = 0x49;
break;
case 0xD1: //"N" tilde -> plain "N"
rxbyte = 0x43;
break;
case 0xD2: //"O" variants
case 0xD3:
case 0xD4:
case 0xD5:
case 0xD6:
case 0xD8:
rxbyte = 0x4F;
break;
case 0xD9: //"U" variants
case 0xDA:
case 0xDB:
case 0xDC:
rxbyte = 0x55;
break;
case 0xDD: //"Y" acute -> "Y"
rxbyte = 0x59;
break;
/* case 0xDF: //beta  //mucks up LCDSmartie's degree symbol??
rxbyte = 0xE2;
break;
*/ case 0xE0: //"a" variants except umlaut
case 0xE1:
case 0xE2:
case 0xE3:
case 0xE5:
rxbyte = 0x61;
break;
case 0xE7: //"c" cedilla -> "c"
rxbyte = 0x63;
break;
case 0xE8: //"e" variants
case 0xE9:
case 0xEA:
case 0xEB:
rxbyte = 0x65;
break;
case 0xEC: //"i" variants
case 0xED:
case 0xEE:
case 0xEF:
rxbyte = 0x69;
break;
case 0xF2: //"o" variants except umlaut
case 0xF3:
case 0xF4:
case 0xF5:
case 0xF8:
rxbyte = 0x6F;
break;
case 0xF7: //division symbol
rxbyte = 0xFD;
break;
case 0xF9: //"u" variants except umlaut
case 0xFA:
case 0xFB:
rxbyte = 0x75;
break;
default:
break;

}

if(Serial.available() > 0)
  lcd.print(rxbyte);  //otherwise a plain char so we print it to lcd


      }       

      // A função shiftOut (o coração do programa) 
      // Mais informações sobre o ShiftOut em:
      // http://www.arduino.cc/en/Tutorial/ShiftOut
      void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {

        int i=0;
        int pinState;
        pinMode(myClockPin, OUTPUT); 
        pinMode(myDataPin, OUTPUT);
       digitalWrite(myDataPin, 0);
       digitalWrite(myClockPin, 0);
   
        for (i=7; i>=0; i--)  {
          digitalWrite(myClockPin, 0);
          if ( myDataOut & (1<<i) ) {
            pinState= 1;
          }
 
          else {     
            pinState= 0;
          }
          digitalWrite(myDataPin, pinState); 
          digitalWrite(myClockPin, 1);
          digitalWrite(myDataPin, 0);
        }
         digitalWrite(myClockPin, 0);
       
         
return;     
       
               }


[almamater]

Bom, meti o código associado ao LCD todo dentro de duas "{" e parece que melhorou:

Código: [Seleccione]

if(Serial.available() > 0) {
rxbyte = serial_getch();

  if (rxbyte == 254) //Matrix Orbital uses 254 prefix for commands
 
{
switch (serial_getch())
{
case 66: //backlight on (at previously set brightness)
                                // not implemented

break;
case 70: //backlight off
// not implemented
                                break;
case 71:  //set cursor position
temp = (serial_getch() - 1);  //get column byte
switch (serial_getch())  //get row byte
{
//line 1 is already set up
case 2:
temp += 0x40;
break;
case 3:
temp += 0x14;
break;
case 4:
temp += 0x54;
break;
default:
break;
}
lcd.commandWrite(0b10000000 + temp);
break;
case 72:  //cursor home (reset display position)
lcd.commandWrite(2);
break;
case 74:  //show underline cursor
lcd.commandWrite(0b00001110);
break;
case 75:  //underline cursor off
case 84:  //block cursor off
lcd.commandWrite(0b00001100);
break;
case 76:  //move cursor left
lcd.commandWrite(16);
break;
case 77:  //move cursor right
lcd.commandWrite(20);
break;
case 78:  //define custom char
lcd.commandWrite(64 + (serial_getch() * 8));  //get+set char address
for (temp = 7; temp != 0; temp--)
{
lcd.print(serial_getch()); //get each pattern byte
}
break;
case 83:  //show blinking block cursor
lcd.commandWrite(0b00001111);
break;
case 86:  //GPO OFF
//implement later
break;
case 87:  //GPO ON
/*temp = serial_getch();
if (temp == 1)
{
GPO1 = GPO_ON;
}*/
break;
case 88:  //clear display, cursor home
lcd.commandWrite(1);
break;
case 152: //set and remember (doesn't save value, though)
case 153: //set backlight brightness
//not implemented
break;

//these commands ignored (no parameters)
case 35: //read serial number
case 36: //read version number
case 55: //read module type
case 59: //exit flow-control mode
case 65: //auto transmit keypresses
case 96: //auto-repeat mode off (keypad)
case 67: //auto line-wrap on
case 68: //auto line-wrap off
case 81: //auto scroll on
case 82: //auto scroll off
case 104: //init horiz bar graph
case 109: //init med size digits
case 115: //init narrow vert bar graph
case 118: //init wide vert bar graph
break;
default:
//all other commands ignored and parameter byte discarded
temp = serial_getch();  //dump the command code
break;
}
return;
} //END OF COMMAND HANDLER

//change accented char to plain, detect and change descenders
//NB descenders only work on 5x10 displays. This lookup table works
//  with my DEM-20845 (Display Elektronik GmbH) LCD using KS0066 chip.

switch (rxbyte)
{
//chars that have direct equivalent in LCD charmap
/* case 0x67: //g
rxbyte = 0xE7;
break;
case 0x6A: //j
rxbyte = 0xEA;
break;
case 0x70: //p
rxbyte = 0xF0;
break;
case 0x71: //q
rxbyte = 0xF1;
break;
case 0x79: //y
rxbyte = 0xF9;
break;
*/ case 0xE4: //ASCII "a" umlaut
rxbyte = 0xE1;
break;
case 0xF1: //ASCII "n" tilde
rxbyte = 0xEE;
break;
case 0xF6: //ASCII "o" umlaut
rxbyte = 0xEF; //was wrong in v0.86
break;
case 0xFC: //ASCII "u" umlaut
rxbyte = 0xF5;
break;

//accented -> plain equivalent
//and misc symbol translation
case 0xA3: //sterling (pounds)
rxbyte = 0xED;
break;
/* case 0xB0: //degrees symbol
rxbyte = 0xDF;
break;
*/ case 0xB5: //mu
rxbyte = 0xE4;
break;
case 0xC0: //"A" variants
case 0xC1:
case 0xC2:
case 0xC3:
case 0xC4:
case 0xC5:
rxbyte = 0x41;
break;
case 0xC8: //"E" variants
case 0xC9:
case 0xCA:
case 0xCB:
rxbyte = 0x45;
break;
case 0xCC: //"I" variants
case 0xCD:
case 0xCE:
case 0xCF:
rxbyte = 0x49;
break;
case 0xD1: //"N" tilde -> plain "N"
rxbyte = 0x43;
break;
case 0xD2: //"O" variants
case 0xD3:
case 0xD4:
case 0xD5:
case 0xD6:
case 0xD8:
rxbyte = 0x4F;
break;
case 0xD9: //"U" variants
case 0xDA:
case 0xDB:
case 0xDC:
rxbyte = 0x55;
break;
case 0xDD: //"Y" acute -> "Y"
rxbyte = 0x59;
break;
/* case 0xDF: //beta  //mucks up LCDSmartie's degree symbol??
rxbyte = 0xE2;
break;
*/ case 0xE0: //"a" variants except umlaut
case 0xE1:
case 0xE2:
case 0xE3:
case 0xE5:
rxbyte = 0x61;
break;
case 0xE7: //"c" cedilla -> "c"
rxbyte = 0x63;
break;
case 0xE8: //"e" variants
case 0xE9:
case 0xEA:
case 0xEB:
rxbyte = 0x65;
break;
case 0xEC: //"i" variants
case 0xED:
case 0xEE:
case 0xEF:
rxbyte = 0x69;
break;
case 0xF2: //"o" variants except umlaut
case 0xF3:
case 0xF4:
case 0xF5:
case 0xF8:
rxbyte = 0x6F;
break;
case 0xF7: //division symbol
rxbyte = 0xFD;
break;
case 0xF9: //"u" variants except umlaut
case 0xFA:
case 0xFB:
rxbyte = 0x75;
break;
default:
break;
}

        //
lcd.print(rxbyte);  //otherwise a plain char so we print it to lcd
      }

Resultado: , existem uns promenores mas nada de grave.

A diferença do Arduino para outro projecto que fiz igual mas usando um PIC é por exemplo nas barras do spectrum analyzer que ficam mais lentas.., só que não dá para melhorar    Resultado: (se aumentar o "Refresh Interval" no LcdSmartie fica tudo marado no LCD) .

Será possível bloquear o envio de caracteres quando o LCD Smartie está OFF, ou seja, apenas tenho o cabo USB ligado e ele de x em x tempo vai enviado isto para o LCD:

[almamater]

  Continuo às turras com o "66666" enviado para o LCD   

Agora consigo que ao inicio de tudo ele não envie estes caracteres, coloquei uma variável rxbyte2 e que apenas envia para o LCD qdo lhe que atribuo o valor de 254, ou seja, apenas qdo o LCDSmartie é ligado. O problema é qdo desligo o LCDSmartie, não sei como identificar qdo é que é desligado para voltar a definir a variável rxbyte2=0

Código: [Seleccione]

//LCD
#include <avr/interrupt.h>
#include <avr/io.h>
#include "LCD4Bit_mod.h"

LCD4Bit_mod lcd = LCD4Bit_mod(2);

byte rxbyte;
byte temp;
int rxbyte2=0;



//LM35       
      //Pin ST_CP (latch) do CI 74HC595
        int latchPin = 3;
      //Pin SH_CP (clock) do CI 74HC595
        int clockPin = 2;
      //Pin de dados do CI 74HC595
        int dataPin = 12;

int nleituras = 0;
int maxLeituras = 8;
int interval = 50;
long previousMillis = 0;
 
       //variáveis que ficam com os dados que vão ser passados para o ShiftOut()
        byte dataEsq;
        byte dataDir;
        byte esq[10];
        byte dir[10];
   
      int sensorPin = 4; // Pin Analógico
      int tempc = 0;     // Variável para a temperatura
      int samples[8];    // Variáveis para ter uma maior precisão
      int i;
 
void setup() {
pinMode(latchPin, OUTPUT);
Serial.begin(19200); //Alterei valor para o do LCD
       
  lcd.init();
  lcd.clear();
  lcd.printIn("FanController v2");
  lcd.cursorTo(2,2);
  lcd.printIn(" *GrcByte*");

 
 
        // A forma de escrever em binário no Arduino é pondo um 'B' atrás 
        // Aqui serão os códigos equivalentes aos dígitos 0 - 9
        // ATENCAO - estes códigos devem ser ajustados, pois dependem das
        // ligações que foram feitas ao CI.

        esq[0] = B11000000;
        esq[1] = B11111001; 
        esq[2] = B10100100;
        esq[3] = B10110000;
        esq[4] = B10011001;
        esq[5] = B10010010;
        esq[6] = B10000010; 
        esq[7] = B11111000; 
        esq[8] = B10000000;
        esq[9] = B10011000;       

        dir[0] = B11000000;
        dir[1] = B11111001; 
        dir[2] = B10100100; 
        dir[3] = B10110000;
        dir[4] = B10011001;
        dir[5] = B10010010;
        dir[6] = B10000010;
        dir[7] = B11111000;
        dir[8] = B10000000; 
        dir[9] = B10011000;
       }
  //LCD
 byte serial_getch(){
  int incoming; 
  while (Serial.available() == 0){}
// read the incoming byte:
  incoming = Serial.read();
  return (byte) (incoming &0xff);

    }

 void loop() {
 
  //TEMPERATURA E DISPLAYS DE SEGMENTOS
 unsigned long currentMillis = millis();

   if(currentMillis - previousMillis > interval) {
    previousMillis = currentMillis;
    nleituras++;
      // Se atingimos o maximo de leituras que queremos
       if(nleituras == maxLeituras){
      nleituras = 0; // recomecamos no proximo ciclo
      // vamos calcular a media
      for(i = 0; i<=7; i++){
    samples[i] = ( 5.0 * analogRead(sensorPin) * 100.0) / 1024.0;
    tempc = tempc + samples[i];
       
      }
      tempc = tempc/8.0; // Calcula-se a média
     
      // para mostrar nos displays de 7 segmentos...
     
      // Calcula-se o dígito da esquerda e da direita
      int num1 = 0;
      do{
        num1++;
        tempc = tempc - 10;
      }while(tempc >= 10);
      dataEsq = esq[num1];
      dataDir = dir[tempc];
     
      // Enquanto estivermos a transmitir, o pino "latch" tem de estar a LOW
      digitalWrite(latchPin, 0);
      // Enviar os bytes
      shiftOut(dataPin, clockPin, dataDir);   
      shiftOut(dataPin, clockPin, dataEsq);
      // Voltamos a por o pino "latch" do CI a HIGH para lhe indicar que já acabámos
      // de transmitir os dados
      digitalWrite(latchPin, 1);
     
    }
  }
         
//LCD

if(Serial.available() > 0) {
  rxbyte = serial_getch();

if (rxbyte == 254) //Matrix Orbital uses 254 prefix for commands
  {
      rxbyte2=254;
switch (serial_getch())
{
case 66: //backlight on (at previously set brightness)
                                // not implemented

break;
case 70:  //backlight off
// not implemented
                                break;
case 71:  //set cursor position
temp = (serial_getch() - 1);  //get column byte
switch (serial_getch())  //get row byte
{
//line 1 is already set up
case 2:
temp += 0x40;
break;
case 3:
temp += 0x14;
break;
case 4:
temp += 0x54;
break;
default:
break;
}
lcd.commandWrite(0b10000000 + temp);
break;
case 72:  //cursor home (reset display position)
lcd.commandWrite(2);
break;
case 74:  //show underline cursor
lcd.commandWrite(0b00001110);
break;
case 75:  //underline cursor off
case 84:  //block cursor off
lcd.commandWrite(0b00001100);
break;
case 76:  //move cursor left
lcd.commandWrite(16);
break;
case 77:  //move cursor right
lcd.commandWrite(20);
break;
case 78:  //define custom char
lcd.commandWrite(64 + (serial_getch() * 8));  //get+set char address
for (temp = 7; temp != 0; temp--)
{
lcd.print(serial_getch()); //get each pattern byte
}
break;
case 83:  //show blinking block cursor
lcd.commandWrite(0b00001111);
break;
case 86:  //GPO OFF
//implement later
break;
case 87:  //GPO ON
/*temp = serial_getch();
if (temp == 1)
{
GPO1 = GPO_ON;
}*/
break;
case 88:  //clear display, cursor home
lcd.commandWrite(1);
break;
case 152: //set and remember (doesn't save value, though)
case 153: //set backlight brightness
//not implemented
break;

//these commands ignored (no parameters)
case 35: //read serial number
case 36: //read version number
case 55: //read module type
case 59: //exit flow-control mode
case 65: //auto transmit keypresses
case 96: //auto-repeat mode off (keypad)
case 67: //auto line-wrap on
case 68: //auto line-wrap off
case 81: //auto scroll on
case 82: //auto scroll off
case 104: //init horiz bar graph
case 109: //init med size digits
case 115: //init narrow vert bar graph
case 118: //init wide vert bar graph
break;
default:
//all other commands ignored and parameter byte discarded
temp = serial_getch();  //dump the command code
break;                               
}
return;



} //END OF COMMAND HANDLER 

        //change accented char to plain, detect and change descenders
//NB descenders only work on 5x10 displays. This lookup table works
//  with my DEM-20845 (Display Elektronik GmbH) LCD using KS0066 chip.

switch (rxbyte)
{
//chars that have direct equivalent in LCD charmap
/* case 0x67: //g
rxbyte = 0xE7;
break;
case 0x6A: //j
rxbyte = 0xEA;
break;
case 0x70: //p
rxbyte = 0xF0;
break;
case 0x71: //q
rxbyte = 0xF1;
break;
case 0x79: //y
rxbyte = 0xF9;
break;
*/ case 0xE4: //ASCII "a" umlaut
rxbyte = 0xE1;
break;
case 0xF1: //ASCII "n" tilde
rxbyte = 0xEE;
break;
case 0xF6: //ASCII "o" umlaut
rxbyte = 0xEF; //was wrong in v0.86
break;
case 0xFC: //ASCII "u" umlaut
rxbyte = 0xF5;
break;

//accented -> plain equivalent
//and misc symbol translation
case 0xA3: //sterling (pounds)
rxbyte = 0xED;
break;
/* case 0xB0: //degrees symbol
rxbyte = 0xDF;
break;
*/ case 0xB5: //mu
rxbyte = 0xE4;
break;
case 0xC0: //"A" variants
case 0xC1:
case 0xC2:
case 0xC3:
case 0xC4:
case 0xC5:
rxbyte = 0x41;
break;
case 0xC8: //"E" variants
case 0xC9:
case 0xCA:
case 0xCB:
rxbyte = 0x45;
break;
case 0xCC: //"I" variants
case 0xCD:
case 0xCE:
case 0xCF:
rxbyte = 0x49;
break;
case 0xD1: //"N" tilde -> plain "N"
rxbyte = 0x43;
break;
case 0xD2: //"O" variants
case 0xD3:
case 0xD4:
case 0xD5:
case 0xD6:
case 0xD8:
rxbyte = 0x4F;
break;
case 0xD9: //"U" variants
case 0xDA:
case 0xDB:
case 0xDC:
rxbyte = 0x55;
break;
case 0xDD: //"Y" acute -> "Y"
rxbyte = 0x59;
                        break;
/* case 0xDF: //beta  //mucks up LCDSmartie's degree symbol??
rxbyte = 0xE2;
break;
*/ case 0xE0: //"a" variants except umlaut
case 0xE1:
case 0xE2:
case 0xE3:
case 0xE5:
rxbyte = 0x61;
break;
case 0xE7: //"c" cedilla -> "c"
rxbyte = 0x63;
break;
case 0xE8: //"e" variants
case 0xE9:
case 0xEA:
case 0xEB:
rxbyte = 0x65;
break;
case 0xEC: //"i" variants
case 0xED:
case 0xEE:
case 0xEF:
rxbyte = 0x69;
break;
case 0xF2: //"o" variants except umlaut
case 0xF3:
case 0xF4:
case 0xF5:
case 0xF8:
rxbyte = 0x6F;
break;
case 0xF7: //division symbol
rxbyte = 0xFD;
break;
case 0xF9: //"u" variants except umlaut
case 0xFA:
case 0xFB:
rxbyte = 0x75;
break;
default:
                    break;
}
        if (rxbyte2 == 254){
         lcd.print(rxbyte);  //otherwise a plain char so we print it to lcd
         }                   
 }
 }

      // A função shiftOut (o coração do programa) 
      // Mais informações sobre o ShiftOut em:
      // http://www.arduino.cc/en/Tutorial/ShiftOut
      void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {

        int i=0;
        int pinState;
        pinMode(myClockPin, OUTPUT); 
        pinMode(myDataPin, OUTPUT);
       digitalWrite(myDataPin, 0);
       digitalWrite(myClockPin, 0);
   
        for (i=7; i>=0; i--)  {
          digitalWrite(myClockPin, 0);
          if ( myDataOut & (1<<i) ) {
            pinState= 1;
          }
 
          else {     
            pinState= 0;
          }
          digitalWrite(myDataPin, pinState); 
          digitalWrite(myClockPin, 1);
          digitalWrite(myDataPin, 0);
        }
         digitalWrite(myClockPin, 0);
           
return;     


         
               }

Testei voltar às origens e programar o Arduino com o código original http://www.nuelectronics.com/estore/?p=9 mas acontece o mesmo, ou é defeito ou feitio