Conexion de displays en DCS con DCS-Bios y Arduino

[Angel]

Problema arreglado, borro mensaje

Tienes instalada la libreria UTFT? yo probaria a quitarla a ver que tal.

Que yo sepa, no. Solo he intalado las librerias que has puesto...

Ahora tengo vuelo, pero si quieres, mañana por la tarde/noche (a partir de las 18H) podemos quedar por Discord y lo vemos más despacio, a ver que me estoy saltando... Gracias!

Bueno pues Pablon ya tiene su pantalla funcionando!
Pongo aqui otra parte del codigo de ejemplo...

Code: Select all

//UHF COMM Radio
void onUhfFreqChange(char* newValue) {
for(int i = 0; i <6; i++){
    myGLCD.print("UHF Radio",0,135);
    printChar(5, i, newValue[i]);
  }
}
DcsBios::StringBuffer<6> uhfFreqBuffer(0x14e2, onUhfFreqChange);

Esto añade otra linea en la pantalla que muestra la frecuencia de la UHF COMM del Huey.
Esta linea myGLCD.print("UHF Radio",0,135); muestra el texto UHF Radio en las coordenadas 0,135
Esta otra printChar(5, i, newValue... indica que aparezca la frecuencia en la fila "5" (posicion antes calculada en una funcion)

Bueno pues hoy me han llegado otras pantallas...


Este tipo de pantallas se llaman "14 segment LED" no son faciles de encontrar.Es conveniente que vengan con un chip controlador i2C como estas( este modelo viene en dos colores ¿?, cosas raras del fabricante) , ojo que tambien se venden sueltas y despues tendriais que soldarle el controlador, es otra opcion desde luego pero mas laboriosa.

Para que podemos usar estas pantallas?
Pues como son alfanumericas sirven para mostrar mas informacion los 7-segment que solo sirven para numeros.
Por ejemplo este tipo de pantallas vendrian muy bien para el UFC del F-18 incluso hay modelos comerciales que las usan

Las letras estan bien es que esta volando un F14 (Top Gun joke)

Como se conectan?
Pues son bastante simples ya que gracias al chip integrado usan el protocolo I2C y solo tiene 5 conectores

SCL (clock) en Arduino Uno a pin A5
SDA (data) en Arduino Uno a pin A4
GND a ground
VCC a 5v (para alimentacion)
i2C a 5V (para señal)

y listo! (en otros Arduino consultar hoja de datos los puertos SCL y SDA cambian)

Ahora solo falta instalar las librerias para controlarlas, hay varias yo voy a usar la de Adafruit.Abrimos Arduino IDe en nuestro ordenador y vamos a..."programa/incluir librerias/administrar bibliotecas" buscamos "adafruit LED" y la instalamos con todas sus dependencias.

Ahora vamos a probarla, vamos a "ejemplos/Adafruit LED backpack library" y elegimos "qadalphanum_mini", lo enviamos a la placa y si todo esta bien conectado empezara a mostrar numeros y letras.

Y bueno hasta aqui he llegado en esta ocasion.

Como no tengo el F18 no he podido probar el codigo , no obstante seria algo parecido a los demas casos.Googlear algo en busca de codigo DCS Bios (hay por ahi un ejemplo del UFC con pantallas OLED), luego habria que modficar el codigo para adaptarlo a las funciones de la libreria Adafruit LED (las ordenes para imprimir en pantalla y nombres de funciones cambian en cada libreria), si sabeis algo de programacion o conoceis a alguien que sepa sera cosa facil.

Otra cosa, para un F-18 necesitareis 5 de estos.Gracias al bus i2C se pueden conectar en serie varios dispositivos todos a los mismos pines y luego se controlan mediante una señal de reloj.Cada pantalla debe de tener una direccion fisica unica.Esto tampoco lo he probado pero hay mucha informacion acerca de como conectar varios dispositivos i2C en foros de Arduino.

Y bueno esto es todo, espero que os sea util en vuestros proyectos!

Resumen de pantallas usadas en el hilo...



De izquierda a derecha...

1- 14 Segment panel (pag 4)
2- 7 segment panel (pag 1)
3- OLED 0,91" panel (128x64 px) (pag 2)
4- TFT 1,8" panel conexion i2C (sin tutorial pero seria como la de 2,8")
5- Liquid crystal 16x2 conexion i2C (pag 1)
6- TFT 2,8" conexion directa sobreplaca Arduino Uno (pag 2)

Buenas, refloto este hilo porque cuando estaba exportando radios en el Huey comente que algunas no exportan las frecuencias.

Por ejemplo el ADF no tiene una pantalla sino una rueda giratoria y DCS:Bios solo permite controlar servos para montar el tinglado giratorio de frecuencias y la aguja de la fuerza de señal, un follon vamos.

Asi que en principio no podriamos exportar el ADF del Huey a una pantalla externa pero como hay gente para todo he encontrado por casualidad un video de un tio que calculando la posicion de la rueda y el angulo de giro cuando la movemos exporta el valor de la radio asi como de fuerza de la señal a una pequeña pantalla OLED!



Un gran trabajo! lo unico que las pantallas oled estas son muy pequeñas aunque adaptando las librerias no deberia haber problema en usar otras.
Yo me he estado peleando estos dias con el codigo (yo de programar no entiendo casi nada) y he logrado exportar la frecuencia a un panel 7-segment que queda muy bien.


Eso si parece que tengo un pequeño error de posicion al principio de cada banda, quizas debido a la conversion de valores que hago.Si alguien quiere echarle un vistazo al codigo es este...

Code: Select all

// Incluimos librerias DcsBios y LedControl para 7-segment panel con chip Max7219

#define DCSBIOS_IRQ_SERIAL
#include <LedControl.h>
#include <DcsBios.h>

//Variables
unsigned int band, signal, rawFreq;
double freq;

//Configuramos puertos del 7-segment led
LedControl lc=LedControl(12,11,10,1);

/* Creamos funcion para configurar un 7-segment panel. Pines DIN(12) CLK(11) CS(10) (1)panel */
void refreshScreen() {
lc.clearDisplay(0); //clear the display 
lc.setChar(0,7,'-',false);
lc.setChar(0,6,int(freq/1000)%10,false);
lc.setChar(0,5,int(freq/100)%10,false);
lc.setChar(0,4,int(freq/10)%10,false);
lc.setChar(0,3,int(freq)%10,false);
lc.setChar(0,2,'-',false);
lc.setChar(0,1,'-',false);
lc.setChar(0,0,'-',false);
}

// operacion matematica (2386/10)%10 = 8,6 los decimales se desestiman (int)



// Aqui calcula los valores de las frecuencias en cada rango 
void calculateFreq() {
  float b;

  const float maxValue = 65535;
  switch (band) {
    case 0: { //190-400 kHz (~210kHz)
      //A = desired freq
      //B = freq based on adfCockpitFrequencyRaw
      //(A>200) A = B - ((B * -0.04408) + 18.31) //Creds Paul Marsh
      b = ((float(rawFreq) / maxValue) * 210) + 190;
      freq = b - ((b * -0.04408) + 18.31);
      break;
    }
    case 1: { //400-850 kHz (~450kHz)
      b = ((float(rawFreq) / maxValue) * 450) + 400;
      if (b < 451) {
        //A = B + ((B * -0.44837) + 177.08)
        //freq = b + ((b * -0.44837) + 181.58);
        freq = b + ((b * -0.44837) + 177.08);
      } else {
        //A = B + ((B * 0.11291) - 100.61)
        //freq = b + ((b * 0.11291) - 96.11);
        freq = b + ((b * 0.11291) - 100.61);
      }
      break;
    }
    case 2: { //850-1800 kHz (~950kHz)
      //A = B - ((B * -0.04532) + 91.54)
      b = ((float(rawFreq) / maxValue) * 950) + 850;
      freq = b - ((b * -0.04532) + 91.54);
      break;
    }
  }
  
}
//////////////////////////////////////////////////////////////////////////
/* Aqui configura un enconder para manejar el TUNE ,en la primera linea */
DcsBios::RotaryEncoder adfTune("ADF_TUNE", "-3200", "+3200", 3, 5);

//Si cambia la banda de frecuencias,recalcula y actualiza valor pantalla
void onAdfBandChange(unsigned int newValue) {
  band = newValue;
  calculateFreq();
  refreshScreen();
}
DcsBios::IntegerBuffer adfBandBuffer(0x14fc, 0x0003, 0, onAdfBandChange);


//Si cambia la posicion de la rueda de frecuencias, recalcula y actualiza valor pantalla
void onAdfFreqChange(unsigned int newValue) {
  rawFreq = newValue;
  calculateFreq();
  refreshScreen();
}
DcsBios::IntegerBuffer adfFreqBuffer(0x1426, 0xffff, 0, onAdfFreqChange);

///////////////////////////////////////////////////////////////////////////////////////
// SETUP
void setup() {
  DcsBios::setup();

  freq = 0;
  signal = 0;
  
// MAX7219 INITIALISATION
lc.shutdown(0,false); //turn on the display
lc.setIntensity(0,8);//set the brightness
lc.clearDisplay(0); //clear the display 

// codigo boot personalizado antes de conexion
lc.setChar(0,7,'-',false);
lc.setChar(0,6,'-',false);
lc.setChar(0,5,'E',false);
lc.setChar(0,4,'5',false);
lc.setChar(0,3,'A',false);
lc.setChar(0,2,'-',false);
lc.setChar(0,1,'-',false);
lc.setChar(0,0,'-',false);

}

// LOOP

  void loop() {
  DcsBios::loop();
}

He conseguido modificar el codigo y ahora las frecuencias se exportan a la pantalla de 7 segmentos y en la Oled se muestra una barra que muestra la fuerza de la señal (lo que haria la aguja en el instrumento real)



Dejo el codigo aqui...

Code: Select all

/* Arduino con dos pantallas , 7-segment protocolo SPI
y OLED protocolo i2C */

//Librerias
#define DCSBIOS_IRQ_SERIAL
#include <LedControl.h>
#include <DcsBios.h>
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// define pantallas
#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);
//7-Segment conexion DIN(12) CLK(11) CS(10)
LedControl lc=LedControl(12,11,10,1);

//Variables
unsigned int band, signal, rawFreq;
double freq;

// refresco pantalla 1 (7-segment) FRECUENCIA
void refreshScreen1() {
lc.clearDisplay(0); //clear the display 
lc.setChar(0,7,'-',false);
lc.setChar(0,6,int(freq/1000)%10,false);
lc.setChar(0,5,int(freq/100)%10,false);
lc.setChar(0,4,int(freq/10)%10,false);
lc.setChar(0,3,int(freq)%10,false);
lc.setChar(0,2,'-',false);
lc.setChar(0,1,'-',false);
lc.setChar(0,0,'-',false);
}


//refresco pantalla 2 (OLED) BARRA SEÑAL
void refreshScreen2() {
  display.clearDisplay();
  display.setTextSize(4);
  display.setTextColor(WHITE);
// dibuja linea recta de longitud proporcional a la fuerza de la señal
// display.fillrect(X,Y,ancho,alto,color)
  display.fillRect(2, 2, float(signal)/65535*(125-4), 25, WHITE);
  display.display();
}

///////////////////////////////////////////////////////////////////////////////////////
// Aqui calcula los valores de las frecuencias en cada rango 
void calculateFreq() {
  float b;

  const float maxValue = 65535;
  switch (band) {
    case 0: { //190-400 kHz (~210kHz)
      //A = desired freq
      //B = freq based on adfCockpitFrequencyRaw
      //(A>200) A = B - ((B * -0.04408) + 18.31) //Creds Paul Marsh
      b = ((float(rawFreq) / maxValue) * 210) + 190;
      freq = b - ((b * -0.04408) + 18.31);
      break;
    }
    case 1: { //400-850 kHz (~450kHz)
      b = ((float(rawFreq) / maxValue) * 450) + 400;
      if (b < 451) {
        //A = B + ((B * -0.44837) + 177.08)
        //freq = b + ((b * -0.44837) + 181.58);
        freq = b + ((b * -0.44837) + 177.08);
      } else {
        //A = B + ((B * 0.11291) - 100.61)
        //freq = b + ((b * 0.11291) - 96.11);
        freq = b + ((b * 0.11291) - 100.61);
      }
      break;
    }
    case 2: { //850-1800 kHz (~950kHz)
      //A = B - ((B * -0.04532) + 91.54)
      b = ((float(rawFreq) / maxValue) * 950) + 850;
      freq = b - ((b * -0.04532) + 91.54);
      break;
    }
  }
  
}
/////////////////////////////////////////////////////////////////////////////
//Si cambia la BANDA de frecuencias,recalcula y actualiza valor pantalla 1
void onAdfBandChange(unsigned int newValue) {
  band = newValue;
  calculateFreq();
  refreshScreen1();
}
DcsBios::IntegerBuffer adfBandBuffer(0x14fc, 0x0003, 0, onAdfBandChange);

//Si cambia la posicion de la rueda de FRECUENCIAS, recalcula y actualiza valor pantalla 1
void onAdfFreqChange(unsigned int newValue) {
  rawFreq = newValue;
  calculateFreq();
  refreshScreen1();
}
DcsBios::IntegerBuffer adfFreqBuffer(0x1426, 0xffff, 0, onAdfFreqChange);


// Si cambia la posicion de la aguja de SEÑAL, recalcula y actualiza pantalla
void onAdfSignalChange(unsigned int newValue) {
  signal = newValue;
  refreshScreen2();
}
DcsBios::IntegerBuffer adfSignalBuffer(0x1428, 0xffff, 0, onAdfSignalChange);


/////////////////////////////////////////////////////////////////////////////////

// SETUP
void setup() {
  DcsBios::setup();
  
  freq = 0;
  signal = 0;

// MAX7219 INITIALISATION
lc.shutdown(0,false); //turn on the display
lc.setIntensity(0,8);//set the brightness
lc.clearDisplay(0); //clear the display 

// codigo boot personalizado antes de conexion
lc.setChar(0,7,'-',false);
lc.setChar(0,6,'-',false);
lc.setChar(0,5,'E',false);
lc.setChar(0,4,'5',false);
lc.setChar(0,3,'A',false);
lc.setChar(0,2,'-',false);
lc.setChar(0,1,'-',false);
lc.setChar(0,0,'-',false);

display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3C (for the 128x32)
  display.display();
  display.clearDisplay();  
}

// LOOP

void loop() {
  DcsBios::loop();
}
  

Menudo crack estas hecho Angel...

Bueno..me he tirado una semanita intentando descifrar el codigo y sacando cosas.

Tambien hay que tener cuidado que la fuentecilla de la protoboard no da alimentado las dos pantallas.
Tengo que mirar cuanta potencia puede suministrar el Arduino a ver cuantas pantallas o leds soporta, sino hay pequeñas fuentes de 5v en aliexpress por poco dinero.

A ver que sale de aqui

Bueno , pues una vuelta de tuerca mas...

El ADF del Hue solo necesita 4 digitos asi que el display de 8 queda descartado por incomodo.

Asi que he encontrado estos display de 4 digitos a buen precio.



Eso si , usan otro protocolo de comunicacion (TM) con solo dos pines de conexion (CLK y DIO) y necesitan otra libreria distinta para Arduino, yo use TM1637 by Avishay Orpaz (disponible en el propio gestor de Arduino)

Aqui pongo el codigo de la nueva opcion....

Code: Select all

#include <Arduino.h>
#include <TM1637Display.h>
#define DCSBIOS_IRQ_SERIAL
#include <DcsBios.h>

// Module connection pins (Digital Pins)
#define CLK 2
#define DIO 3

//Variables
unsigned int band, signal, rawFreq;
double freq;

#define TEST_DELAY   2000

// Configuramos display
TM1637Display display(CLK, DIO);



// Funcion actualizar frecuencia en pantalla
void refreshScreen() {
display.showNumberDec(freq,false);
}

// Aqui calcula los valores de las frecuencias en cada rango 
void calculateFreq() {
  float b;

  const float maxValue = 65535;
  switch (band) {
    case 0: { //190-400 kHz (~210kHz)
      //A = desired freq
      //B = freq based on adfCockpitFrequencyRaw
      //(A>200) A = B - ((B * -0.04408) + 18.31) //Creds Paul Marsh
      b = ((float(rawFreq) / maxValue) * 210) + 190;
      freq = b - ((b * -0.04408) + 18.31);
      break;
    }
    case 1: { //400-850 kHz (~450kHz)
      b = ((float(rawFreq) / maxValue) * 450) + 400;
      if (b < 451) {
        //A = B + ((B * -0.44837) + 177.08)
        //freq = b + ((b * -0.44837) + 181.58);
        freq = b + ((b * -0.44837) + 177.08);
      } else {
        //A = B + ((B * 0.11291) - 100.61)
        //freq = b + ((b * 0.11291) - 96.11);
        freq = b + ((b * 0.11291) - 100.61);
      }
      break;
    }
    case 2: { //850-1800 kHz (~950kHz)
      //A = B - ((B * -0.04532) + 91.54)
      b = ((float(rawFreq) / maxValue) * 950) + 850;
      freq = b - ((b * -0.04532) + 91.54);
      break;
    }
  }
  
}

//Si cambia la banda de frecuencias,recalcula y actualiza valor pantalla
void onAdfBandChange(unsigned int newValue) {
  band = newValue;
  calculateFreq();
  refreshScreen();
}
DcsBios::IntegerBuffer adfBandBuffer(0x14fc, 0x0003, 0, onAdfBandChange);


//Si cambia la posicion de la rueda de frecuencias, recalcula y actualiza valor pantalla
void onAdfFreqChange(unsigned int newValue) {
  rawFreq = newValue;
  calculateFreq();
  refreshScreen();
}
DcsBios::IntegerBuffer adfFreqBuffer(0x1426, 0xffff, 0, onAdfFreqChange);

///////////////////////////////////////////////////////////////////////
// SETUP

void setup() {
  // Clear the display:
  display.clear();
  delay(1000);

DcsBios::setup();
  
  freq = 0;
  signal = 0;

}

/////////////////////////////////////////
// LOOP

  void loop() {
  DcsBios::loop();
// Set the brightness to 5 (0=dimmest 7=brightest)
// Si no configuras brillo no funciona?
  display.setBrightness(5);

  
}