Arduino car game dashboard

drashmika29 · July 29, 2023, 9:42pm

In Euro Truck Simulator game, when the speed of the truck is more than 50kph, an LED on the Arduino should be turned on, and if the speed of the truck is less than 50kph, the led should be off. Can you explain how to do this?
Thank you

Files:

Plugin.cpp file


#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
  
  float cruise_control; // added
  
} 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"));
  PUT_BYTE_FLOAT(telemetry.cruise_control *     GETFLTOPT("factor_cruise_control"));

  // Pack data for LEDs into bytes
  bool send_value = (speed_kph > 50) ? true : false;
  
  // Truck lights
  //BOOKMARK
  PUT_BYTE(PACKBOOL(
    send_value, 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;
  
  ss.width(3);
  /* ss << abs(int(speed_mph));
  ss << " MPH";
  
  ss << "   G  "; */
  
  /* 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 << abs(int(speed_kph));
  ss << " KPH";
  
  ss << "   F ";
  
  ss.width(3);
  ss << int(fuel_ratio * 100.0f) << "%";
  
  
  ss.width(3);
  ss << abs(int(speed_kph)); */
  
  //ss << int(telemetry.engine_gear);
  
  if(telemetry.engine_gear == 1) {

	ss << "a";

   }

  else if(telemetry.engine_gear == 2){

	ss << "b";

   }
   else if(telemetry.engine_gear == 3){

	ss << "c";

   }
   else if(telemetry.engine_gear == 4){

	ss << "d";

   }
   else if(telemetry.engine_gear == 5){

	ss << "e";

   }
   else if(telemetry.engine_gear == 6){

	ss << "f";

   }
   else if(telemetry.engine_gear == 7){

	ss << "g";

   }
   else if(telemetry.engine_gear == 8){

	ss << "h";

   }
   else if(telemetry.engine_gear == 9){

	ss << "i";

   }
   else if(telemetry.engine_gear == 10){

	ss << "j";

   }
   else if(telemetry.engine_gear == 11){

	ss << "k";

   }
   else if(telemetry.engine_gear == 12){

	ss << "l";

   }
  
   else if(telemetry.engine_gear == 13){

	ss << "m";

   }
   else if(telemetry.engine_gear == 14){

	ss << "n";

   }
   else if(telemetry.engine_gear == 15){

	ss << "o";

   }
   else if(telemetry.engine_gear == 16){

	ss << "p";

   }
   else if(telemetry.engine_gear == 17){

	ss << "q";

   }
   else if(telemetry.engine_gear == 18){

	ss << "r";

   }
   else if(telemetry.engine_gear == -1){

	ss << "s";

   }
   else if(telemetry.engine_gear == -2){

	ss << "t";

   }
   else if(telemetry.engine_gear == -3){

	ss << "u";

   }
   else if(telemetry.engine_gear == -4){

	ss << "v";

   }
    else if(telemetry.engine_gear == 0){

	ss << "w";

   }
  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);
  REG_CHAN(cruise_control,                float); //added

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

Arduino.ino file

#include <Servo.h>

const int SPEEDO_PIN      = A0;
const int RPM_PIN         = A1;
const int FUEL_PIN        = A5;
const int LEFT_INDICATOR  = A2;
const int RIGHT_INDICATOR = A3;
const int PARKING_BREAK   = A4;
const int CRUISE_CONTROL  = 11;
const int FUEL_WARNING    = 12;
const int LOW_BEAM        = 28;
const int HIGH_BEAM       = 30;

int pinA = 9;
int pinB = 8;
int pinC = 6;
int pinD = 5;
int pinE = 4;
int pinF = 3;
int pinG = 7;
int pinH = 2;

// defines servo names
Servo speedo;
Servo rpm;
Servo fuel;
Servo cruise;

#define PACKET_SYNC 0xFF
#define PACKET_VER  2

#define SERVO_DIR_NORMAL false
#define SERVO_DIR_INVERT true

int serial_byte;

void setup()
{
  Serial.begin(115200);
  
  speedo.attach(SPEEDO_PIN);
  speedo.write(180);
  rpm.attach(RPM_PIN);
  rpm.write(180);
  fuel.attach(FUEL_PIN);
  fuel.write(40);
  cruise.write(180);
  
  pinMode(LEFT_INDICATOR, OUTPUT);
  pinMode(RIGHT_INDICATOR, OUTPUT);
  pinMode(PARKING_BREAK, OUTPUT);
  pinMode(FUEL_WARNING, OUTPUT);
  pinMode(CRUISE_CONTROL, OUTPUT);
  pinMode(LOW_BEAM, OUTPUT);
  pinMode(HIGH_BEAM, OUTPUT);
  pinMode(pinA, OUTPUT);
  pinMode(pinB, OUTPUT);
  pinMode(pinC, OUTPUT);
  pinMode(pinD, OUTPUT);
  pinMode(pinE, OUTPUT);
  pinMode(pinF, OUTPUT);
  pinMode(pinG, OUTPUT);
  pinMode(pinH, OUTPUT); 

  //range-splitter LED's
  pinMode(22, OUTPUT);
  pinMode(24, OUTPUT);
  pinMode(26, OUTPUT);
  
  digitalWrite(LEFT_INDICATOR, 0);
  digitalWrite(RIGHT_INDICATOR, 0);
  digitalWrite(PARKING_BREAK, 0);
  digitalWrite(FUEL_WARNING, 0);
  digitalWrite(CRUISE_CONTROL, 0);
  digitalWrite(LOW_BEAM, 0);
  digitalWrite(HIGH_BEAM, 0);
  
  delay(500);
  
  speedo.write(0);
  rpm.write(0);
  fuel.write(0);
  digitalWrite(LEFT_INDICATOR, 1);
  digitalWrite(RIGHT_INDICATOR, 1);
  digitalWrite(PARKING_BREAK, 1);
  digitalWrite(FUEL_WARNING, 1);
  digitalWrite(CRUISE_CONTROL, 1);
  digitalWrite(LOW_BEAM, 1);
  digitalWrite(HIGH_BEAM, 1);
  digitalWrite(22, 1);
  digitalWrite(24, 1);
  digitalWrite(26, 1);
  
  delay(500);
  
  speedo.write(180);
  rpm.write(180);
  fuel.write(85);
  digitalWrite(LEFT_INDICATOR, 0);
  digitalWrite(RIGHT_INDICATOR, 0);
  digitalWrite(PARKING_BREAK, 0);
  digitalWrite(FUEL_WARNING, 0);
  digitalWrite(CRUISE_CONTROL, 0);
  digitalWrite(LOW_BEAM, 0);
  digitalWrite(HIGH_BEAM, 0);
  digitalWrite(22, 0);
  digitalWrite(24, 0);
  digitalWrite(26, 0);

  digitalWrite(pinA, HIGH);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, HIGH);
  digitalWrite(pinD, HIGH);
  digitalWrite(pinE, HIGH);
  digitalWrite(pinF, HIGH);
  digitalWrite(pinG, HIGH);
  digitalWrite(pinH, HIGH);

  delay(1000);
}

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 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)
    servo.write(85 - serial_byte); //set lower than the tach and speedo to limit movement.
  else
    servo.write(serial_byte);
}

void read_serial_byte_set_servo_cruise(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); //set lower than the tach and speedo to limit movement.
  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
  read_serial_byte_set_servo_fuel(fuel, SERVO_DIR_INVERT); // Fuel ratio
  skip_serial_byte(); // Oil pressure
  skip_serial_byte(); // Oil temperature
  skip_serial_byte(); // Water temperature
  skip_serial_byte(); // Battery voltage
  read_serial_byte_set_servo_cruise(cruise, SERVO_DIR_INVERT); // cruise speed, set to trip a light  

  if (cruise.read() < 180)
  {
      digitalWrite(CRUISE_CONTROL, 1);
      }
  if (cruise.read() > 179)
      {
      digitalWrite(CRUISE_CONTROL, 0);
      }
  
  // Truck lights byte
  serial_byte = Serial.read();
  digitalWriteFromBit(LEFT_INDICATOR,  serial_byte, 5);  
  digitalWriteFromBit(RIGHT_INDICATOR, serial_byte, 4);
  digitalWriteFromBit(LOW_BEAM,  serial_byte, 3);  
  digitalWriteFromBit(HIGH_BEAM, serial_byte, 2);
  
  
  // 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();
  
// Followed by text
  if (0 < text_len && text_len < 127)
  {
    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 == 'a')
       {
        //1
  digitalWrite(pinA, HIGH);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, HIGH);
  digitalWrite(pinD, HIGH);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, HIGH);
  digitalWrite(pinH, HIGH);
      }
       else  if (serial_byte == 'b')
       {
        //2
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, HIGH);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, HIGH);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, HIGH);
      }
       else  if (serial_byte == 'c')
       {
  //3
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, HIGH);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, HIGH);
      }
       else  if (serial_byte == 'd')
       {
  //4
  digitalWrite(pinA, HIGH);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, HIGH);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, HIGH);
      }
       else  if (serial_byte == 'e')
       {
  //5
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, HIGH);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, HIGH);
      }
       else  if (serial_byte == 'f')
       {
  //6
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, HIGH);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, HIGH);
      }
       else  if (serial_byte == 'g')
       {
  //7
  digitalWrite(pinA, HIGH);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, HIGH);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, HIGH);
  digitalWrite(pinH, HIGH);
      }
       else  if (serial_byte == 'h')
       {
 //8
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, HIGH);
      }
       else  if (serial_byte == 'i')
       {
  //9
  digitalWrite(pinA, HIGH);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, HIGH);
      }
       else  if (serial_byte == 'j')
       {
  //10
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, HIGH);
  digitalWrite(pinH, LOW);
      }
       else  if (serial_byte == 'k')
       {
  //11
  digitalWrite(pinA, HIGH);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, HIGH);
  digitalWrite(pinD, HIGH);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, HIGH);
  digitalWrite(pinH, LOW);
      }
       else  if (serial_byte == 'l')
       {
  //12
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, HIGH);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, HIGH);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, LOW);
      }
       else  if (serial_byte == 'm')
       {
  //13
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, HIGH);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, LOW);
      }
       else  if (serial_byte == 'n')
       {
  //14
  digitalWrite(pinA, HIGH);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, HIGH);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, LOW);
      }
       else  if (serial_byte == 'o')
       {
  //15
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, HIGH);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, LOW);
      }
       else  if (serial_byte == 'p')
       {
  //16
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, HIGH);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, LOW);
      }
       else  if (serial_byte == 'q')
       {
  //17
  digitalWrite(pinA, HIGH);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, HIGH);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, HIGH);
  digitalWrite(pinH, LOW);
      }
       else  if (serial_byte == 'r')
       {
  //18
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, LOW);
      }
       else  if (serial_byte == 's')
       {
  // R1
  digitalWrite(pinA, HIGH);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, HIGH);
  digitalWrite(pinD, HIGH);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, HIGH);
  digitalWrite(pinH, HIGH);
      }
       else  if (serial_byte == 't')
       {
  //R2
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, HIGH);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, HIGH);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, HIGH);
      }
       else  if (serial_byte == 'u')
       {
  //R3
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, HIGH);
  digitalWrite(pinD, LOW);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, HIGH);
      }
       else  if (serial_byte == 'v')
       {
  //R4
  digitalWrite(pinA, HIGH);
  digitalWrite(pinB, HIGH);
  digitalWrite(pinC, LOW);
  digitalWrite(pinD, HIGH);
  digitalWrite(pinE, LOW);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, HIGH);
      }
       else  if (serial_byte == 'w')
       {
  // Neutral
  digitalWrite(pinA, HIGH);
  digitalWrite(pinB, LOW);
  digitalWrite(pinC, HIGH);
  digitalWrite(pinD, HIGH);
  digitalWrite(pinE, HIGH);
  digitalWrite(pinF, LOW);
  digitalWrite(pinG, LOW);
  digitalWrite(pinH, HIGH);
        }
  //sets range splitter LED's
  if (serial_byte == 'a' || serial_byte == 'd' || serial_byte == 'g' || serial_byte == 'j' || serial_byte == 'm' || serial_byte == 'p' || serial_byte == 's' || serial_byte == 'v')
{
  digitalWrite(22, 1);
}
else
{
    digitalWrite(22, 0);
}
  if (serial_byte == 'b' || serial_byte == 'e' || serial_byte == 'h' || serial_byte == 'k' || serial_byte == 'n' || serial_byte == 'q' || serial_byte == 't')
{
  digitalWrite(24, 1);
}
else
{
    digitalWrite(24, 0);
}
  if (serial_byte == 'c' || serial_byte == 'f' || serial_byte == 'i' || serial_byte == 'l' || serial_byte == 'o' || serial_byte == 'r' || serial_byte == 'u')
{
  digitalWrite(26, 1);
}
else
{
    digitalWrite(26, 0);
}

    }
  }
}

Files URL:

lastchancename · July 29, 2023, 10:22pm

I’m guessing you didn’t write this, and have very little idea what it does.

I’m not going to read the whole spiel, but the speed value exists in the telemetry structure…. so you need to receive that, compare it to your threshold, and switch the required LED.

The code could be shortened significantly, and made easier to read - with a couple of hours work by a competent C developer.

system · January 25, 2024, 10:22pm

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
Reading serial data from PC General Guidance	35	2792	August 16, 2022
Connecting real car cluster with pc games (X-sim) Exhibition	23	42993	May 6, 2021
HUD per arduino Hardware	105	28881	May 7, 2021
Help needed in adding speed to my project(4WD RC Car) General Guidance	17	2657	May 5, 2021
Can someone help me combine these two scripts Interfacing	9	3159	May 6, 2021

Arduino car game dashboard

Related topics