A więc, Dzień dobry
.Z samym Arduino mam do czynienia od ok. pół roku. Stąd też moje możliwości programowania nie są zbyt duże, aczkolwiek na moje potrzeby wystarcza(nie chwaląc się oczywiście).
Chcę się uczyć, aby móc dobudowywać kolejne części kodu, jednak na razie muszę bazować na efektach innych osób.
Przechodząc do meritum, buduję kokpit z prawdziwego auta do gry Euro Truck Simulator 2. Ktoś może powiedzieć, że biorę się za zbyt trudne rzeczy jak na tak małe doświadczenie.
Do tego celu chcę użyć Arduino Mega2560 z shield CanBUS od Elecfreaks.
Shield ma obsługiwać licznik z samochodu poprzez szynę CAN(ustawienie prędkości szyny 500 k).
Natomiast wyświetlacz HD44780 ma wyświetlać dane, których nie ma na liczniku z samochodu, czyli np. :
odległość(z nawigacji), ograniczenie prędkości itd.
Sam licznik działa dość dobrze, jednak mam problemy z ogarnięciem wyświetlacza.
Bez podłączonego shield'a, wyświetlacz poprawnie pokazuje żadane wartości.
Kiedy jest zamontowany "CAN BUS" i wgrany odpowiedni szkic na Arduino, wyświetlacz zamiast pokazywać ww. dane, pokazuje albo "krzaczki", albo ciąg znaków" HHHHHH".
Wklejam linki ze szkicami, a także plugin obsługujący telemetrię z gry oraz jakie dane ma wysyłać na port szeregowy.
Kolega programista z którym rozmawiałem, wspominał o przesłaniu danych przeznaczonych dla wyświetlacza w postaci zserializowanego stringa, a dopiero na Arduino miały by być te dane odpowiednio przetworzone.
Inny znajomy wspominał o odfiltrowaniu danych dla wyświetlacza.
W pewnym momencie pogubiłem się.
Linki:
Wersja bez CAN BUS, sam wyświetlacz i serwomechanizmy:
[syntax=cpp]/*
Copyright (c) 2013, Silas Parker
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
The name of Silas Parker may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <LiquidCrystal.h>
#include <Servo.h>
const int SPEEDO_PIN = A1;
const int RPM_PIN = A0;
const int LO = A2;
const int check = A3;
const int Rew = A4;
const int poz = A5;
const int LEFT_INDICATOR = 8;
const int RIGHT_INDICATOR = 9;
const int PARKING_BREAK = 10;
const int FUEL_WARNING = 11;
const int LOW_BEAM = 12;
const int HIGH_BEAM = 13;
// Servo variables
Servo speedo;
Servo rpm;
#define PACKET_SYNC 0xFF
#define PACKET_VER 2
#define SERVO_DIR_NORMAL false
#define SERVO_DIR_INVERT true
int serial_byte;
LiquidCrystal lcd(28, 30, 38, 36, 34, 32);
void setup()
{
Serial.begin(115200);
lcd.begin(16, 2);
lcd.print("Self Test");
// Initialise servos
speedo.attach(SPEEDO_PIN);
speedo.write(180);
rpm.attach(RPM_PIN);
rpm.write(180);
// Initialise LEDs
pinMode(LEFT_INDICATOR, OUTPUT);
pinMode(RIGHT_INDICATOR, OUTPUT);
pinMode(PARKING_BREAK, OUTPUT);
pinMode(FUEL_WARNING, OUTPUT);
pinMode(LOW_BEAM, OUTPUT);
pinMode(HIGH_BEAM, OUTPUT);
pinMode(LO, OUTPUT);
pinMode(check, OUTPUT);
pinMode(Rew, OUTPUT);
pinMode(poz, OUTPUT);
digitalWrite(LEFT_INDICATOR, 0);
digitalWrite(RIGHT_INDICATOR, 0);
digitalWrite(PARKING_BREAK, 0);
digitalWrite(FUEL_WARNING, 0);
digitalWrite(LOW_BEAM, 0);
digitalWrite(HIGH_BEAM, 0);
digitalWrite(LO, 0);
digitalWrite(check, 0);
digitalWrite(Rew, 0);
digitalWrite(poz, 0);
delay(500);
speedo.write(0);
rpm.write(0);
digitalWrite(LEFT_INDICATOR, 1);
digitalWrite(RIGHT_INDICATOR, 1);
digitalWrite(PARKING_BREAK, 1);
digitalWrite(FUEL_WARNING, 1);
digitalWrite(LOW_BEAM, 1);
digitalWrite(HIGH_BEAM, 1);
digitalWrite(LO, 1);
digitalWrite(check, 1);
digitalWrite(Rew, 1);
digitalWrite(poz, 1);
delay(500);
speedo.write(180);
rpm.write(180);
digitalWrite(LEFT_INDICATOR, 0);
digitalWrite(RIGHT_INDICATOR, 0);
digitalWrite(PARKING_BREAK, 0);
digitalWrite(FUEL_WARNING, 0);
digitalWrite(LOW_BEAM, 0);
digitalWrite(HIGH_BEAM, 0);
digitalWrite(LO, 0);
digitalWrite(check, 0);
digitalWrite(Rew, 0);
digitalWrite(poz, 0);
lcd.clear();
lcd.print("Wait");
// Wait a second to ensure serial data isn't from re-programming
delay(2500);
lcd.clear();
lcd.print("Ready");
}
void read_serial_byte_set_servo(Servo& servo, bool invert)
{
serial_byte = Serial.read();
serial_byte = (serial_byte < 0) ? 0 : ((serial_byte > 180) ? 180 : serial_byte);
if (invert)
servo.write(180 - serial_byte);
else
servo.write(serial_byte);
}
void skip_serial_byte()
{
(void)Serial.read();
}
void digitalWriteFromBit(int port, int value, int shift)
{
digitalWrite(port, (value >> shift) & 0x01);
}
void loop()
{
if (Serial.available() < 16)
return;
serial_byte = Serial.read();
if (serial_byte != PACKET_SYNC)
return;
serial_byte = Serial.read();
if (serial_byte != PACKET_VER)
{
lcd.clear();
lcd.print("PROTOCOL VERSION ERROR");
return;
}
read_serial_byte_set_servo(speedo, SERVO_DIR_INVERT); // Speed
read_serial_byte_set_servo(rpm, SERVO_DIR_INVERT); // RPM
skip_serial_byte(); // Brake air pressure
skip_serial_byte(); // Brake temperature
skip_serial_byte(); // Fuel ratio
skip_serial_byte(); // Oil pressure
skip_serial_byte(); // Oil temperature
skip_serial_byte(); // Water temperature
skip_serial_byte(); // Battery voltage
// Truck lights byte
serial_byte = Serial.read();
digitalWriteFromBit(poz, serial_byte, 6);
digitalWriteFromBit(LEFT_INDICATOR, serial_byte, 5);
digitalWriteFromBit(RIGHT_INDICATOR, serial_byte, 4);
digitalWriteFromBit(LOW_BEAM, serial_byte, 3);
digitalWriteFromBit(HIGH_BEAM, serial_byte, 2);
digitalWriteFromBit(Rew, serial_byte, 0);
// Warning lights bytes
serial_byte = Serial.read();
digitalWriteFromBit(PARKING_BREAK, serial_byte, 7);
digitalWriteFromBit(LO, serial_byte, 5);
digitalWriteFromBit(check, serial_byte, 6);
digitalWriteFromBit(FUEL_WARNING, serial_byte, 3);
// Enabled flags
serial_byte = Serial.read();
// Text length
int text_len = Serial.read();
// Followed by text
if (0 < text_len && text_len < 127)
{
lcd.clear();
for (int i = 0; i < text_len; ++i)
{
while (Serial.available() == 0) // Wait for data if slow
{
delay(2);
}
serial_byte = Serial.read();
if (serial_byte < 0 && serial_byte > 127)
return;
if (serial_byte == '\n')
lcd.setCursor(0, 1);
else
lcd.print(char(serial_byte));
// delay(2);
}
}
}[/syntax]
Wersja z CAN BUS i wyświetlaczem:
[syntax=cpp]/*
Copyright (c) 2013, Silas Parker
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
The name of Silas Parker may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
Source Code modified by Leon Bataille under the above mentioned license.
2015
*/
#include <mcp_can.h>
#include <SPI.h>
#include <Servo.h>
#include <Wire.h>
#include <LiquidCrystal.h>
#define lo8(x) ((int)(x)&0xff)
#define hi8(x) ((int)(x)>>8)
//Sketch information #DO NOT REMOVE!
String game = "Euro Truck Sim 2";
String vendor = "Leon Bataille";
//END Sketch information
//const int SPEEDO_PIN = A1;
//const int RPM_PIN = A0;
const int LEFT_INDICATOR = 40;
const int RIGHT_INDICATOR = 42;
const int PARKING_BREAK = 44;
const int FUEL_WARNING = 46;
// Servo variables
Servo speedo;
Servo rpm;
Servo fuel;
int fernlicht = 48;
int nebellicht = 50;
int bremse = 52;
int engine_rpm;
boolean hgb = false;
int blinker;
int temp;
float engine_fuel;
#define PACKET_SYNC 0xFF
#define PACKET_VER 2
#define SERVO_DIR_NORMAL true
#define SERVO_DIR_INVERT false
int speed ;
int serial_byte;
const int SPI_CS_PIN = 10;
MCP_CAN CAN(SPI_CS_PIN);// Set CS pin
LiquidCrystal lcd(28, 30, 38, 36, 34, 32);
void setup()
{
pinMode(fernlicht, OUTPUT);
pinMode(nebellicht, OUTPUT);
pinMode(bremse, OUTPUT);
Serial.begin(115200);
// Initialise LEDs
pinMode(LEFT_INDICATOR, OUTPUT);
pinMode(RIGHT_INDICATOR, OUTPUT);
pinMode(PARKING_BREAK, OUTPUT);
pinMode(FUEL_WARNING, OUTPUT);
digitalWrite(LEFT_INDICATOR, 0);
digitalWrite(RIGHT_INDICATOR, 0);
digitalWrite(PARKING_BREAK, 0);
digitalWrite(FUEL_WARNING, 0);
// Wait a second to ensure serial data isn't from re-programming
delay(1000);
lcd.begin(16, 2);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Uruchamianie");
lcd.setCursor(0,1);
lcd.print("systemu...");
START_INIT:
if(CAN_OK == CAN.begin(CAN_500KBPS)) // init can bus : baudrate = 500k
{
Serial.println("CAN BUS Shield uruchomiono poprawnie!");
}
else
{
Serial.println("Błąd uruchomienia CAN BUS Shield");
Serial.println("Uruchom CAN BUS Shield ponownie");
delay(100);
goto START_INIT;
}
//Tachotest RPM
unsigned char stmp59[8] ={0x4A, 0x4A, 0xFF, 0xFF, 0x5D, 0xFF, 0xFF, 0xFF};
CAN.sendMsgBuf(0x201, 8, 8, stmp59);
unsigned char stmp12[8] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
CAN.sendMsgBuf(0x420, 2, 8, stmp12);
delay(3000);
lcd.clear();
lcd.print("Prosze czekac");
// Wait a second to ensure serial data isn't from re-programming
delay(2500);
lcd.clear();
lcd.print("Gotowy");
}
void read_serial_byte_set_servo(Servo& servo, bool invert)
{
serial_byte = Serial.read();
serial_byte = (serial_byte < 0) ? 0 : ((serial_byte > 180) ? 180 : serial_byte);
//Tempo
if (invert) {
speed = serial_byte * 0.55;//(180 * 0.6 - serial_byte * -0.6)-110;
}
else {
speed = (serial_byte * 0.6)-110;
}
// servo.write(180 - serial_byte);
if (speed> 1) {
//KMH aktualisieren
for(int i=0;i<5;i++){
unsigned char stmp[8] = {speed,0,0,0,0,0,0,0};
CAN.sendMsgBuf(0x201, 4, 16, stmp);
unsigned char stmp25[8] = {0x78, 0x00, 0x59, 0xFF, 0xC0, 0x00, 0x20,0x51};
CAN.sendMsgBuf(0x430, 4, 16, stmp25);
}
}
/*
//Wenn Nadel auf 0 geht, KMH neu schreiben
FreqCounter::f_comp= 8; // Kompensation einstellen
FreqCounter::start(100); // Zähler starten für 1000ms
while (FreqCounter::f_ready == 0) // warten bis der Zähler fertig ist
freq=FreqCounter::f_freq; // Ergebnis lesen
freq=freq*10;
*/
else{
unsigned char stmp[8] = {speed,0,0,0,0,0,0,0};
CAN.sendMsgBuf(0x201, 4, 16, stmp);
unsigned char stmp21[8] = {0x91, 0x00, 0x59, 0xFF, 0xC0, 0x00, 0x20,0x51};
CAN.sendMsgBuf(0x430, 4, 16, stmp21);
}
}
void read_serial_byte_set_servo2(Servo& servo, bool invert){
serial_byte = Serial.read();
serial_byte = (serial_byte < 0) ? 0 : ((serial_byte > 180) ? 180 : serial_byte);
//RPM
if (invert){
//servo.write(180 - serial_byte);
engine_rpm = (180 * 0.5 - serial_byte * -0.5)-90;
unsigned char stmp4[] = {1,0,0,0,engine_rpm,0,0,0};
CAN.sendMsgBuf(0x201, 0, 8, stmp4);
unsigned char stmp1[8] = {0x59, 0x00, 0x59, 0xFF, 0xC0, 0x00, 0x20,0x51};
CAN.sendMsgBuf(0x420, 4, 16, stmp1);
}
else{
//servo.write(serial_byte);
engine_rpm = (serial_byte * 0.5)-90;
unsigned char stmp4[] = {1,0,0,0,engine_rpm,0,0,0};
CAN.sendMsgBuf(0x201, 0, 8, stmp4);
unsigned char stmp1[8] = {0x59, 0x00, 0x59, 0xFF, 0xC0, 0x00, 0x20,0x51};
CAN.sendMsgBuf(0x420, 4, 16, stmp1);
}
}
void read_serial_byte_set_servo_fuel(Servo& servo, bool invert)
{
serial_byte = Serial.read();
serial_byte = (serial_byte < 0) ? 0 : ((serial_byte > 180) ? 180 : serial_byte);
if (invert){
engine_fuel = (180+serial_byte);
//servo.write(85 - serial_byte); //set lower than the tach and speedo to limit movement.
unsigned char stmp12[] = {engine_fuel,0,0,0,0,0,0,0};
CAN.sendMsgBuf(0x420, 0, 8, stmp12);
}
else {
//servo.write(serial_byte);
engine_fuel = (180-serial_byte);
unsigned char stmp12[] = {engine_fuel,0,0,0,0,0,0,0};
CAN.sendMsgBuf(0x420, 0, 8, stmp12);
}
}
void skip_serial_byte()
{
(void)Serial.read();
}
void digitalWriteFromBit(int port, int value, int shift)
{
//int portnumber = port;
digitalWrite(port, (value >> shift) & 0x01);
if ((analogRead(2) < 350) && (analogRead(3) < 350)) {
//kein Blinker
blinker = 0;
}
else if ((analogRead(2) > 350) && (analogRead(3) < 350)) {
//linker Blinker
blinker = 1;
}
else if ((analogRead(3) > 350) && (analogRead(2) < 350 )){
//rechter Blinker
blinker = 2;
}
else if ((analogRead(3) > 350) && (analogRead(2) > 350 )){
//Warnblinker
blinker = 3;
}
unsigned char stmp15[] = {blinker,0,hgb,0,0,0,0,0}; //1,0 = links; 2,0 = rechts; 3,0 = Warn
CAN.sendMsgBuf(0x470, 0, 8, stmp15);
}
void loop()
{
/* unsigned char stmp[8] = {0x76, 0x00, 0x59, 0xFF, 0xC0, 0x00, 0x20,0x51};
CAN.sendMsgBuf(0x420, 4, 16, stmp);
*/
if (Serial.available() < 16)
return;
serial_byte = Serial.read();
if (serial_byte != PACKET_SYNC)
return;
serial_byte = Serial.read();
if (serial_byte != PACKET_VER)
read_serial_byte_set_servo(speedo, SERVO_DIR_NORMAL); // Speed
read_serial_byte_set_servo2(rpm, SERVO_DIR_NORMAL); // RPM
delay(30);
skip_serial_byte(); // Brake air pressure
skip_serial_byte(); // Brake temperature
read_serial_byte_set_servo_fuel(fuel, SERVO_DIR_INVERT); // Fuel ratio
skip_serial_byte(); // Oil temperature
skip_serial_byte(); //Water temperature
skip_serial_byte(); // Battery voltage
// Truck lights byte
serial_byte = Serial.read();
digitalWriteFromBit(LEFT_INDICATOR, serial_byte, 5);
digitalWriteFromBit(RIGHT_INDICATOR, serial_byte, 4);
// Warning lights bytes
serial_byte = Serial.read();
digitalWriteFromBit(PARKING_BREAK, serial_byte, 7);
digitalWriteFromBit(FUEL_WARNING, serial_byte, 3);
// Enabled flags
serial_byte = Serial.read();
// Text length
int text_len = Serial.read();
if (0 < text_len && text_len < 127)
{
lcd.clear();
for (int i = 0; i < text_len; ++i)
{
while (Serial.available() == 0) // Wait for data if slow
serial_byte = Serial.read();
if (serial_byte < 0 && serial_byte > 127)
return;
if (serial_byte == '\n')
lcd.setCursor(0, 1);
else
lcd.write(char(serial_byte));
delay(5);
}
}
}[/syntax]
Plik obsługujący port szeregowy(.cpp jeden z elementów biblioteki .dll, gotowy do skompilowania)
[syntax=cpp]/*
Copyright (c) 2013, Silas Parker
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
The name of Silas Parker may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "serial.hpp"
Serial::Serial() : com_port(INVALID_HANDLE_VALUE)
{}
Serial::~Serial()
{
close();
}
bool Serial::is_valid() const
{
return com_port != INVALID_HANDLE_VALUE;
}
bool Serial::open(const std::string& name, std::string& errmsg)
{
bool retval = false;
DCB config;
errmsg.clear();
// If port already open, ignore call
if (com_port != INVALID_HANDLE_VALUE)
{
errmsg = "COM port already open";
goto exit;
}
// Open COM port
com_port = CreateFile(name.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, 0, NULL);
if (com_port == INVALID_HANDLE_VALUE)
{
errmsg = "Can not open COM port";
goto exit;
}
// Get current config
config.DCBlength = sizeof(config);
if (!GetCommState(com_port, &config))
{
errmsg = "Can not get COM port config";
goto exit;
}
// Set defaults
config.BaudRate = CBR_115200;
config.StopBits = ONESTOPBIT;
config.Parity = NOPARITY;
config.ByteSize = 8;
// Set config
if (!SetCommState(com_port, &config))
{
errmsg = "Can not set COM port config";
goto exit;
}
retval = true;
exit:
if (retval == false)
{
close();
}
return retval;
}
void Serial::close()
{
if (com_port != INVALID_HANDLE_VALUE)
{
CloseHandle(com_port);
com_port = INVALID_HANDLE_VALUE;
}
}
void Serial::write(const unsigned char* data, unsigned length)
{
if (data == 0 || length == 0)
return;
if (com_port != INVALID_HANDLE_VALUE)
{
unsigned long wrote;
WriteFile(com_port, data, length, &wrote, NULL);
FlushFileBuffers(com_port);
}
}[/syntax]
I główny plik plugin'u(plik .cpp gotowy do skompilowania do biblioteki .dll):
[syntax=cpp]/*
Copyright (c) 2013, Silas Parker
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
The name of Silas Parker may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define WINVER 0x0500
#define _WIN32_WINNT 0x0500
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdarg.h>
#include <sstream>
#include <scssdk_telemetry.h>
#include <eurotrucks2/scssdk_telemetry_eut2.h>
#include "serial.hpp"
#include "options.hpp"
static const float METERS_PER_SEC_TO_MILES_PER_HOUR = 2.2369f;
static const float METERS_PER_SEC_TO_KM_PER_HOUR = 3.6f;
// Game log file
scs_log_t game_log = NULL;
// COM port file
Serial serial_port;
unsigned long last_update = 0;
// Packet
#define PACKET_MAX_SIZE 720 // Can send a maximum of 720 bytes per frame at 20 FPS over a 115200 bps line
#define PACKET_SYNC 0xFF
#define PACKET_VER 2
unsigned char packet[PACKET_MAX_SIZE];
#define PACKBOOL(A,B,C,D,E,F,G,H) \
(((unsigned char)(A) << 7) | ((unsigned char)(B) << 6) | \
((unsigned char)(C) << 5) | ((unsigned char)(D) << 4) | \
((unsigned char)(E) << 3) | ((unsigned char)(F) << 2) | \
((unsigned char)(G) << 1) | ((unsigned char)(H)))
// Telemetry data
struct telemetry_state_t
{
float speed; // Meters per Second
float engine_rpm; // RPM
int engine_gear; // >0 Forward, 0 Neutral, <0 Reverse
bool parking_brake;
bool motor_brake;
float brake_air_pressure; // PSI
bool brake_air_pressure_warning;
bool brake_air_pressure_emergency;
float brake_temperature;
float fuel; // Liters
bool fuel_warning;
float fuel_average_consumption; // Liters / KM
float fuel_capacity; // Liters
float oil_pressure; // PSI
bool oil_pressure_warning;
float oil_temperature; // Celsius
float water_temperature; // Celsius
bool water_temperature_warning;
float battery_voltage; // Volts
bool battery_voltage_warning;
bool electric_enabled;
bool engine_enabled;
bool light_lblinker;
bool light_rblinker;
bool light_parking;
bool light_low_beam; // Dipped headlights
bool light_high_beam; // Full headlights
bool light_brake;
bool light_reverse;
float odometer; // Kilometres
} telemetry;
Options option_file;
unsigned char float_to_byte(float value)
{
return
(value > 254.0f) ? 254 : // Sync byte is 255 so avoid that
((value < 0.0f) ? 0 :
(unsigned char)(value));
}
void send_empty_packet()
{
memset(packet, 0, PACKET_MAX_SIZE);
packet[0] = PACKET_SYNC;
packet[1] = PACKET_VER;
serial_port.write(packet, 16);
}
SCSAPI_VOID telemetry_frame_end(const scs_event_t /*event*/, const void *const /*event_info*/, const scs_context_t /*context*/)
{
if (!serial_port.is_valid())
return;
const unsigned long now = GetTickCount();
const unsigned long diff = now - last_update;
if (diff < 50)
return;
last_update = now;
const float speed_mph = telemetry.speed * METERS_PER_SEC_TO_MILES_PER_HOUR;
const float speed_kph = telemetry.speed * METERS_PER_SEC_TO_KM_PER_HOUR;
const float fuel_ratio = telemetry.fuel / telemetry.fuel_capacity;
unsigned idx = 0;
memset(packet, 0, PACKET_MAX_SIZE);
#define PUT_BYTE(X) packet[idx++] = (unsigned char)(X)
#define PUT_BYTE_FLOAT(X) packet[idx++] = (unsigned char)(float_to_byte(X))
#define GETFLTOPT(X) (option_file.get_option_float(X, 1.0f))
// Packet header
PUT_BYTE(PACKET_SYNC);
PUT_BYTE(PACKET_VER);
// Convert data for output by servos
// Adjust the constant values to map to servo range
PUT_BYTE_FLOAT(fabs(telemetry.speed) * GETFLTOPT("factor_speed")); // Absolute value for when reversing
PUT_BYTE_FLOAT(telemetry.engine_rpm * GETFLTOPT("factor_engine_rpm"));
PUT_BYTE_FLOAT(telemetry.brake_air_pressure * GETFLTOPT("factor_brake_air_pressure"));
PUT_BYTE_FLOAT(telemetry.brake_temperature * GETFLTOPT("factor_brake_temperature"));
PUT_BYTE_FLOAT(fuel_ratio * GETFLTOPT("factor_fuel_ratio")); // Fuel level
PUT_BYTE_FLOAT(telemetry.oil_pressure * GETFLTOPT("factor_oil_pressure"));
PUT_BYTE_FLOAT(telemetry.oil_temperature * GETFLTOPT("factor_oil_temperature"));
PUT_BYTE_FLOAT(telemetry.water_temperature * GETFLTOPT("factor_water_temperature"));
PUT_BYTE_FLOAT(telemetry.battery_voltage * GETFLTOPT("factor_battery_voltage"));
// Pack data for LEDs into bytes
// Truck lights
PUT_BYTE(PACKBOOL(
0, telemetry.light_parking,
telemetry.light_lblinker, telemetry.light_rblinker,
telemetry.light_low_beam, telemetry.light_high_beam,
telemetry.light_brake, telemetry.light_reverse));
// Warning lights
PUT_BYTE(PACKBOOL(
telemetry.parking_brake, telemetry.motor_brake,
telemetry.brake_air_pressure_warning, telemetry.brake_air_pressure_emergency,
telemetry.fuel_warning, telemetry.battery_voltage_warning,
telemetry.oil_pressure_warning, telemetry.water_temperature_warning));
// Enabled flags
PUT_BYTE(PACKBOOL(
0,0,0,0,0, 0,
telemetry.electric_enabled, telemetry.engine_enabled));
// Build string for LCD display
std::stringstream ss;
if (telemetry.engine_gear > 0)
{
ss <<"D";
ss.width(2);
ss << telemetry.engine_gear;
}
else if (telemetry.engine_gear == 0)
{
ss <<"N";
}
else
{
ss <<"R";
ss.width(2);
ss << abs(telemetry.engine_gear);
}
ss << "\n";
ss.width(3);
ss << int(fuel_ratio * 100.0f) << "% ";
ss.width(3);
ss << abs(int(speed_kph));
ss.width(4);
ss << "km/h";
std::string display_str(ss.str());
// Write length of string
PUT_BYTE(display_str.size());
// Followed by string
display_str.copy((char*)&packet[idx], PACKET_MAX_SIZE - idx);
idx += display_str.size();
serial_port.write(packet, idx);
}
SCSAPI_VOID telemetry_store_float(const scs_string_t /*name*/, const scs_u32_t /*index*/, const scs_value_t *const value, const scs_context_t context)
{
assert(value);
assert(value->type == SCS_VALUE_TYPE_float);
assert(context);
*static_cast<float *>(context) = value->value_float.value;
}
SCSAPI_VOID telemetry_store_bool(const scs_string_t /*name*/, const scs_u32_t /*index*/, const scs_value_t *const value, const scs_context_t context)
{
assert(value);
assert(value->type == SCS_VALUE_TYPE_bool);
assert(context);
*static_cast<bool *>(context) = (value->value_bool.value != 0);
}
SCSAPI_VOID telemetry_store_s32(const scs_string_t /*name*/, const scs_u32_t /*index*/, const scs_value_t *const value, const scs_context_t context)
{
assert(value);
assert(value->type == SCS_VALUE_TYPE_s32);
assert(context);
*static_cast<int *>(context) = value->value_s32.value;
}
SCSAPI_VOID telemetry_configuration(const scs_event_t /*event*/, const void *const event_info, const scs_context_t /*context*/)
{
const struct scs_telemetry_configuration_t *const info = static_cast<const scs_telemetry_configuration_t *>(event_info);
for (const scs_named_value_t *current = info->attributes; current->name; ++current)
{
#define GET_CONFIG(PROPERTY, TYPE) \
if (strcmp(SCS_TELEMETRY_CONFIG_ATTRIBUTE_ ## PROPERTY, current->name) == 0) \
{ telemetry.PROPERTY = current->value.value_ ## TYPE.value; }
GET_CONFIG(fuel_capacity, float);
}
}
void get_cwd(std::string& str)
{
char buffer[256];
GetCurrentDirectory(256, buffer);
str.assign(buffer);
}
SCSAPI_RESULT scs_telemetry_init(const scs_u32_t version, const scs_telemetry_init_params_t *const params)
{
if (version != SCS_TELEMETRY_VERSION_1_00) {
return SCS_RESULT_unsupported;
}
const scs_telemetry_init_params_v100_t *const version_params = static_cast<const scs_telemetry_init_params_v100_t *>(params);
game_log = version_params->common.log;
game_log(SCS_LOG_TYPE_message, "Plugin initialising");
std::string cwd;
get_cwd(cwd);
game_log(SCS_LOG_TYPE_message, (std::string("Plugin CWD: ") + cwd).c_str());
std::string option_filepath(cwd + "\\plugins\\dash_plugin.txt");
if (!option_file.read_file(option_filepath))
{
game_log(SCS_LOG_TYPE_error, (std::string("Error reading settings file: ") + option_filepath).c_str());
return SCS_RESULT_generic_error;
}
const std::string com_port = option_file.get_option_string("comport", "COM3");
game_log(SCS_LOG_TYPE_message, (std::string("Using serial port: ") + com_port).c_str());
// Open COM port
std::string errmsg;
if (!serial_port.open(com_port, errmsg))
{
game_log(SCS_LOG_TYPE_error, errmsg.c_str());
return SCS_RESULT_generic_error;
}
send_empty_packet();
// Register for in game events
bool registered =
(version_params->register_for_event(
SCS_TELEMETRY_EVENT_frame_end, telemetry_frame_end, NULL) == SCS_RESULT_ok) &&
(version_params->register_for_event(
SCS_TELEMETRY_EVENT_configuration, telemetry_configuration, NULL) == SCS_RESULT_ok);
// Register for truck channels
#define REG_CHAN(CHANNEL, TYPE) \
registered &= (version_params->register_for_channel( \
SCS_TELEMETRY_TRUCK_CHANNEL_ ## CHANNEL, SCS_U32_NIL, SCS_VALUE_TYPE_ ## TYPE, \
SCS_TELEMETRY_CHANNEL_FLAG_none, telemetry_store_ ## TYPE, &telemetry.CHANNEL) == SCS_RESULT_ok)
REG_CHAN(speed, float);
REG_CHAN(engine_rpm, float);
REG_CHAN(engine_gear, s32);
REG_CHAN(parking_brake, bool);
REG_CHAN(motor_brake, bool);
REG_CHAN(brake_air_pressure, float);
REG_CHAN(brake_air_pressure_warning, bool);
REG_CHAN(brake_air_pressure_emergency, bool);
REG_CHAN(brake_temperature, float);
REG_CHAN(fuel, float);
REG_CHAN(fuel_warning, bool);
REG_CHAN(fuel_average_consumption, float);
REG_CHAN(oil_pressure, float);
REG_CHAN(oil_pressure_warning, bool);
REG_CHAN(oil_temperature, float);
REG_CHAN(water_temperature, float);
REG_CHAN(water_temperature_warning, bool);
REG_CHAN(battery_voltage, float);
REG_CHAN(battery_voltage_warning, bool);
REG_CHAN(electric_enabled, bool);
REG_CHAN(engine_enabled, bool);
REG_CHAN(light_lblinker, bool);
REG_CHAN(light_rblinker, bool);
REG_CHAN(light_parking, bool);
REG_CHAN(light_low_beam, bool);
REG_CHAN(light_high_beam, bool);
REG_CHAN(light_brake, bool);
REG_CHAN(light_reverse, bool);
REG_CHAN(odometer, float);
if (!registered)
{
game_log(SCS_LOG_TYPE_error, "Unable to register callbacks");
return SCS_RESULT_generic_error;
}
memset(&telemetry, 0, sizeof(telemetry));
return SCS_RESULT_ok;
}
SCSAPI_VOID scs_telemetry_shutdown(void)
{
send_empty_packet();
serial_port.close();
game_log(SCS_LOG_TYPE_message, "Plugin shutdown");
game_log = NULL;
}
BOOL APIENTRY DllMain(HMODULE /*module*/, DWORD reason_for_call, LPVOID /*reseved*/)
{
if (reason_for_call == DLL_PROCESS_DETACH)
{
serial_port.close();
}
return TRUE;
}[/syntax]
Pliki przeznaczone powyżej(oprócz szkiców) są przeznaczone do kompilacji do biblioteki .dll, która to później obsługuje telemetrię i przesyłanie danych do Arduino.
Jeśli byłby ktoś miły nakierować mnie na właściwą drogę do rozwiązania mojego problemu, będę wdzięczny.
Nie znalazłem też pomocy w wyszukiwarce, proszę o wyrozumiałość.
Statystyki: Napisane przez MajkyyM — 28 cze 2017, o 17:58
]]>