Monthly Archives:Dezember 2015

Mazda RX8 canbus

Ich hab mal ein wenig mit der canbus-card für den Arduino Uno experimentiert und die ersten Test sehen nicht schlecht aus.
Das Tacho des RX8 eignet sich eigentlich optimal. Es ist günstig, geht bis 10K Rpm und 300Kmh.

      

  • Tankanzeige geht noch nicht
  • Anschnallzeichen lässt sich nicht deaktivieren

Update: 27.02.2017

Folgende Funktionen lassen sich über canbus steuern:

  • Öldruck (als Warnlicht und auch analog)
  • Batterieanzeige
  • Kühlwasseranzeige
  • Motorwarnleuchte
  • ABS Warnlicht
  • Bremsanzeige
  • Tempomat
  • EPS Warnlicht
  • DSC/ESP (On/off)
  • DSC active
  • Drehzahl
  • Geschwindigkeit
  • Tank

Direkt über den Arduino können dann noch Blinker und das Türwarnlicht geschaltet werden.

Mazda RX8 canbus
4.9 (98.57%) 14 stimmen

rcc v2 – real cockpit connector version 2

Status: Beta V.2.0.0.0 (29.01.2017)

  • Bodyshaker support (Assetto Corsa, Projekt Cars)
  • new output vars from games for own controls
  • support R3E – RaceRoom Racing Experience
  • many bugfixes and optimations
  • dokumentation not complete

Kurzanleitung:

Generell hat sich an der Bedienung zur alten Version nichts geändert.
Leider musste ich aber den internen Programmablauf etwas ändern. Dadurch ergibt sich auch eine Änderung am Arduinosketch. Dies betrifft also „nur“ die Benutzer vor V.2.0.0.0

V2 ist kein update, sondern eine eigenständige Version welche nur entpackt werden muss.

Benutzer der V1.x.x.x :
-im Debug der alten V1.x.x.x alte Werte auslesen und notieren
-neue V.2 in einem anderen Verzeichnis entpacken
-das mitgelieferte „BasicV2.ino“ auf dem Arduino flashen
-V2. starten verbinden und „zurücksetzen“ wählen
-die zuvor notierten Werte wieder konfigurieren

Output:

Der übergebene Outputstring kann im Tab „Dash“ für jedes Game angepasst werden. Nach und nach werden weitere „Outputs“ dazu kommen. Der String ist so konfiguriert das die ersten 5 Werte aus jedem Spiel immer gleich in Länge und Reihenfolge sind. Selbige werden immer ausgegeben.
Alle anderen Werte sind optional, unterschiedlich und können in den entsprecheneden readme’s nachgelesen werden.

Syntax:
   Kmh          Rpm            Fuel      Temp      Gear
SSxxx;RRxxxx;FFxxx;TTxxx;GGxx; (x steht immer für eine Ziffer mit führender Null)

Beispiel:
183 Kmh
4560 rpm
32 l Rest im Tank
122 Grad
5 Gang

Output:
SS183;RR4560;FF032;TT122;GG05;

Besonderheiten der zusätzlichen Outputs im Tab „Dash“:
Insgesammt gibt es 16 zusätzliche Ausgaben und nochmals 6 Gruppen mit möglichen Werten.
Gruppen beinhalten mehrere Werte. Zum Beispiel gibt es in Project Cars als erste Gruppe eine Wertfolge für „temptyre(4)“. In dieser Gruppe befinden sich die Werte für die Reifentemperatur aller 4 Reifen in der Reihenfolge VL, VR, HL, HR jeweils mit 3 Stellen die mit den Zeichen „~Q“ beginnen.

Als Beispiel: ~Q095097096095;
„~Q“ leitet den Wert der ersten Gruppe für 4 einzelne Werte ein.

Die Syntax der ersten 16 Einzelwerte gehen von „~A“ bis „~P“.
Die der 6 folgenden Gruppen von „~Q“ bis „~V“. (diese müssen im Arduinosketch aufgelöst werden)

Im Programmverzeichniss under „Arduinosketche/Enhanced V2“ befinden sich kleine einfache Sketchteile die sich schön in die Basis der BasicV2.ino intrgrieren lassen.

Download:

Bitte habt verständniss das ich kein support per Telefon oder per email gebe. Schreibt eure Fragen etc. bitte hier in die Kommentare.

Please understand that I do not give support by telephone or by email. Please write your questions, etc. here in the comments.

rcc v2 – real cockpit connector version 2
5 (100%) 10 stimmen

VW Golf 3 Tacho mit rcc – real cockpit connector

Da ich unglaublich viele Anfragen aus dem Aus-Inland bekommen habe ob ich nicht mal ein kleines Tutorial für ein Golftacho machen kann, will ich das hier mal umsetzten.

Aber erstmal ein großes Danke an Daniel, welcher in Österreich wohnt und mir eine großzügige Spende sowie auch 2 x Golf 3 Tachos kostenlos zur verfügung gestellt hat.

Prinzipiell ist der Aufbau ähnlich wie schon bei dem BMW e36 Tacho. Die Kmh/h-Anzeige wird mit auch mit 5v angesteuert.
Das besondere beim VW-Tacho ist eben das das Rpm-Signal mit 12v angesteuert wird. Fuel und Temp, genau wie bei BMW über Widerstandsveränderungen.

Hier möchte ich anmerken, dass VW bei dem Golf 3 gleich 6 verschiedene Tachos verbaut hat. Ich habe hier ein VDO und ein TRW die Beide bei 0 Kmh anfangen. Wer mag, kann hier ein wenig nachlesen: Tachoumbau.com

Leider musste ich für eine saubere Tachojustierung das Tacho öffnen. Der Grund dafür ist das ich mit der Feinjustierung vom RPM nicht unter 1.000 gekommen bin. Ein ähnliches Problem gibt es auch beim e36 Tacho. Dort gehts nicht unter 750rpm. In Rennspiele vielleicht nicht das Problem aber einige (viele) bauen einen LKW-Simulatur. Da sollte dann auch die Anzeige unter 1000 funktionieren. Dazu aber später mehr.

Als erstes also das Tacho öffnen, so dass wir an die Nadeln drann kommen.

Jetzt gehts an die Verkabelung. (Das flashen des Arduinos sollte schon fertig sein)

Golf3 Tacho Arduino Wiring Verkabelung

 

 

 

Wenn alles richtig verkabelt ist machen wir eine Vorabkonfigurierung im „rcc“ für das Tacho.
(im Tab „Hardware“). Das Tacho noch NICHT mit Strom versorgen.

  • Checkbox „Testmodus aktivieren)
  • Arduino anschliessen, ComPort wählen und „open“ klicken
  • auf der linken Seite die Werte des realen Tachos eintragen (speichern im PC+ write Arduino)
  • mittig die Funktion „speed“ wählen:    min=0, max=226 (speichern + write Arduino)
  • mittig die Funktion „rpm“ wählen:       min=31, max=198 (speichern + write Arduino)
  • Im Tab „Debug“ mit „EEProm Werte lesen“ überprüfen ob die Werte auch wirklich im Arduino abgelegt sind.
    maxSpdSim = 220
    minSpdTacho = 0
    maxSpdTacho = 226
    maxRpmSim = 525
    minRpmTacho = 31
    maxRpmTacho = 198
    maxFuelSim = 55
    minFuelTacho = 150
    maxFuelTacho = 0
    maxTempSim = 130
    minTempTacho = 140
    maxTempTacho = 0
    pkmh = 3
    prpm = 2
    pful = 5
    ptmp = 6
    Button 1 = 7
    Button 2 = 8
    Axis 1 = 99
    Axis 2 = 99
  • zurück zum testen rpm wählen, eine 0 ins rechte Feld daneben eintragen und das kleine „test“ aktivieren
  • jetzt das Tacho mit Strom versorgen

An diesem Punkt sollte das Rpm etwa 1000 auf dem Tacho anzeigen. Ihr könnt jetzt noch versuchen weiter den kleinsten  möglichen Wert zu ermitteln in dem ihr wieder zurück auf „adj“ klickt und mit dem Schieberegler versucht die Nadel soweit wie möglich richtung 0 zu bringen.

Bei mir war „min=31“ der beste Wert. Alles darunter fing  die Nadel an zu zappeln.
Nun steht die Nadel bei 1000 und nicht da wo sie hin soll.

Golf 3rcc justierung

 

 

 

Ich denke das der Arduino nicht mit der Hz-Zahl klar kommt was das Tacho will. Also hab ich ein wenig getrickst.
Sollte jemand eine bessere Lösung haben, kann er sie gerne unten in die Kommentare schreiben.

Zu diesem Zeitpunkt trennt ihr jetzt das Tacho vom Strom. (Die Nadel bleibt bei ca. 1000 stehen)
Hebelt die Nadel vorsichtig ab und bringt sie wieder in der Nullposition an.

Der Ardunino schafft zwar nicht unter dem dem Wert aber sehr wohl über den Wert. Heisst, er schafft die Nadel auch weit über die Anzeige raus. Und genau das machen wir uns zu nutze.

Tacho Golf 3 Nadel neu justieren

 

 

 

  1. Nadel vorsichtig abhebeln (evt. noch etwas Unterlegen um Kratzer zu vermeiden)
  2. Nadel inNullposition wieder anbringen
  3. zeigt Tacho ohne Arduino wenn es eingeschaltet wird.
    Sobald Arduino und rcc angeschlossen sind, färt die Nadel auf 0
  4. zeigt die Endposition

Jetzt noch nach oben beschriebene Anleitung den oberen rpm-Wert mit „max“ einjustieren

Bei „speed“ ebenso verfahren. Niedrigsten und höchsten Wert mittels Schieberegler einstellen.
Es ist KEINE Nadeländerung nötig.

Bei allen Speichervorgängen im rcc muss der „Testmodus“ aktiviert sein, sonst funktioniert es nicht.

Viel Spaß beim nachbauen.

VW Golf 3 Tacho mit rcc – real cockpit connector
5 (100%) 13 stimmen

rcc comes with bodyshaker support

Um noch mehr „feeling“ in den Simulator zu bringen habe ich mich entschlossen eine Unterstützung für Bodyshaker einzubauen.
Die ersten Tests mit Assetto Corsa sind gut gelaufen.

Im rcc werden NICHT die Sounds aus dem Game sondern die physikalichen Daten des Fahrzeuges zur Erzeugung der Vibrationen genutzt.

Zum testen hab ich eine externe USB-Soundkarte, einen Mini-Verstärker und ein paar Bodyshaker genommen.

rcc comes with bodyshaker support
5 (100%) 17 stimmen

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]);
}

6DOF – Stewart platform mit FSX –
5 (100%) 6 stimmen

rcc mit TM1638

Da doch einige Anfragen zur Ansteuerung eines TM1638 mit dem rcc gekommen sind, habe ich hier mal ein einfaches Beispiel für eine Drehzahlanzeige gemacht.

//https://github.com/rjbatista/tm1638-library
#include   
// define a module on data (DIO) pin 8, clock (CLK) pin 9 
// and strobe (STB0)pin 10
TM1638 module(8, 9, 10);

String ver = "2.0.0.0";

const int nChar = 30; // size of char
String inString = ""; // a string to hold incoming data
boolean stringComplete = false; // whether the string is complete

int vRpm;

void setup()
{
Serial.begin(38400);
}

void readdata() {
if (stringComplete) {
if (inString.substring(0, 2) == "RR") {
vRpm = inString.substring(2, 6).toInt();
module.setDisplayToDecNumber(vRpm * 10,0,false);
}
inString = "";
stringComplete = false;
}
}

void serialReadEvent() {
while (Serial.available()) {
char inChar = (char)Serial.read();
inString += inChar;
if (inChar == ';') {
stringComplete = true;
}
}
}

void loop() {
serialReadEvent();
readdata();
}

rcc mit TM1638
5 (100%) 6 stimmen
Facebook Auto Publish Powered By : XYZScripts.com