Flugsimulation

Räumungsverkauf

Aus Platzgründen muss ich mich leider von einigen Teilen trennen. Größtenteils aus meinem Bestand der Flugsimulation.
Ein paar Teile sind schon bei Kleinanzeigen eingestellt aber es kommen noch einige diese Woche dazu.

Eine kleine Übersicht:
B737 MCP – weiße Anzeigen – beleuchtbar
B737 EFIS Panel
Logitech Saitek Pro Flight Yoke im 737 Style mit Zusatzschalter
B737 Nose wheel mit Schalter
B737 Autobrakes
B737 Landing gear
B737 Flaps gauge
B737 Brakes pressure
B737 Yaw damper
…..
Jede Menge Platinen aus meinem FSBUS-System.
Außerdem kommt noch das komplette selbstgebaute Cockpit mit 2 x 32 Zoll Monitore und 2 x Monitore für die Anzeigen dazu.

Auch hab ich noch ein paar Tachos die ich ja bereits hier gezeigt habe. Mazda RX8 sowie BMW und Golftachos.

Also einfach mal täglich in meine Kleinanzeigenliste reinschauen…..

https://www.ebay-kleinanzeigen.de/s-bestandsliste.html?userId=28222553

 

Platinen RS485

Arduino mit RS485

Für mein neues Projekt, die A-10C II, brauche ich neue Kontrollerkarten. Nach einigen Recherchen fiel meine Wahl auf Arduino Nano die mit einem Mega und dem RS485 den kleinsten Verkabelungsaufwand ausmachen. Hier die Infos aus dem DCS-Forum

Über einem Arduino Mega, der mit USB am PC angeschlossen ist, werden alle Nanos direkt mit RJ45 verkabelt. 

Also hab rasch die Platine für den Master und den Client mit Sprint-Layout 6.0 geplant und bei den Chinesen erstellen lassen. 
5 Master (Mindestabnahme) und 30 Clients haben mit Versand, bei erstaunlich guter Qualität, keine 30€ gekostet)

Ein erster Test mit DCS – A-10C II und meinen Karten war schon mal vielversprechend. In den späteren Berichten kommen mehr Infos.

737MCP mit neuen „weißen“ Anzeigen und Filter

7-Segmentanzeigen in weiß, mit und 1 bzw. 2fach Filter  

 

Displayset – einzelne 7Segmentanzeigen

Display-Set by sim-pc.de V.1.03 (für einzelne 7Segemntanzeigen)

  • mini Packs für 3-6 Anzeigen, bei Bedarf auch kürzbar 
  • kompatibel mit Display-Card
  • kompatibel mit den Platinen von FSBUS, Rob

     
 

 

 

 

 

 
     

 

 

 

 

 

 

     

 

 

 

 

 

 

 

Controllercard 7Segment – Displaykarte

Weil mein alter Flugsimulator mit FSBUS läuft und dieser ja leider nicht weiterentwickelt wird, war ich auf der Suche nach Ersatz und da ich meine fertigen Panels weiter benutzen wollte, musste eine Lösung her mit der ich ohne viel Aufwand meine Karten weiter benutzen kann.

Ich hab mich jetzt für das Mobiflightsystem entschieden welches für die 7Segmentanzeigen den MAX7219-Chip nimmt.
Die Karte kann selbstverständlich auch mit Anderen Systemen genutzt werden die 7Segmentanzeigen oder LED’s benutzen 

Damit ich meine alten Anzeigen weiterhin benutzen kann, habe ich das Design der Platinen bewusst so aufgebaut das ich alle meine Kabel direkt weiter benutzen kann.

Displaycard by sim-pc.de V.1.03 (einzelne 7Segemntanzeigen)

  • Anschlüsse für 8  Anzeigen (bis 8 Stück pro Port) oder bis zu 64 LEDs, auch einzeln ansteuerbar
  • für Common Cathode (gemeinsame Kathode)
  • Ansteuerung über SPI Interface (bis 10 Mhz) mit nur 3 Leitungen (plus +5V und GND)
  • Helligkeitskontrolle softwaretechnisch über das Interface
  • externe Stromversorgung 5v
  • mehrere Platinen hintereinander schaltbar / Stapelbar(bei Mobiflight max. 4 pro Arduino Mega2560)
  • Arduino Mega stapelbar
  • visuelle Kartenanzeige (1 bis 4 per Stiftleiste)
  • kompatibel mit Sim-pc Diplay-Set (einzelne Platinen für 7Segmentanzeigen)
  • kompatibel mit den Platinen von FSBUS, Rob

     
 

 

 

 

 

 
     

 

 

 

 

 

 

     

 

 

 

 

 

 

 

6DOF – Stewart platform mit FSX –

Hier mal ein erster Test einer 6DOF Stewart Plattform auf Servo und arduino-basis in Verbindung mit SIMTOOLS.

/*
//********************************************************************************************
// RC Model Servo
// Original code By EAOROBBIE (Robert Lindsay)
// Completely mangled by aarondc
// For free use for Sim Tool Motion Software
// Changed by SIM-PC.de for 6DOF
//********************************************************************************************
#include 
//#define DEBUG 1               // comment out this line to remove debuggin Serial.print lines
const int kActuatorCount = 6;   // how many Actuators we are handling

// the letters ("names") sent from Sim Tools to identify each actuator
// NB: the order of the letters here determines the order of the remaining constants kPins and kActuatorScale
const char kActuatorName[kActuatorCount] = { 'A', 'B', 'C', 'D', 'E', 'F' };
const int kPins[kActuatorCount] = {2, 3, 4, 5, 6, 7};           
const int kActuatorScale[kActuatorCount][6] = { { 0, 179 } ,    // 1 Actuator scaling
                                                { 0, 179 } ,    // 2 Actuator scaling
                                                { 0, 179 } ,    // 3 Actuator scaling
                                                { 0, 179 } ,    // 4 Actuator scaling
                                                { 0, 179 } ,    // 5 Actuator scaling
                                                { 0, 179 }      // 6 Actuator scaling
                                               };  
const char kEOL = '~';                              // End of Line - the delimiter for our acutator values 
const int kMaxCharCount = 3;                        // some insurance...
Servo actuatorSet[kActuatorCount];                  // our array of Actuators
int actuatorPosition[kActuatorCount] = {90,90,90,98,90,90};    // current Actuator positions, initialised to 90
int currentActuator;                                // keep track of the current Actuator being read in from serial port
int valueCharCount = 0;                             // how many value characters have we read (must be less than kMaxCharCount!!

// set up some states for our state machine
// psReadActuator = next character from serial port tells us the Actuator
// psReadValue = next 3 characters from serial port tells us the value
enum TPortState { psReadActuator, psReadValue };   
TPortState currentState = psReadActuator;

void setup()
{ 
    // attach the Actuators to the pins
    for (int i = 0; i < kActuatorCount; i++) 
        actuatorSet[i].attach(kPins[i]);
    
    // initialise actuator position
    for (int i = 0; i < kActuatorCount; i++) updateActuator(i); Serial.begin(38400); // opens serial port at a baud rate of 9600 } void loop() { } // this code only runs when we have serial data available. ie (Serial.available() > 0).
void serialEvent() {
    char tmpChar;
    int tmpValue;

    while (Serial.available()) {
        // if we're waiting for a Actuator name, grab it here
        if (currentState == psReadActuator) {
            tmpChar = Serial.read();
            // look for our actuator in the array of actuator names we set up 
#ifdef DEBUG            
Serial.print("read in ");            
Serial.println(tmpChar);            
#endif
            for (int i = 0; i < kActuatorCount; i++) {
                if (tmpChar == kActuatorName[i]) {
#ifdef DEBUG            
Serial.print("which is actuator ");            
Serial.println(i);            
#endif
                    currentActuator = i;                        // remember which actuator we found
                    currentState = psReadValue;                 // start looking for the Actuator position 
                    actuatorPosition[currentActuator] = 0;      // initialise the new position
                    valueCharCount = 0;                         // initialise number of value chars read in 
                    break;
                }
            }
        }
        
        // if we're ready to read in the current Actuator's position data
        if (currentState == psReadValue) {
            while ((valueCharCount < kMaxCharCount) && Serial.available()) {
                tmpValue = Serial.read();
                if (tmpValue != kEOL) {
                    tmpValue = tmpValue - 48;
                    if ((tmpValue < 0) || (tmpValue > 9)) tmpValue = 0;
                    actuatorPosition[currentActuator] = actuatorPosition[currentActuator] * 10 + tmpValue;
                    valueCharCount++;
                }
                else break;
            }
            
            // if we've read the value delimiter, update the Actuator and start looking for the next Actuator name
            if (tmpValue == kEOL || valueCharCount == kMaxCharCount) {
#ifdef DEBUG            
Serial.print("read in ");            
Serial.println(actuatorPosition[currentActuator]);            
#endif
                // scale the new position so the value is between 0 and 179
                actuatorPosition[currentActuator] = map(actuatorPosition[currentActuator], 0, 255, kActuatorScale[currentActuator][0], kActuatorScale[currentActuator][1]);
#ifdef DEBUG            
Serial.print("scaled to ");            
Serial.println(actuatorPosition[currentActuator]);            
#endif
                updateActuator(currentActuator);
                currentState = psReadActuator;
            }
        }
    }
}


// write the current Actuator position to the passed in Actuator 
void updateActuator(int thisActuator) {
    actuatorSet[thisActuator].write(actuatorPosition[thisActuator]);
}

12
WP2Social Auto Publish Powered By : XYZScripts.com