Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa

Componentes e Materiais

Componente Quantidade
Arduino Nano R3 1

Sobre o Projeto

Descrição

Eu queria! Tive inveja do carro grande do meu amigo Taggi mostrando a velocidade no para-brisa. Tive que ter, tive que fazer eu mesmo, claro!

HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa

Ponto de Vista do Software

Projetando o circuito, a parte mais difícil e confusa foi a conexão dos displays de 7 segmentos aos decodificadores BCD porque os números são "invertidos" (espelhados).

Há 3 botões: + e - para aumentar/diminuir brilho e S/H para alternar entre Velocidade em km/h e Rumo em graus; no caso de Rumo, o LED vermelho também acende, significando "graus" da bússola (1-360°) quando em movimento. Não é uma bússola eletrônica, é um GPS e você precisa se mover para ter a informação correta da direção para a qual está se movendo. O brilho é salvo na memória EEPROM após um minuto. O brilho é alterado tanto nos displays quanto no LED via pinos PWM.

Uma parte importante do código é para coletar dados do GPS, principalmente velocidade e direção, extraindo-os de cada sentença NMEA. Mesmo usando a classe String, principalmente para manipulação de sentenças NMEA seriais, todo o fluxo de elaboração é estável e sólido; usa "serialEvent()" para receber dados do GPS uma vez por segundo, então chama "nmeaExtractData()" e finalmente verifica o pacote de dados com "nmea0183_checksum()" para garantir integridade dos dados. Se você usar outra marca e modelo de GPS, certifique-se que as sentenças tenham a mesma estrutura ou terá que fazer algumas alterações aqui. Por exemplo, EM406A usa pacote "$GPRMC", BT220 usa "$GNRMC" em vez... apenas uma pequena mudança de nome... Um link útil pode ajudar com teste de checksum: https://nmeachecksum.eqth.net - Aqui um exemplo de uma sentença NMEA completa, ela contém: id, tempo, validade, latitude, longitude, velocidade, curso verdadeiro, data, variação e checksum.

$GNRMC, 095836.000, A, 4551.9676, N, 01328.7118, E, 2.09, 341.84, 280519,, *08

O sketch provê para habilitar o latch para cada decodificador BCD de display individualmente, definir o número do código no barramento binário de 4 bits, desabilitar o latch, e assim por diante quando o valor muda. Zeros à esquerda não significativos são apagados (não exibidos).

Antes de carregar um novo sketch para o MCU lembre-se de remover o Jumper: ele está conectado ao pino Rx do Arduino e durante o carregamento certamente estará em conflito com o Tx do GPS. Após carregar o software, coloque o Jumper de volta no lugar para restaurar a funcionalidade normal.

HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa

Lista de Componentes

PCB (Placas de Circuito Impresso)

Usei duas PCBs de face dupla por isso cerca de 50 rebites ou pinos passantes são usados para resolver rotas para todo o circuito. Há também 5 furos de alinhamento para fazer primeiro. Projetei em cada PCB esses 5 pontos de alinhamento. Na seção de download você tem todos os arquivos PCB, faces de componentes e solda, espelhados, para download e impressão por meio de uma impressora a laser em folhas "amarelas" ou "azuis"; desta vez usei as azuis mas as amarelas também são boas e o preço é menor. Tenho que dizer que as folhas azuis são melhores... Ao imprimir, lembre-se de desativar configurações de economia de toner, use em vez disso resolução de 1200 dpi para ter resultado preto profundo real. O processo de transferência de toner das folhas mágicas para PCB é feito pelo uso de um ferro quente... Por aí na rede há alguns tutoriais mostrando como produzir uma boa PCB mas lembre destes pontos importantes: limpe perfeitamente e escove levemente o cobre com uma esponja rugosa de cozinha, 5 minutos de ferro, choque térmico com água, alinhamento das duas faces por meio dos 5 furos (usei 5 pinos em uma superfície de LED branca grande para ver os furos), proteja a outra face durante o processo de corrosão. Imprimir também a face de componentes torna o projeto "profissional" :-)

HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa

NOTAS: as fotos são da versão anterior à final, significa que alguns detalhes podem ser diferentes: ex. o fio verde estranho ao redor das PCBs na versão final desaparece, ou o Jumper mudou da PCB #1 para PCB #2. Você deve configurar o GPS a 9600 bps, sentença NMEA GNRMC 1Hz apenas; isso pode ser feito usando seu próprio software de configuração. Finalmente, antes de soldar o conector USB fêmea, cole um pequeno pedaço de fita isolante sob ele para evitar contato indesejado com uma trilha de cobre, no lado dos componentes, logo abaixo dele.

HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa
HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa

Ao dar energia pela primeira vez você descobrirá que os números são "ilegíveis", porque foi feito para olhá-los refletidos no para-brisa (espelho). Instale no carro na frente do banco do motorista, encontre um lugar confortável e fixe. Sugiro conectar o cabo de alimentação USB após a posição de ignição para que ligue/desligue quando motor ligado/desligado. É isso, damas e cavalheiros!

Novidades e Melhorias

HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa
HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa
HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa

Ao dirigir, apenas dirija. Dirija com segurança!

Código

Sketch Arduino Car-HUD

/* Este sketch atua como HUD (head up display) de para-brisa de carro, por Marco Zonca, 10/2020
Arduino Nano como CPU, GPS BT-220 nmea a cada 1 seg, 3 x botões, 3 x displays 7 segmentos cátodo comum,
3 x 14511 decodificador BCD latch, memória EEPROM MPU (1 byte) e muitos resistores;
AVISO: =======
Antes de atualizar software, desconecte pino RX no Arduino (TX do GPS) por meio do JUMPER */
#include <Wire.h>
#include <EEPROM.h>
String inputString = "";
String nm_time = "00:00:00";
String nm_validity = "V";
String nm_latitude = "dd°mm.mmmm'N";
String nm_longitude = "ddd°mm.mmmm'E";
String nm_knots = "0.0kn";
float nmf_knots = 0.0;
float nmf_kmh = 0.0;
int nmi_kmh = 0;
String nm_truecourse = "360";
float nmf_truecourse = 360;
String nm_date = "dd/mm/yyyy";
int nmi_truecourse = 0;
byte kCent = 0;
byte kDeci = 0;
byte kUnit = 0;
byte tCent = 0;
byte tDeci = 0;
byte tUnit = 0;
byte brightness = 120;
byte latch_off = HIGH;
byte latch_on = LOW;
int n=0;
unsigned long lastmemcheck = 0;
unsigned long memcheck = 60000; // verifica para salvar valor "brightness" na EEPROM a cada 60 segundos
bool stringComplete = false;
bool isKMH=true;
bool ret = false;
const int disp001 = 2; // latch display unidades
const int disp010 = 8; // latch display dezenas
const int disp100 = 12; // latch display centenas
const int disp001dim = 9; // pino dimmer/off display unidades
const int disp010dim = 10; // pino dimmer/off display dezenas
const int disp100dim = 11; // pino dimmer/off display centenas
const int button_kt = 14; // botão kmh/rumo
const int button_more = 15; // botão brilho +
const int button_less = 16; // botão brilho -
const int degreesLED = 3; // LED graus
const int bit_3 = 7; // bit 3
const int bit_2 = 6; // bit 2
const int bit_1 = 5; // bit 1
const int bit_0 = 4; // bit 0
const int dly = 10; // delay latch m/seg
const byte off = 0; // mesmo que brightness=0
const int addr = 0; // endereço EEPROM para valor de brilho
const byte numbers[10] [4] = {{0,0,0,0},{1,0,0,0},{0,1,0,0},{1,1,0,0},{0,0,1,0},
 {1,0,1,0},{0,1,1,0},{1,1,1,0},{0,0,0,1},{1,0,0,1}}; // bits 0,1,2,3

void setup() {
  Serial.begin(9600);
  Wire.begin();
  inputString.reserve(200);
  brightness = EEPROM.read(addr);
  if (brightness > 250 || brightness < 10) {
    brightness=120;
  } // evita valores loucos na 1ª leitura da EEPROM
  pinMode(disp001, OUTPUT);
  pinMode(disp010, OUTPUT);
  pinMode(disp100, OUTPUT);
  pinMode(degreesLED, OUTPUT);
  pinMode(button_kt, INPUT_PULLUP);
  pinMode(button_less, INPUT_PULLUP);
  pinMode(button_more, INPUT_PULLUP);
  pinMode(bit_3, OUTPUT);
  pinMode(bit_2, OUTPUT);
  pinMode(bit_1, OUTPUT);
  pinMode(bit_0, OUTPUT);
  analogWrite(disp001dim, off); // off e zera displays
  analogWrite(disp010dim, off);
  analogWrite(disp100dim, off);
  analogWrite(degreesLED, off);
  setBusNr(0);
  digitalWrite(disp001, latch_on);
  digitalWrite(disp010, latch_on);
  digitalWrite(disp100, latch_on);
  delay(dly);
  digitalWrite(disp001, latch_off);
  digitalWrite(disp010, latch_off);
  digitalWrite(disp100, latch_off);
  analogWrite(disp001dim, brightness); // liga display
  analogWrite(disp010dim, brightness);
  analogWrite(disp100dim, brightness);
}

void loop() {
  // GPS NMEA ------------------
  if (stringComplete == true) {
    // recebeu sentença nmea pela porta serial RX
    ret = nmeaExtractData();
    inputString = "";
    stringComplete = false;
    if (ret == true) {
      kCent=nmi_kmh/100;
      n=nmi_kmh-(kCent*100);
      kDeci=n/10;
      n=nmi_kmh-(kCent*100)-(kDeci*10);
      kUnit=n;
      tCent=nmi_truecourse/100;
      n=nmi_truecourse-(tCent*100);
      tDeci=n/10;
      n=nmi_truecourse-(tCent*100)-(tDeci*10);
      tUnit=n;
      display();
    }
  }
  if (millis() > (lastmemcheck+memcheck)) {
    // grava na memória valor de brilho (se modificado)
    EEPROM.update(addr,brightness);
    lastmemcheck=millis();
  }
  checkButtons();
}

void display() {
  if (isKMH == true) {
    // velocidade em km/h (isKMH=true)
    analogWrite(degreesLED, off);
    setBusNr(kUnit);
    digitalWrite(disp001, latch_on);
    delay(dly);
    digitalWrite(disp001, latch_off);
    if (kDeci > 0 || kCent > 0) {
      // define dezenas off se dezenas=0 (e também centenas=0)
      setBusNr(kDeci);
      digitalWrite(disp010, latch_on);
      delay(dly);
      digitalWrite(disp010, latch_off);
      analogWrite(disp010dim, brightness);
    } else {
      analogWrite(disp010dim, off);
    }
    if (kCent > 0) {
      // define centenas off se=0
      setBusNr(kCent);
      digitalWrite(disp100, latch_on);
      delay(dly);
      digitalWrite(disp100, latch_off);
      analogWrite(disp100dim, brightness);
    } else {
      analogWrite(disp100dim, off);
    }
  } else {
    // rumo verdadeiro em graus (isKMH=false)
    analogWrite(degreesLED, brightness);
    setBusNr(tUnit);
    digitalWrite(disp001, latch_on);
    delay(dly);
    digitalWrite(disp001, latch_off);
    if (tDeci > 0 || tCent > 0) {
      // define dezenas off se dezenas=0 (e também centenas=0)
      setBusNr(tDeci);
      digitalWrite(disp010, latch_on);
      delay(dly);
      digitalWrite(disp010, latch_off);
      analogWrite(disp010dim, brightness);
    } else {
      analogWrite(disp010dim, off);
    }
    if (tCent > 0) {
      // define centenas off se=0
      setBusNr(tCent);
      digitalWrite(disp100, latch_on);
      delay(dly);
      digitalWrite(disp100, latch_off);
      analogWrite(disp100dim, brightness);
    } else {
      analogWrite(disp100dim, off);
    }
  }
}

void checkButtons(){
  if (digitalRead(button_kt) == LOW) {
    if (isKMH == true) {
      isKMH=false;
    } else {
      isKMH=true;
    }
    delay(250);
  }
  if (digitalRead(button_more) == LOW) {
    if (brightness <= 240) {
      brightness=brightness+10;
    }
    analogWrite(disp001dim, brightness);
    analogWrite(disp010dim, brightness);
    analogWrite(disp100dim, brightness);
    delay(100);
  }
  if (digitalRead(button_less) == LOW) {
    if (brightness >= 20) {
      brightness=brightness-10;
    }
    analogWrite(disp001dim, brightness);
    analogWrite(disp010dim, brightness);
    analogWrite(disp100dim, brightness);
    delay(100);
  }
}

void setBusNr(int number) {
  // define barramento de 4 bits
  for (byte b=0; b<=3; b++) {
    if (numbers[number][b]==0) {
      if (b==0) {digitalWrite(bit_0, LOW);}
      if (b==1) {digitalWrite(bit_1, LOW);}
      if (b==2) {digitalWrite(bit_2, LOW);}
      if (b==3) {digitalWrite(bit_3, LOW);}
    } else {
      if (b==0) {digitalWrite(bit_0, HIGH);}
      if (b==1) {digitalWrite(bit_1, HIGH);}
      if (b==2) {digitalWrite(bit_2, HIGH);}
      if (b==3) {digitalWrite(bit_3, HIGH);}
    }
  }
}

// extrai dados de nmea inputString
bool nmeaExtractData() {
  int d=0;
  int s=0;
  int y=0;
  int z=0;
  float t=0;
  bool ret = false;
  // true se sentença nmea = $GNRMC e CHKSUM válido
  if ((inputString.substring(0,6) == "$GNRMC") && (inputString.substring(inputString.length()-4,inputString.length()-2) == nmea0183_checksum(inputString))) {
    y=0;
    for (s = 1; s < 11; s ++) {
      y=inputString.indexOf(",",y);
      switch (s) {
        case 1: //-----------------------tempo
          z=inputString.indexOf(",",y+1);
          if (z>(y+1)) {
            nm_time=inputString.substring(y+1,y+2+1)+":"+inputString.substring(y+1+2,y+4+1)+":"+inputString.substring(y+1+4,y+6+1);
          }
          y=z;
          break;
        case 2: //-----------------------validade
          z=inputString.indexOf(",",y+1);
          if (z>(y+1)) {
            nm_validity=inputString.substring(y+1,y+1+1);
          }
          y=z;
          break;
        case 3: //-----------------------latitude
          z=inputString.indexOf(",",y+1);
          if (z>(y+1)) {
            nm_latitude=inputString.substring(y+1,y+2+1)+"°"+inputString.substring(y+1+2,y+10+1)+"'";
          }
          y=z;
          break;
        case 4: //-----------------------norte/sul
          z=inputString.indexOf(",",y+1);
          if (z>(y+1)) {
            nm_latitude=nm_latitude + inputString.substring(y+1,y+1+1);
          }
          y=z;
          break;
        case 5: //-----------------------longitude
          z=inputString.indexOf(",",y+1);
          if (z>(y+1)) {
            nm_longitude=inputString.substring(y+1,y+3+1)+"°"+inputString.substring(y+1+3,y+11+1)+"'";
          }
          y=z;
          break;
        case 6: //-----------------------leste/oeste
          z=inputString.indexOf(",",y+1);
          if (z>(y+1)) {
            nm_longitude=nm_longitude + inputString.substring(y+1,y+1+1);
          }
          y=z;
          break;
        case 7: //-----------------------velocidade nós
          z=inputString.indexOf(",",y+1);
          if (z>(y+1)) {
            nmf_knots=inputString.substring(y+1,z).toFloat();
            t=roundOneDec(nmf_knots);
            nm_knots=String(t,1)+"kn";
            nmf_kmh=roundTwoDec(nmf_knots * 1.852);
            nmi_kmh=roundZeroDec(nmf_knots * 1.852);
          }
          y=z;
          break;
        case 8: //-----------------------curso verdadeiro
          z=inputString.indexOf(",",y+1);
          if (z>(y+1)) {
            nmf_truecourse=inputString.substring(y+1,z).toFloat();
            t=roundZeroDec(nmf_truecourse);
            nmi_truecourse=t;
            d=t;
            nm_truecourse=d;
          }
          y=z;
          break;
        case 9: //-----------------------data
          z=inputString.indexOf(",",y+1);
          if (z>(y+1)) {
            nm_date=inputString.substring(y+1,y+2+1)+"/"+inputString.substring(y+1+2,y+4+1)+"/20"+inputString.substring(y+1+4,y+6+1);
          }
          y=z;
          break;
        case 10: // statements n.u.
          break;
        default: // statements n.u.
          break;
      }
    }
    ret=true;
  }
  return ret;
}

/* SerialEvent ocorre sempre que novos dados chegam no serial RX hardware.
Esta rotina é executada entre cada vez que loop() roda, então usar delay dentro do loop
pode atrasar a resposta. Múltiplos bytes de dados podem estar disponíveis. */
void serialEvent() {
  while (Serial.available()) {
    char inChar = (char)Serial.read();
    inputString += inChar;
    // se o caractere recebido é newline, define flag para o loop principal
    // fazer algo a respeito
    if (inChar == '\n') {
      stringComplete = true;
    }
  }
}

// calcula checksum de sentença nmea
String nmea0183_checksum(String nmea_data) {
  int crc = 0;
  String chSumString = "";
  int i;
  // ignora o primeiro sinal $, checksum na sentença
  for (i = 1; i < (nmea_data.length()-5); i ++) {
    // remove o -5 se não houver "*" + cksum + cr + lf presentes
    crc ^= nmea_data[i];
  }
  chSumString = String(crc,HEX);
  if (chSumString.length()==1) {
    chSumString="0"+chSumString.substring(0,1);
  }
  chSumString.toUpperCase();
  return chSumString;
}

// arredonda zero decimais
float roundZeroDec(float f) {
  float y, d;
  y = f*1;
  d = y - (int)y;
  y = (float)(int)(f*1)/1;
  if (d >= 0.5) {
    y += 1;
  } else {
    if (d < -0.5) {
      y -= 1;
    }
  }
  return y;
}

// arredonda uma decimal
float roundOneDec(float f) {
  float y, d;
  y = f*10;
  d = y - (int)y;
  y = (float)(int)(f*10)/10;
  if (d >= 0.5) {
    y += 0.1;
  } else {
    if (d < -0.5) {
      y -= 0.1;
    }
  }
  return y;
}

// arredonda duas decimais
float roundTwoDec(float f) {
  float y, d;
  y = f*100;
  d = y - (int)y;
  y = (float)(int)(f*100)/100;
  if (d >= 0.5) {
    y += 0.01;
  } else {
    if (d < -0.5) {
      y -= 0.01;
    }
  }
  return y;
}

Esquemáticos

HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa car-hud_m5RwPQqpxH.fzz HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa HUD Automotivo: Velocidade e Bússola em Tempo Real no Para-brisa ard-carhud-v2_3N5756haNI.ino ard-carhud-v2-2_XhXHFJu0T8.ino

Processo de manufatura

  1. Revolucionando Mobilidade: Por Dentro do Motorcar Semi‑Autônomo da Arrow Electronics para Motoristas com Deficiência
  2. Carro Autônomo Donkey Car: IA TensorFlow MobileNetV2 para Coleta de Lixo
  3. Planejamento de Movimento em Tempo Real para Veículos Autônomos em Ambientes Urbanos: Estudo de Protótipo em Escala Reduzida
  4. Como 5G Está Transformando Carros Conectados: Velocidade, Segurança e Recursos Inteligentes
  5. Segurança em Primeiro Lugar: Como Europeus Veem os Carros Conectados do Futuro
  6. Seleção do Cabo de Motor Ideal para Inversores de Frequência (VSDs)
  7. Tornos de Velocidade Twister: Polimento e Desbaste Avançados com 50% Mais Potência e Controle Regenerativo
  8. Torno de Mesa Inclinada FBL-1233: Precisão, Velocidade e Versatilidade para Alto Volume e Curtas Séries
  9. Troca de Dados de Produto: O Principal Desafio para Fabricantes Automotivos
  10. Como Escolher o Turbo Certo para Seu Carro: Guia Prático