Módulo Piloto Automático

Leandro Souza escreveu:Rapaz, que show!!! Enfim encontrei alguém que saiba programar arduino... rsrs, estou com meu projeto de MCP parado, por falta de conhecimento... Abraços!!!

Código:

#include <MemoryFree.h>
#include <Wire.h>

//Declaracao pinos
/*ANALOGICOS*/
const int PIN_SELA = 0;
const int PIN_SELB = 1;

/*DIGITAIS*/
//LCD
const int PIN_SCE   = 3; //lcd S CE       (azul)    
const int PIN_RESET = 7;  //lcd Reset     (cinza)  
const int PIN_DC    = 5;  //lcd DC        (roxo)    
const int PIN_SDIN  = 6;  //lcd DIN       (verde)  
const int PIN_SCLK  = 8;  //lcd CLK       (marrom)    
const int PIN_BL    = 9;  //lcd backlight (laranja)
                          //lcd VCC       (vermelho)
                          //lcd GND       (amarelo)

//ENCODER ROTATIVO
const int PIN_ROTA = 12; //encoder rotativo A (amarelo)
const int PIN_ROTB = 11; //encoder rotativo B (vermelho)
                         //encoder rotativo GND (laranja)

//Variaveis sistema
unsigned int rPOS;
int inAvionics=1;
int tpAvionics=0;

//Variavel com serial
int CodeIn=0;
char c;
char commandBuffer[135];
int commandBufferSize=0;
byte valLeds=B00000000;
boolean enviaLed=false;
int fRam=0;
unsigned long currentTimeRAM;
unsigned long loopTimeEncRAM;

//Variavel tipo selecao
int tpSel=5;
int tpSelF=0;
int valA=0;
int valB=0;

//Variaveis piloto automatico
long HDG=0;
long ALT=0;
long VSP=0;
long tmpHDG=0;
long tmpALT=0;
long tmpVSP=0;

//Variaveis indicador piloto automatico
int indAP=0;
int indHDG=0;
int indNAV=0;
int indAPR=0;
int indREV=0;
int indALT=0;
int tmpIndAP=0;
int tmpIndHDG=0;
int tmpIndNAV=0;
int tmpIndAPR=0;
int tmpIndREV=0;
int tmpIndALT=0;

//Variaveis encoder rotativo
String comando;
unsigned long currentTimeEnc;
unsigned long loopTimeEnc;
unsigned char encoder_A;
unsigned char encoder_B;
unsigned char encoder_A_prev=0;
int fadeAmount=1;
int tst=1;

//Variaveis botões
byte lerBts;
int btPress=0;

//Variaveis LCD
#define LCD_C     LOW
#define LCD_D     HIGH
#define LCD_CMD   0

#define LCD_X     84
#define LCD_Y     48

int a = 0;

static const byte ASCII[][5] =
{
 {0x00, 0x00, 0x00, 0x00, 0x00} // 20  
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <
,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =
,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e >
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c ¥
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ←
,{0x00, 0x06, 0x09, 0x09, 0x06} // 7f →
};

void setup() {
  Serial.begin(115200);  
  
  LcdInitialise();
  LcdClear();
 
  drawLine();
  delay(1000);
  gotoXY(13,1);
  LcdString ("Starting");
  delay(200);
  gotoXY(26,2);
  LcdString ("Auto");
  delay(200);
  gotoXY(23,3);
  LcdString("Pilot");    
  delay(200);
  gotoXY(5,4);
  LcdString("Bonino Sis");    

  //Iniciar Pinos
  pinMode(PIN_ROTA, INPUT);
  //digitalWrite(PIN_ROTA, HIGH);
  pinMode(PIN_ROTB, INPUT);
  //digitalWrite(PIN_ROTB, HIGH);
  
  Wire.begin();
  acendeLed(B00000000);
  delay(500);
  acendeLed(B01110111);

  //Iniciar variaveis
  currentTimeEnc=millis();
  loopTimeEnc=currentTimeEnc;
  currentTimeRAM=millis();
  loopTimeEncRAM=currentTimeRAM;
  
  LcdClear();

  //Montar painel
  gotoXY(6,1);
  LcdString("HDG");
  gotoXY(28,1);
  LcdString(":");
  gotoXY(6,2);
  LcdString("ALT");
  gotoXY(28,2);
  LcdString(":");
  gotoXY(6,3);
  LcdString("VS");
  gotoXY(28,3);
  LcdString(":");

  escreveHDG();
  escreveAlt();
  escreveVS();
  delay(100);
  acendeLed(B00000000);
  delay(100);
  acendeLed(B01110111);
  delay(100);
  acendeLed(B00000000);
  delay(100);
  acendeLed(B01110111);
  delay(100);
  acendeLed(B00000000);
}

void loop() {
  estadoSistema();
  
  if (inAvionics==1) {  
    lerSeletor();
    pressBotao();
    lerEncoder();
  }
  
  if (Serial.available()) {
    lerSerial();
  }
  executaComandos();
  if (inAvionics==1) {
    estadosLeds();
    valoresAP();    
  }
  
  currentTimeRAM=millis();
  if (currentTimeRAM>=loopTimeEncRAM+10000) {
    loopTimeEncRAM=currentTimeRAM;
    fRam=freeRam();
  }
}

void estadoSistema() {
  if (inAvionics!=tpAvionics) {
    inAvionics=tpAvionics;
    
    if (inAvionics==0) {
      //Desligar sistema
      analogWrite(PIN_BL, 20);
      LcdClear();
      acendeLed(B00000000);
      HDG=0;
      ALT=0;
      VSP=0;
      tpSel=5;
      gotoXY(13,1);
      LcdString ("Avionics");
      gotoXY(33,2);
      LcdString ("OFF");      
    } else {
      //Ligar sistema
      analogWrite(PIN_BL, 100);
      //Montar painel
      LcdClear();
      gotoXY(6,1);
      LcdString("HDG");
      gotoXY(28,1);
      LcdString(":");
      gotoXY(6,2);
      LcdString("ALT");
      gotoXY(28,2);
      LcdString(":");
      gotoXY(6,3);
      LcdString("VS");
      gotoXY(28,3);
      LcdString(":");      
      
      escreveHDG();
      escreveAlt();
      escreveVS();
      lerSeletor();
      valoresAP();
    }
  }
}

unsigned int getPos(long vVal) {  
  if (vVal>=10000 || (vVal<=-1000)) {
    rPOS=38;
  } else if (vVal>=1000 || (vVal>-1000 && vVal<=-100)) {
    rPOS=45;
  } else if (vVal>=100 || (vVal>-100 && vVal<=-10)) {
    rPOS=52;  
  } else if (vVal>=10 || (vVal>-10 && vVal<=-1)) {
    rPOS=59;
  } else if (vVal<10) {
    rPOS=66;
  }
  return rPOS;
}

void escreveHDG() {
  LcdClearSeg(1);
  gotoXY(getPos(HDG),1);
  
  char cstr[4];
  String(HDG).toCharArray(cstr,4);
  
  LcdString(cstr);
}

void escreveAlt() {
  LcdClearSeg(2);
  gotoXY(getPos(ALT),2);
  
  char cstr[6];
  String(ALT).toCharArray(cstr,6);
  
  LcdString(cstr);
}

void escreveVS() {
  LcdClearSeg(3);
  gotoXY(getPos(VSP),3);
  
  char cstr[6];
  String(VSP).toCharArray(cstr,6);
  
  LcdString(cstr);
}

void valoresAP() {
  //HDG
  if (HDG!=tmpHDG) {
    HDG=tmpHDG;
    escreveHDG();
  }
  //ALT
  if (ALT!=tmpALT) {
    ALT=tmpALT;
    escreveAlt();
  }
  //V SPEED
  if (VSP!=tmpVSP) {
    VSP=tmpVSP;
    escreveVS();
  }

}

void acendeLed(byte inLed) {
  Wire.beginTransmission(36);
  Wire.write(inLed);
  Wire.endTransmission();
}

void estadosLeds() {
  if (indAP!=tmpIndAP
        || indHDG!=tmpIndHDG
        || indNAV!=tmpIndNAV
        || indAPR!=tmpIndAPR
        || indREV!=tmpIndREV
        || indALT!=tmpIndALT) {
    indAP=tmpIndAP;
    indHDG=tmpIndHDG;
    indNAV=tmpIndNAV;
    indAPR=tmpIndAPR;
    indREV=tmpIndREV;
    indALT=tmpIndALT;
    
    enviaLed=true;
  }

  if (enviaLed) {
    valLeds=B00000000;
    
    //AP LED 1
    if (indAP==1) {
      valLeds=valLeds+B00000001;
    }
    //HDG LED 2
    if (indHDG==1) {
      valLeds=valLeds+B00000010;
    }
    //NAV LED 3
    if (indNAV==1) {
      valLeds=valLeds+B00000100;
    }
    //APR LED 5
    if (indAPR==1) {
      valLeds=valLeds+B00010000;
    }
    //REV LED 6
    if (indREV==1) {
      valLeds=valLeds+B00100000;
    }
    //ALT LED 7
    if (indALT==1) {
      valLeds=valLeds+B01000000;
    }

    enviaLed=false;
    acendeLed(valLeds);
  }
}

int freeRam () {
  extern int __heap_start, *__brkval;
  int v;
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}

Código:

void pressBotao() {
  Wire.requestFrom(32,1);
  
  if (Wire.available()) {
    lerBts = Wire.read();
    if (lerBts<255) {
      if (btPress==0) {
        switch (lerBts) {
          case 254: //AP - bt1
            btPress=1;
            Serial.println("B01");
            break;
          case 253: //HDG - bt2
            btPress=1;
            Serial.println("B04");
            break;
          case 251: //NAV - bt3
            btPress=1;
            Serial.println("B10");
            break;          
          case 247: //APR - bt4
            btPress=1;
            Serial.println("B08");
            break;
          case 239: //REV - bt5
            btPress=1;
            Serial.println("B09");
            break;
          case 223: //ALT - bt6
            btPress=1;
            Serial.println("B05");
            break;          
        }
      }
    } else {
      btPress=0;
    }
  } else {
    btPress=0;
  }
}

void lerEncoder() {
  comando="";
  currentTimeEnc = millis();
  if(currentTimeEnc >= (loopTimeEnc + 5)){
    // 5ms since last check of encoder = 200Hz  
    encoder_A = digitalRead(PIN_ROTA);    // Read encoder pins
    encoder_B = digitalRead(PIN_ROTB);  
    if((!encoder_A) && (encoder_A_prev)){
      
      
      // A has gone from high to low
      if(encoder_B) {
        switch (tpSel) {
          case 0:
            //diminuir HDG
            comando="A58";  
            break;
          case 1:
            //diminuir ALT
            comando="B12";
            break;
          case 2:
            //diminuir VS
            comando="B14";
            break;
        }        
      }  
      else {
        switch (tpSel) {
          case 0:
            //aumentar HDG
            comando="A57";  
            break;
          case 1:
            //aumentar ALT
            comando="B11";
            break;
          case 2:
            //aumentar VS
            comando="B13";
            break;
        }              
      }
      if (comando!="") {
        Serial.println(comando);
      }
    }  
    encoder_A_prev = encoder_A;     // Store value of A for next time    
        
    loopTimeEnc = currentTimeEnc;  // Updates loopTime
  }
  // Other processing can be done here
}

void lerSeletor() {
/*Posições
0-HDG
1-ALT
2-V Speed*/
  valA=analogRead(PIN_SELA);
  valB=analogRead(PIN_SELB);
  tpSelF=0;
  
  if (valA!=0 && valB==0) {tpSelF=0;}
  else if (valA!=0 && valB!=0) {tpSelF=1;}
  else if (valA==0 && valB!=0) {tpSelF=2;}
  
  if (tpSelF!=tpSel) {
    int lin=tpSel+1;
    gotoXY(0,lin);
    LcdString(" ");
    lin=tpSelF+1;
    gotoXY(0,lin);
    LcdString(">");
    tpSel=tpSelF;
  }
}

Código:

void LcdCharacter(char character)
{
  LcdWrite(LCD_D, 0x00);
  for (int index = 0; index < 5; index++)
  {
    LcdWrite(LCD_D, ASCII[character - 0x20][index]);
  }
  LcdWrite(LCD_D, 0x00);
}

void LcdClear(void)
{
  for (int index = 0; index < LCD_X * LCD_Y / 8; index++)
  {
    LcdWrite(LCD_D, 0x00);
  }
}

void LcdClearSeg(int lin) {
  gotoXY(38,lin);
  LcdString("      ");
}

void LcdInitialise(void)
{
  pinMode(PIN_SCE,   OUTPUT);
  pinMode(PIN_RESET, OUTPUT);
  pinMode(PIN_DC,    OUTPUT);
  pinMode(PIN_SDIN,  OUTPUT);
  pinMode(PIN_SCLK,  OUTPUT);

  digitalWrite(PIN_RESET, LOW);
 // delay(1);
  digitalWrite(PIN_RESET, HIGH);

  LcdWrite(LCD_CMD, 0x21 );  // LCD Extended Commands.
  LcdWrite(LCD_CMD, 0xAA);  // Set LCD Vop (Contrast). 0xB1 - 0xAA
  LcdWrite(LCD_CMD, 0x04 );  // Set Temp coefficent. //0x04
  LcdWrite(LCD_CMD, 0x14 );  // LCD bias mode 1:48. //0x13
  LcdWrite(LCD_CMD, 0x0d );  // LCD in normal mode 0x0C. 0x0d for inverse
  LcdWrite(LCD_C, 0x20);
  LcdWrite(LCD_C, 0x0C);
  
  delay(500);
  //Backlight;
  pinMode(PIN_BL,OUTPUT);
  analogWrite(PIN_BL, 100);  
}

void LcdString(char *characters)
{
  while (*characters)
  {
    LcdCharacter(*characters++);
  }
}

void LcdWrite(byte dc, byte data)
{
  digitalWrite(PIN_DC, dc);
  digitalWrite(PIN_SCE, LOW);
  shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data);
  digitalWrite(PIN_SCE, HIGH);
}

// gotoXY routine to position cursor
// x - range: 0 to 84
// y - range: 0 to 5

void gotoXY(int x, int y)
{
  LcdWrite( 0, 0x80 | x);  // Column.
  LcdWrite( 0, 0x40 | y);  // Row.  
}

void drawLine(void)
{
  unsigned char  j;  
   for(j=0; j<84; j++) // top
   {
          gotoXY (j,0);
     LcdWrite (1,0x01);
  }    
  for(j=0; j<84; j++) //Bottom
   {
          gotoXY (j,5);
     LcdWrite (1,0x80);
  }    

  for(j=0; j<6; j++) // Right
   {
          gotoXY (83,j);
     LcdWrite (1,0xff);
  }    
   for(j=0; j<6; j++) // Left
   {
          gotoXY (0,j);
     LcdWrite (1,0xff);
  }

}

Código:

char getChar()// Get a character from the serial buffer
{
 while(Serial.available() == 0);// wait for data
 return((char)Serial.read());// Thanks Doug
}//end of getchar

void lerSerial() {
 int i=0;
 while (i<128) {
   while(!Serial.available());
   c=Serial.read();
   if (c=='\n' || c=='\r') {break;};
   commandBuffer[i]=c;
   i++;
 }
 commandBufferSize=i;
}

void executaComandos() {
 char cstr[6];
 int i=0;
 int tipo=0;
 String valCom;
 while (i<=commandBufferSize) {
   tipo=0;
   c=commandBuffer[i];
   //gotoXY(6,4);
   //LcdCharacter(c);
   
   //VALORES;
   if (c=='=') {
     tipo=1;
   } else if (c=='<') {
     tipo=2;
   }
   
   //VALORES AP
   if (tipo==1) {
     i++;
     c=commandBuffer[i];
     switch (c) {
       case 'a': // AP active indicator
         valCom = "";
         i++;
         valCom += commandBuffer[i];
         if (valCom=="1") {tmpIndAP=1;} else {tmpIndAP=0;}
         break;
       case 'j': // AP HDG active indicator
         valCom = "";
         i++;
         valCom += commandBuffer[i];
         if (valCom=="1") {tmpIndHDG=1;} else {tmpIndHDG=0;}
         break;
       case 'o': // AP NAV active indicator
         valCom = "";
         i++;
         valCom += commandBuffer[i];
         if (valCom=="1") {tmpIndNAV=1;} else {tmpIndNAV=0;}
         break;
       case 'm': // AP APR active indicator
         valCom = "";
         i++;
         valCom += commandBuffer[i];
         if (valCom=="1") {tmpIndAPR=1;} else {tmpIndAPR=0;}
         break;
       case 'n': // AP REV active indicator
         valCom = "";
         i++;
         valCom += commandBuffer[i];
         if (valCom=="1") {tmpIndREV=1;} else {tmpIndREV=0;}
         break;
       case 'k': // AP ALT active indicator
         valCom = "";
         i++;
         valCom += commandBuffer[i];
         if (valCom=="1") {tmpIndALT=1;} else {tmpIndALT=0;}
         break;

       case 'd': // AP HDG set
         valCom = "";
         i++;
         valCom += commandBuffer[i];// get 1 charactor
         i++;
         valCom += commandBuffer[i];// get 2 charactor
         i++;
         valCom += commandBuffer[i];// get 3 charactor
     
         //char array to int      
         valCom.toCharArray(cstr,4);
         tmpHDG = atoi(cstr);
         break;
       case 'b': // AP ALT set
         valCom = "";
         i++;
         valCom += commandBuffer[i];// get 1 charactor
         i++;
         valCom += commandBuffer[i];// get 2 charactor
         i++;
         valCom += commandBuffer[i];// get 3 charactor
         i++;
         valCom += commandBuffer[i];// get 4 charactor
         i++;
         valCom += commandBuffer[i];// get 5 charactor
     
         //char array to int
         valCom.toCharArray(cstr,6);
         tmpALT = atoi(cstr);
         break;
       case 'c': // AP V SPEED set
         valCom = "";
         i++;
         valCom += commandBuffer[i];// get 1 charactor
         i++;
         valCom += commandBuffer[i];// get 2 charactor
         i++;
         valCom += commandBuffer[i];// get 3 charactor
         i++;
         valCom += commandBuffer[i];// get 4 charactor
         i++;
         valCom += commandBuffer[i];// get 5 charactor
   
         //char array to int
         valCom.toCharArray(cstr,6);
         tmpVSP = atoi(cstr);
         break;    
     }
   }
   
   //SISTEMA;
   if (tipo==2) {
     i++;
     c=commandBuffer[i];
     switch (c) {
       case 'g': // Avionics indicador
         valCom = "";
         i++;
         valCom += commandBuffer[i];
         if (valCom=="1") {tpAvionics=1;} else {tpAvionics=0;}
         break;
     }
   }
   
   i++;
 }
}

Manoel Carvalho escreveu:Parabéns Ricardo, tá ficando um show!
Você utilizou led´s de alto brilho? Se sim, pode ser que, dependendo da posição que ficará o MCP, estas luzes podem te incomodar no escuro (digo isso por experiência própria). Teste isto antes de concluir o projeto e veja se led´s convencionais não dão um efeito melhor.

ricardopaulob escreveu:Salve pessoal,

Primeiramente gostaria de agradecer muito ao pessoal do fórum. Sempre fui fã de flight simulator, mas nunca tive dinheiro sobrando para os cockpits caros que vendem por aí. E navegando aqui no fórum descobri várias possibilidades.

Venho aqui mostrar o módulo de piloto automático que fiz usando o arduino uno e alguns componentes que tinha aqui em casa (sou nerd mesmo, já brinco com arduino tem um tempo).

Materiais:
-Arduino Uno
-2 x PCF8574P (expansor de portas para botões e leds indicadores)
-LCD Nokia 5110
-6 x push button (comandos piloto automático)
-6 x leds (indicadores do piloto automático)
-chave 3 posições (selecionar modo de operação - HDG, ALT ou VS)
-encoder rotativo (selecionar valor de acordo com o modo)
-protoboard
-resistores diversos (10k, 330ohms, 150ohms, 4k7, etc...)

Seguem as fotos e um vídeo:

Aproveitei uma caixa de som queimada para o case


Montando o LCD e os botões seletores


Pouco fio ainda


Tudo ligado e funcionando


Agora tem fio..  


Ufa, tudo pronto, inclusive as marcações toscas...



Passei o feriado todo quebrando a cabeça com isso, mas valeu a pena.

To vendo que o vício vai pegar. Tenho um arduino mega aqui e vou partir para a construção do throtle quadrant, com trims, flaps e trem de pouso (será genérico, mas baseado no Baron 58), falta comprar alguns potenciômetros e compensado para a estrutura.

Obrigado pessoal,

Ricardo

Ricardo de Azevedo escreveu:
Será que esse seu projeto funcionaria com digital tube ??... talvez ficaria até mais bonito não sei...estou estudando agora arduino e ainda não sou capaz de fazer um projeto de MCP

Flavio Ribeiro escreveu:

Ricardo de Azevedo escreveu:
Será que esse seu projeto funcionaria com digital tube ??... talvez ficaria até mais bonito não sei...estou estudando agora arduino e ainda não sou capaz de fazer um projeto de MCP

Oi,
O que é digital tube?

Um abraço!