Oi boa tarde, estou fazendo um projeto do sensor fs300 que vai emitir o sinal para o arduino que passara a leitura para o lcd, usei a ligal so sensor nesta figura a seguir.

soh que fiz a ligacao do lcd na figura a seguir.

soh coloquei a ligação nos pinos 4,5,6,7,8,9, respectivamente, o lcd ligou, msd tem um sombreado na parte de baixo, gostaria de saber o que poderia ser ,

desde ja agradeço

se puder me orientar tenha a programacao, soh queria colocar as varieaveis

segue em anexo em portugues

#include <LiquidCrystal.h> 

// Inicializa a libraria do lcd com os pinos de interface 
LiquidCrystal lcd(9, 8, 7, 6, 5, 4); 

// Especifica os pinos para os dois botoes de reset dos contadorese o led indicador de estado 
byte reset_total_A = 11; 
byte reset_total_B = 12; 
byte led_de_estado = 13; 

byte interrupt_do_sensor = 0; // 0 = pino 2; 1 = pino 3 
byte pino_do_sensor = 2; 

// O sensor de fluxo por efeito Hall envia 4.5 pulsos por segundo por litro de fluxo 
float factor_calibragem = 4.5; 

volatile byte contagem_pulsos = 0; 

float fluxo = 0.0; 
unsigned int fluxo_ml = 0; 
unsigned long ml_total_A = 0; 
unsigned long ml_total_B = 0; 

unsigned long tempo_antigo = 0; 

void setup() { 
  lcd.begin(16, 2); 
  lcd.setCursor(0, 0); 
  lcd.print(" "); 
  lcd.setCursor(0, 1); 
  lcd.print(" "); 

  // Inicializa a conexao serial para comunicar com o pc 
  Serial.begin(38400); 

  // Define os pinos do led indicador de estaddo como saida 
  pinMode(led_de_estado, OUTPUT); 
  digitalWrite(led_de_estado, HIGH); // ativa o led indicador de estado 

  // Define os botoes de reset e ativa os resistores pullup internos 
  pinMode(reset_total_A, INPUT); 
  digitalWrite(reset_total_A, HIGH); 
  pinMode(reset_total_B, INPUT); 
  digitalWrite(reset_total_B, HIGH); 

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

  // O sensor de efeito Hall esta conetado ao pino 2 e usa a interupcao 0. 
  // Configurado para mudança de estado FALLING (transicao de estado HIGH para estado LOW) 
  attachInterrupt(interrupt_do_sensor, contador_de_pulsos, FALLING); 
} 

/** 
* Ciclo principal 
*/ 
void loop() { 
  if (digitalRead(reset_total_A) == LOW) { 
    ml_total_A = 0; 
    lcd.setCursor(0, 1); 
    lcd.print("0L "); 
  } 
  if (digitalRead(reset_total_B) == LOW) { 
    ml_total_B = 0; 
    lcd.setCursor(8, 1); 
    lcd.print("0L "); 
  } 
  if ((digitalRead(reset_total_A) == LOW) || (digitalRead(reset_total_B) == LOW)) { 
    digitalWrite(led_de_estado, LOW); 
  } 
  else { 
    digitalWrite(led_de_estado, HIGH); 
  } 

  if((millis() - tempo_antigo) > 1000) {  // Apenas processar os contadores a cada um segundo 
    detachInterrupt(interrupt_do_sensor);   // Desactivar o interupt enquanto calculamos o fluxo e envio do valor 
    //lcd.setCursor(15, 0); 
    //lcd.print("*"); 
  
    // Por causa de este ciclo poder não ser executado em intervalos de um segundo 
    // calculamos os milissegundos que passaram desde a ultima execução e usamos esse
    // valor apra a escala do calculo. Também é aplicado o factor de calibração baseado no 
    // numero de pulsos por segundo por litro (litros/minuto nestes caso) emitidos pelo sensor. 
    fluxo = ((1000.0 / (millis() - tempo_antigo)) * contagem_pulsos) / factor_calibragem; 
  
    // Anotar o tempo no qual fazemos este calculo. Repara que neste caso porque nós 
    // interrompemos os interrupts a função millis() não está incrementando e vai nos
    // retornar o valor de millisegundos de quando nós desactivamos os interrupts. 
    tempo_antigo = millis(); 
  
    // Dividir o fluxo em litros/minuto por 60 para determinar quantos litros passaram no 
    // sensor neste intervalo de 1 segundo, e multiplicar por 1000 para converter em ml. 
    fluxo_ml = (fluxo / 60) * 1000; 
  
    // Adicionar os mililitros medidos neste segundo ao total cumulativo 
    ml_total_A += fluxo_ml; 
    ml_total_B += fluxo_ml; 
  
    // Durante o teste pode ser util imprimir a variavel de contagem dos pulsos 
    // para poder ser comparado com o fluxo esperado no datasheet do sensor. 
    Serial.print(contagem_pulsos, DEC); 
    Serial.print(" "); 
  
    // Escrever o valor calculado para a porta serial. Porque queremos imprimir um valor 
    // fracional e print() não suporta, faremos um calculo para imprimir a parte inteira, 
    // o ponto decimal e a parte fracional. 
    unsigned int fracao; 
  
    // Imprime o fluxo neste segundo em litros/minuto 
    Serial.print(int(fluxo)); // Imprime a parte inteira da variavel de fluxo 
    Serial.print("."); // Imprime o ponto decimal 
    // Calcula a parte fracional. O multiplicador 10 calcula 1 casa decimal. 
    fracao = (fluxo - int(fluxo)) * 10; 
    Serial.print(fracao, DEC) ; // Imprime a parte fracional da variavel de fluxo 
  
    // Imprime o numero de litros fluidos neste segundo 
    Serial.print(" ");     // Separador 
    Serial.print(fluxo_ml); 
  
    // Imprime o total cumulativo de litros desde o inicio 
    Serial.print(" ");    // Separador 
    Serial.print(ml_total_A); 
    Serial.print(" ");     // Separador 
    Serial.println(ml_total_B); 
  
    lcd.setCursor(0, 0); 
    lcd.print(" "); 
    lcd.setCursor(0, 0); 
    lcd.print("Fluxo: "); 
    if(int(fluxo) < 10) { 
      lcd.print(" "); 
    } 
    lcd.print((int)fluxo);   // Imprime a parte inteira da variavel de fluxo 
    lcd.print('.');          // Imprime o ponto decimal 
    lcd.print(fracao, DEC) ; // Imprime a parte fracional da variavel de fluxo 
    lcd.print(" L"); 
    lcd.print("/min"); 
  
    lcd.setCursor(0, 1); 
    lcd.print(int(ml_total_A / 1000)); 
    lcd.print("L"); 
    lcd.setCursor(8, 1); 
    lcd.print(int(ml_total_B / 1000)); 
    lcd.print("L"); 
  
    // Resetar a contagem de pulsos 
    contagem_pulsos = 0; 
  
    // Ativa a interrupt do sensor novamente 
    attachInterrupt(interrupt_do_sensor, contador_de_pulsos, FALLING); 
  } 
} 

/** 
* Chamado por interrupt0 uma vez por cada rotação do sensor de efeito hall. 
*/ 

void contador_de_pulsos() { 
  // Incrementa a variavel de contagem dos pulsos 
  contagem_pulsos++; 
}

.