controls.c

/*
 * ICSim++ 
 *		
 * Instrument Control Simulator
 * 
 * University of Adelaide
 *
 */

#include <pthread.h>
#include <math.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#include <getopt.h>
#include <signal.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <net/if.h>
#include <linux/can.h>
#include <linux/can/raw.h>
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include "lib.h"
#include <errno.h>



//////////////////////////////////
////GLOBAL CONSTAND VARIABLES/////
//////////////////////////////////
#ifndef DATA_DIR
#define DATA_DIR "./data/"
#endif
#define DEFAULT_CAN_TRAFFIC DATA_DIR "sample-can.log"
#define DEFAULT_CANFD_TRAFFIC DATA_DIR "sample-canfd.log"
#define DEFAULT_FUEL_CONSTANT_FACTOR 0.1;
#define DEFAULT_FUEL_CONSTANT_FACTOR_SPEED_DIVIDER 50;
#define DEFAULT_BATTERY_CONSTANT_FACTOR 3;
#define DEFAULT_DIFFICULTY 1
#define MAX_LINE_LENGTH 1024
#define Hold_On 1
#define Hold_Off 0
#define MAX_SEGMENTS 50
#define PORT 8080
#define BUFFER_SIZE 1024
#define MAX_CLIENTS 5

// 0 = No randomization added to the packets other than location and ID
// 1 = Add NULL padding
// 2 = Randomize unused bytes
//Powertrain IDs
#define DEFAULT_THROTTLE_ID 16 //0x010
#define DEFAULT_THROTTLE_POS 4
#define DEFAULT_RPM_ID 32 //0x020
#define DEFAULT_RPM_POS 1
#define DEFAULT_SPEED_ID 48 //0x030
#define DEFAULT_SPEED_POS 3
#define DEFAULT_ENGINE_LOAD_ID 64 //0x040
#define DEFAULT_ENGINE_LOAD_POS 2
#define DEFAULT_FUEL_TANK_ID 80 //0x050
#define DEFAULT_FUEL_TANK_POS 4
#define DEFAULT_AIR_FLOW_ID 96 //0x060
#define DEFAULT_AIR_FLOW_POS 1
#define DEFAULT_OXYGEN_SENSOR_ID 112 //0x070
#define DEFAULT_OXYGEN_SENSOR_POS 3
#define DEFAULT_BATTERY_ID 128 //0x080
#define DEFAULT_BATTERY_POS 0
#define DEFAULT_VVT_ID 144 //0x090
#define DEFAULT_VVT_POS 2
#define DEFAULT_OIL_TEMPERATURE_ID 160 //0x0A0
#define DEFAULT_OIL_TEMPERATURE_POS 4
#define DEFAULT_RADIATOR_TEMPERATURE_ID 176 //0x0B0
#define DEFAULT_RADIATOR_TEMPERATURE_POS 0
#define DEFAULT_GEAR_ID 192 //0x0C0
#define DEFAULT_GEAR_POS 3

//Chassis
#define DEFAULT_BRAKECONTROL_ID 512 //0x200
#define DEFAULT_BRAKECONTROL_POS 2
#define DEFAULT_HANDBRAKE_ID 528 //0x210
#define DEFAULT_HAND_BRAKE_POS 0
#define DEFAULT_STEERING_ID 544 //0x220
#define DEFAULT_STEERING_POS 5
#define DEFAULT_ABS_ID 560 //0x230
#define DEFAULT_ABS_POS 3
#define DEFAULT_AIRBAG_ID 576 //0x240
#define DEFAULT_AIRBAG_POS 1
#define DEFAULT_CRUISECONTROL_ID 592 //0x250
#define DEFAULT_CRUISECONTROL_POS 0


//Body
#define DEFAULT_DOOR_ID 1024 // 0x400
#define DEFAULT_DOOR_POS 5
#define DEFAULT_WINDOW_ID 1040 // 0x410
#define DEFAULT_WINDOW_POS 2
#define DEFAULT_LIGHT_ID 1056 //0x420
#define DEFAULT_LIGHT_POS 0
#define DEFAULT_SIGNAL_ID 1072 // 0x430
#define DEFAULT_SIGNAL_POS 3
#define DEFAULT_HAZARD_ID 1077 // 0x435
#define DEFAULT_HAZARD_POS 1
#define DEFAULT_WIPER_ID 1088 //0x440
#define DEFAULT_WIPER_POS 4
#define DEFAULT_SUNROOF_ID 1104 //0x450
#define DEFAULT_SUNROOF_POS 3
#define DEFAULT_SIDEMIRROR_ID 1120 //0x460
#define DEFAULT_SIDEMIRROR_POS 2
#define DEFAULT_TRUNK_ID 1136 //0x470
#define DEFAULT_TRUNK_POS 1
#define DEFAULT_HORN_ID 1152 //0x480
#define DEFAULT_HORN_POS 5




//Infotainment
#define DEFAULT_AUDIOSYSTEM_ID 1536 //0x600
#define DEFAULT_AUDIOSYSTEM_POS 3
#define DEFAULT_AIRCONDITION_ID 1552 //0x610
#define DEFAULT_AIRCONDITION_POS 1
#define DEFAULT_BLUETOOTH_ID 1568 //0x620
#define DEFAULT_BLUETOOTH_POS 5
#define DEFAULT_SATELITENAVIGATION_ID 1584 //0x630
#define DEFAULT_SATELITENAVIGATION_POS 0
#define DEFAULT_DEFROSTER_ID 1600 //0x640
#define DEFAULT_DEFROSTER_POS 4




#define CAN_DOOR1_LOCK 1
#define CAN_DOOR2_LOCK 2 
#define CAN_DOOR3_LOCK 4
#define CAN_DOOR4_LOCK 8
#define CAN_WINDOW1_LOCK 1
#define CAN_WINDOW2_LOCK 2 
#define CAN_WINDOW3_LOCK 4
#define CAN_WINDOW4_LOCK 8
#define CAN_LEFT_SIGNAL 1
#define CAN_RIGHT_SIGNAL 2
#define CAN_HAZARD_ON 0x05
#define CAN_HAZARD_OFF 0x06
#define CAN_LIGHT_ON 0x0B
#define CAN_LIGHT_OFF 0x0A
#define CAN_BLUETOOTH_ON 0x0B
#define CAN_BLUETOOTH_OFF 0x0A
#define CAN_AIRCONDITION_ON 0x08
#define CAN_AIRCONDITION_OFF 0x09
#define CAN_AIRCONDITION_Up 0x0A
#define CAN_AIRCONDITION_Down 0x0B
#define CAN_HANDBRAKE_ON 0x0F
#define CAN_HANDBRAKE_OFF 0x0E
#define CAN_BRAKECONTROL_ON 0x0D
#define CAN_BRAKECONTROL_OFF 0x0C
#define CAN_ABS_ON 0x03
#define CAN_ABS_OFF 0x04
#define CAN_WIPER_ON 0x09
#define CAN_WIPER_OFF 0x08
#define CAN_AIRBAG_ON 0x06
#define CAN_AIRBAG_OFF 0x07
#define CAN_TRUNK_ON 0x0C
#define CAN_TRUNK_OFF 0x0D
#define CAN_SIDEMIRROR_ON 0x0E
#define CAN_SIDEMIRROR_OFF 0x0F
#define CAN_SUNROOF_ON 0x01
#define CAN_SUNROOF_OFF 0x02
#define CAN_HORN_ON 0x09
#define CAN_HORN_OFF 0x08
#define CAN_CRUISECONTROL_ON 0x05
#define CAN_CRUISECONTROL_OFF 0x06
#define CAN_STEERING_ON 0x07
#define CAN_STEERING_OFF 0x08
#define ON 1
#define OFF 0
#define CAN_DEFROSTER_INIT 0
#define CAN_DEFROSTER_FRONT_ON 1
#define CAN_DEFROSTER_FRONT_OFF 2
#define CAN_DEFROSTER_REAR_ON 3
#define CAN_DEFROSTER_REAR_OFF 4
#define CAN_DEFROSTER_BOTH_ON 5
#define CAN_DEFROSTER_BOTH_OFF 6
#define CAN_RADIO_ON 1
#define CAN_RADIO_OFF 0
#define CAN_RADIO_NextStation 2
#define CAN_RADIO_PreviousStation 3
#define CAN_RADIO_VolumeUp 4
#define CAN_RADIO_VolumeDown 5
#define DOOR_LOCKED 0
#define DOOR_UNLOCKED 1
#define WINDOW_LOCKED 0
#define WINDOW_UNLOCKED 1
#define SCREEN_WIDTH 720
#define SCREEN_HEIGHT 486
#define JOY_UNKNOWN -1
#define BUTTON_LOCK 4
#define PS3_BUTTON_LOCK 10
#define BUTTON_UNLOCK 5
#define PS3_BUTTON_UNLOCK 11
#define BUTTON_A 0
#define PS3_BUTTON_A 14
#define BUTTON_B 1
#define PS3_BUTTON_B 13
#define BUTTON_X 2
#define PS3_BUTTON_X 15 
#define BUTTON_Y 3
#define PS3_BUTTON_Y 12
#define BUTTON_START 7
#define BUTTON_L 8
#define BUTTON_H 9
#define PS3_BUTTON_L 16
#define PS3_BUTTON_H 17
#define PS3_BUTTON_START 3
#define AXIS_LEFT_V 0
#define PS3_AXIS_LEFT_V 0
#define AXIS_LEFT_H 1
#define PS3_AXIS_LEFT_H 1
#define AXIS_L2 2
#define PS3_AXIS_L2 12
#define AXIS_RIGHT_H 3
#define PS3_AXIS_RIGHT_H 3
#define AXIS_RIGHT_V 4
#define PS3_AXIS_RIGHT_V 2
#define AXIS_R2 5
#define PS3_AXIS_R2 13
#define PS3_X_ROT 4
#define PS3_Y_ROT 5
#define PS3_Z_ROT 6 // The rotations are just guessed
#define MAX_RPM 5000.0 
#define MAX_OIL_TEMPERATURE 95 
#define MAX_SPEED 90.0 // Limiter 260.0 is full guage speed
#define MAX_STEERING_Angle 90.0
#define ACCEL_RATE 8.0 // 0-MAX_SPEED in seconds
#define USB_CONTROLLER 0
#define PS3_CONTROLLER 1




//////////////////////////////////
////VARIABLES INITIALIZATION//////
//////////////////////////////////
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; 
char vcanName[50];

int gButtonY = BUTTON_Y;
int gButtonX = BUTTON_X;
int gButtonA = BUTTON_A;
int gButtonB = BUTTON_B;
int gButtonL = BUTTON_L;
int gButtonH = BUTTON_H;
int gButtonStart = BUTTON_START;
int gButtonLock = BUTTON_LOCK;
int gButtonUnlock = BUTTON_UNLOCK;
int gAxisL2 = AXIS_L2;
int gAxisR2 = AXIS_R2;
int gAxisRightH = AXIS_RIGHT_H;
int gAxisRightV = AXIS_RIGHT_V;
int gAxisLeftH = AXIS_LEFT_H;
int gAxisLeftV = AXIS_LEFT_V;
// Acelleromoter axis info
int gJoyX = JOY_UNKNOWN;
int gJoyY = JOY_UNKNOWN;
int gJoyZ = JOY_UNKNOWN;

//CAN / CANFD 
int CANType = CAN_MTU;
int maxdlen;

#define DEFAULT_LOG_ALL_FRAMES 0
#define Frame_Log_Level_All 1
#define Frame_Log_Level_Both_User_System 2
#define Frame_Log_Level_UserOnly 3
#define Frame_Log_Level_SegmentOnly 4


//Network Segment Structure
typedef struct {
    char name[20];
    char interface[10];
    unsigned int start_id;
    unsigned int end_id;
    int socket;
} NetworkSegment;
NetworkSegment segments[MAX_SEGMENTS];
int num_segments = -1;

//Analog joystick dead zone
const int JOYSTICK_DEAD_ZONE = 8000;
int gLastAccelValue = 0; // Non analog R2

int s; // socket
struct canfd_frame cf;
char *traffic_log = DEFAULT_CAN_TRAFFIC;
struct ifreq ifr;
int door_pos = DEFAULT_DOOR_POS;
int window_pos = DEFAULT_WINDOW_POS;
int signal_pos = DEFAULT_SIGNAL_POS;
int speed_pos = DEFAULT_SPEED_POS;
int rpm_pos = DEFAULT_RPM_POS;
int oil_temp_pos = DEFAULT_OIL_TEMPERATURE_POS;
int radiator_temp_pos = DEFAULT_RADIATOR_TEMPERATURE_POS;
int engine_load_pos = DEFAULT_ENGINE_LOAD_POS;
int air_flow_pos = DEFAULT_AIR_FLOW_POS;
int VVT_pos = DEFAULT_VVT_POS;
int gear_pos = DEFAULT_GEAR_POS;
int oxygen_sensor_pos = DEFAULT_OXYGEN_SENSOR_POS;
int battery_pos = DEFAULT_BATTERY_POS;
int throttle_pos = DEFAULT_THROTTLE_POS;
int fuel_pos = DEFAULT_FUEL_TANK_POS;
int light_pos = DEFAULT_LIGHT_POS;
int light_len = DEFAULT_LIGHT_POS;
int door_len = DEFAULT_DOOR_POS;
int window_len = DEFAULT_WINDOW_POS;
int bluetooth_len = DEFAULT_BLUETOOTH_POS;
int bluetooth_pos = DEFAULT_BLUETOOTH_POS;
int audiosys_len = DEFAULT_AUDIOSYSTEM_POS;
int audiosys_pos = DEFAULT_AUDIOSYSTEM_POS;
int aircondition_len = DEFAULT_AIRCONDITION_POS;
int aircondition_pos = DEFAULT_AIRCONDITION_POS;
int satelitenavigation_len = DEFAULT_SATELITENAVIGATION_POS;
int satelitenavigation_pos = DEFAULT_SATELITENAVIGATION_POS;
int defroster_len = DEFAULT_DEFROSTER_POS;
int defroster_pos = DEFAULT_DEFROSTER_POS;
int hand_brake_pos = DEFAULT_HAND_BRAKE_POS;
int hand_brake_len = DEFAULT_HAND_BRAKE_POS;
int brakecontrol_len = DEFAULT_BRAKECONTROL_POS;
int brakecontrol_pos = DEFAULT_BRAKECONTROL_POS;
int abs_len = DEFAULT_ABS_POS;
int abs_pos = DEFAULT_ABS_POS;
int wiper_pos = DEFAULT_WIPER_POS;
int wiper_len = DEFAULT_WIPER_POS;
int airbag_pos = DEFAULT_AIRBAG_POS;
int airbag_len = DEFAULT_AIRBAG_POS;
int hazard_pos = DEFAULT_HAZARD_POS;
int hazard_len = DEFAULT_HAZARD_POS;
int sunroof_pos = DEFAULT_SUNROOF_POS;
int sunroof_len = DEFAULT_SUNROOF_POS;
int sidemirror_pos = DEFAULT_SIDEMIRROR_POS;
int sidemirror_len = DEFAULT_SIDEMIRROR_POS;
int trunk_pos = DEFAULT_TRUNK_POS;
int trunk_len = DEFAULT_TRUNK_POS;
int horn_pos = DEFAULT_HORN_POS;
int horn_len = DEFAULT_HORN_POS;
int steering_pos = DEFAULT_STEERING_POS;
int steering_len = DEFAULT_STEERING_POS;
int cruisecontrol_pos = DEFAULT_CRUISECONTROL_POS;
int cruisecontrol_len = DEFAULT_CRUISECONTROL_POS;
int signal_len = DEFAULT_SIGNAL_POS;
int speed_len = DEFAULT_SPEED_POS;
int rpm_len = DEFAULT_RPM_POS;
int oil_temp_len = DEFAULT_OIL_TEMPERATURE_POS;
int radiator_temp_len = DEFAULT_RADIATOR_TEMPERATURE_POS;
int engine_load_len = DEFAULT_ENGINE_LOAD_POS;
int gear_len = DEFAULT_GEAR_POS;
int oxygen_sensor_len = DEFAULT_OXYGEN_SENSOR_POS;
int air_flow_len = DEFAULT_AIR_FLOW_POS;
int VVT_len = DEFAULT_VVT_POS;
int fuel_len = DEFAULT_FUEL_TANK_POS;
int battery_len = DEFAULT_BATTERY_POS;
int throttle_len = DEFAULT_THROTTLE_POS;
int difficulty = DEFAULT_DIFFICULTY;
char *script_path = NULL;

int lock_enabled = 0;
int unlock_enabled = 0;
int left_shift_enabled = 0;
int right_shift_enabled = 0;
int left_ctrl_enabled = 0;
int right_ctrl_enabled = 0;
char door_state = 0xf;
char window_state = 0xf;
char signal_state = 0;
char last_signal_state = 0;
char light_status = CAN_LIGHT_OFF;
char lightButtonPressed = CAN_LIGHT_OFF;
char bluetooth_status = CAN_BLUETOOTH_OFF;
char audiosys_status = CAN_RADIO_OFF;
char aircondition_status = CAN_AIRCONDITION_OFF;
char satelitenavigation_status = OFF;
char defroster_status = CAN_DEFROSTER_INIT;
char hand_brake_status = CAN_HANDBRAKE_OFF;
char handbrakeOn = CAN_HANDBRAKE_OFF;
char brakecontrol_status = CAN_BRAKECONTROL_OFF;
char abs_status = CAN_ABS_OFF;
char wiper_status = CAN_WIPER_OFF;
char wiperOn = CAN_WIPER_OFF;
char airbag_status = CAN_AIRBAG_OFF;
char hazard_status = CAN_HAZARD_OFF;
char sunroof_status = CAN_SUNROOF_OFF;
char sidemirror_status = CAN_SIDEMIRROR_OFF;
char trunk_status = CAN_TRUNK_OFF;
char horn_status = CAN_HORN_OFF;
char cruisecontrol_status = CAN_CRUISECONTROL_OFF;
int current_throttle_status = OFF;
int throttle = 0;
float throttle_position = 0;
int current_gear = 1;
float current_gear_factor = 8.056;
float current_oxygen_sensor = 0.9;
float speed_brake_throttle = 1.0;
float current_speed = 10;
char current_steering_angle = 0;
int current_rpm = 900;
int current_aircondition_value = 20;
float current_oil_temp = 0;
float current_radiator_temp = 0;
float current_engine_load = 0;
float current_air_flow = 0;
float current_VVT = 0;
float current_battery = 1000;
int charging_status = 0;
float current_fuel = 100;
int turning = 0;
int door_id, signal_id, speed_id, light_id, handbrake_id, wiper_id, rpm_id, oil_temp_id, radiator_temp_id, battery_id, fuel_id, throttle_id, bluetooth_id, audiosys_id, aircondition_id, satelitenavigation_id, defroster_id, brakecontrol_id, abs_id, cruisecontrol_id, steering_id, window_id, horn_id, trunk_id, sidemirror_id, sunroof_id, hazard_id, airbag_id, engine_load_id, gear_id, air_flow_id, oxygen_sensor_id, VVT_id;
int currentTime;
int lastAccel = 0;
int lastTempCheck = 0;
int timeinmiliseconds = 0;
int lastTurnSignal = 0;
int scripted_delay_time = 0;

int seed = 0;
int debug = 0;
int scripted_input = 0;

int play_id;
int gateway_id;
int kk = 0;
char data_file[256];
SDL_GameController *gGameController = NULL;
SDL_Joystick *gJoystick = NULL;
SDL_Haptic *gHaptic = NULL;
SDL_Renderer *renderer = NULL;
SDL_Texture *base_texture = NULL;
int gControllerType = USB_CONTROLLER;
pthread_t inputThread;
int server_fd = -1;
pthread_mutex_t cleanup_lock = PTHREAD_MUTEX_INITIALIZER;


// Function prototype
void *process_line(char *line);
char *trim_whitespace(char *str);
void *script_processor();
void simulate_key_press(SDL_Keycode key, int isHold);
char *convert_to_lowercase(char *line);
void kk_check(int);


void cleanup_resources(int client_socket) {
    if (client_socket != -1) {
        close(client_socket);
        printf("Client socket closed.\n");
    }
    if (server_fd != -1) {
        close(server_fd);
        printf("Server socket closed.\n");
    }
    pthread_mutex_destroy(&cleanup_lock);
}

void sigint_handler(int signo) {
	(void)signo;  // Suppress unused parameter warning
    pthread_mutex_lock(&cleanup_lock);
    cleanup_resources(-1);
    pthread_mutex_unlock(&cleanup_lock);
    exit(0);
}

void socket_server_cleanup() {
    if (server_fd != -1) {
        close(server_fd);
        printf("Socket closed.\n");
    }
}


void *socket_server(void *arg) {
	(void)arg;// Suppress unused parameter warning
    int new_socket = -1;
    struct sockaddr_in address;
    char buffer[BUFFER_SIZE];
    int addrlen = sizeof(address);

    // Set up server socket
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        perror("Socket creation failed");
        pthread_exit(NULL);
    }

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) == -1) {
        perror("Bind failed");
        cleanup_resources(-1);
        pthread_exit(NULL);
    }

    if (listen(server_fd, MAX_CLIENTS) == -1) {
        perror("Listen failed");
        cleanup_resources(-1);
        pthread_exit(NULL);
    }

    printf("Server listening on port %d...\n", PORT);

    while (1) {
        // Accept a new client connection
        if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen)) == -1) {
            perror("Accept failed");
            continue;
        }

        printf("Client connected.\n");

        // Handle client messages
        while (1) {
            memset(buffer, 0, BUFFER_SIZE);
            ssize_t bytes_read = read(new_socket, buffer, BUFFER_SIZE - 1);
            if (bytes_read <= 0) {
                if (bytes_read == 0) {
                    printf("Client disconnected.\n");
                } else {
                    perror("Read error");
                }
                break;
            }

            printf("Received: %s\n", buffer);

            // Respond to the client
            const char *response = "Message received.\n";

			// Process the received command
            process_line(buffer);
			
            if (send(new_socket, response, strlen(response), 0) == -1) {
                perror("Send error");
                break;
            }
        }

        close(new_socket);
        new_socket = -1;
    }

    cleanup_resources(new_socket);
    pthread_exit(NULL);
}

// Adds data dir to file name
// Uses a single pointer so not to have a memory leak
// returns point to data_files or NULL if append is too large
char *get_data(char *fname) {
  if(strlen(DATA_DIR) + strlen(fname) > 255) return NULL;
  strncpy(data_file, DATA_DIR, 255);
  strncat(data_file, fname, 255-strlen(data_file));
  return data_file;
}


//////////////////////////////////
////SEND PACKET///////////////////
//////////////////////////////////
void send_pkt(int mtu) {
    int i;
	pthread_mutex_lock(&lock);
    for (i = 0; i < num_segments; i++) {
        if (cf.can_id >= segments[i].start_id && cf.can_id <= segments[i].end_id) {
            if (write(segments[i].socket, &cf, mtu) != mtu) {
                perror("write");
            }
			pthread_mutex_unlock(&lock);
            return;
        }
    }
	pthread_mutex_unlock(&lock);
    printf("CAN ID 0x%X is not in any valid segment range\n", cf.can_id);
}

void send_pkt_old(int mtu) {
  if(write(s, &cf, mtu) != mtu) {
	perror("write");
  }
}


NetworkSegment get_segment_name(struct canfd_frame *cf)
{
	for (int i = 0; i < num_segments; i++) {
        if (cf->can_id >= segments[i].start_id && cf->can_id <= segments[i].end_id) {
            return segments[i];
        }
    }

    // Return a default NetworkSegment if no match is found
    NetworkSegment default_segment = {0}; // Zero-initialize all fields
    return default_segment;
  
}


//////////////////////////////////
////Randomizes bytes in CAN packet if difficulty is hard enough
//////////////////////////////////
void randomize_pkt(int start, int stop) {
	if (difficulty < 2) return;
	int i = start;
	for(;i < stop;i++) {
		if(rand() % 3 < 1) cf.data[i] = rand() % 255;
	}
}


//////////////////////////////////
////SEND DOOR LOCK PACKET/////////
//////////////////////////////////
void send_lock(char door) {
	door_state |= door;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = door_id;
	cf.len = door_len;
	cf.data[door_pos] = door_state;
	if (door_pos) randomize_pkt(0, door_pos);
	if (door_len != door_pos + 1) randomize_pkt(door_pos + 1, door_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND DOOR UNLOCK PACKET///////
//////////////////////////////////
void send_unlock(char door) {
	door_state &= ~door;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = door_id;
	cf.len = door_len;
	cf.data[door_pos] = door_state;
	if (door_pos) randomize_pkt(0, door_pos);
	if (door_len != door_pos + 1) randomize_pkt(door_pos + 1, door_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND WINDOW LOCK PACKET/////////
//////////////////////////////////
void send_window_lock(char window) {
	window_state |= window;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = window_id;
	cf.len = window_len;
	cf.data[window_pos] = window_state;
	if (window_pos) randomize_pkt(0, window_pos);
	if (window_len != window_pos + 1) randomize_pkt(window_pos + 1, window_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND WINDOW UNLOCK PACKET///////
//////////////////////////////////
void send_window_unlock(char window) {
	window_state &= ~window;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = window_id;
	cf.len = window_len;
	cf.data[window_pos] = window_state;
	if (window_pos) randomize_pkt(0, window_pos);
	if (window_len != window_pos + 1) randomize_pkt(window_pos + 1, window_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND HEAD LIGHT PACKET////////
//////////////////////////////////
void send_light_signal(char light) {
	light_status = light;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = light_id;
	cf.len = light_len;
	cf.data[light_pos] = light_status;
	if (light_pos) randomize_pkt(0, light_pos);
	if (light_len != light_pos + 1) randomize_pkt(light_pos + 1, light_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND BLUETOOTH PACKET////////
//////////////////////////////////
void send_bluetooth_signal(char bluetooth) {
	bluetooth_status = bluetooth;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = bluetooth_id;
	cf.len = bluetooth_len;
	cf.data[bluetooth_pos] = bluetooth_status;
	if (bluetooth_pos) randomize_pkt(0, bluetooth_pos);
	if (bluetooth_len != bluetooth_pos + 1) randomize_pkt(bluetooth_pos + 1, bluetooth_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND AUDIOSYSTEM PACKET////////
//////////////////////////////////
void send_audiosys_signal(char audiosys) {
	memset(&cf, 0, sizeof(cf));
	cf.can_id = audiosys_id;
	cf.len = audiosys_len;
	cf.data[audiosys_pos] = audiosys;
	if (audiosys_pos) randomize_pkt(0, audiosys_pos);
	if (audiosys_len != audiosys_pos + 1) randomize_pkt(audiosys_pos + 1, audiosys_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND SATELITE NAVIGATION PACKET////////
//////////////////////////////////
void send_satelitenavigation_signal(char satelitenavigation) {
	satelitenavigation_status = satelitenavigation;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = satelitenavigation_id;
	cf.len = satelitenavigation_len;
	cf.data[satelitenavigation_pos] = satelitenavigation_status;
	if (satelitenavigation_pos) randomize_pkt(0, satelitenavigation_pos);
	if (satelitenavigation_len != satelitenavigation_pos + 1) randomize_pkt(satelitenavigation_pos + 1, satelitenavigation_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}

//////////////////////////////////
////SEND DEFROSTER PACKET////////
//////////////////////////////////
void send_defroster_signal(char defroster) {
	defroster_status = defroster;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = defroster_id;
	cf.len = defroster_len;
	cf.data[defroster_pos] = defroster_status;
	if (defroster_pos) randomize_pkt(0, defroster_pos);
	if (defroster_len != defroster_pos + 1) randomize_pkt(defroster_pos + 1, defroster_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND HANDBRAKE PACKET/////////
//////////////////////////////////
void send_hand_brake_signal(char hand_brake) {
	hand_brake_status = hand_brake;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = handbrake_id;
	cf.len = hand_brake_len;
	cf.data[hand_brake_pos] = hand_brake_status;
	if (hand_brake_pos) randomize_pkt(0, hand_brake_pos);
	if (hand_brake_len != hand_brake_pos + 1) randomize_pkt(hand_brake_pos + 1, hand_brake_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND BRAKE CONTROL PACKET/////////
//////////////////////////////////
void send_brakecontrol_signal(char brakecontrol) {
	brakecontrol_status = brakecontrol;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = brakecontrol_id;
	cf.len = brakecontrol_len;
	cf.data[brakecontrol_pos] = brakecontrol_status;
	if (brakecontrol_pos) randomize_pkt(0, brakecontrol_pos);
	if (brakecontrol_len != brakecontrol_pos + 1) randomize_pkt(brakecontrol_pos + 1, brakecontrol_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND Anti-lock Braking System PACKET/////////
//////////////////////////////////
void send_abs_signal(char abs) {
	abs_status = abs;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = abs_id;
	cf.len = abs_len;
	cf.data[abs_pos] = abs_status;
	if (abs_pos) randomize_pkt(0, abs_pos);
	if (abs_len != abs_pos + 1) randomize_pkt(abs_pos + 1, abs_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}



//////////////////////////////////
////SEND WIPER PACKET/////////////
//////////////////////////////////
void send_wiper_signal(char wiper) {
	wiper_status = wiper;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = wiper_id;
	cf.len = wiper_len;
	cf.data[wiper_pos] = wiper_status;
	if (wiper_pos) randomize_pkt(0, wiper_pos);
	if (wiper_len != wiper_pos + 1) randomize_pkt(wiper_pos + 1, wiper_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}

//////////////////////////////////
////SEND airbag PACKET/////////////
//////////////////////////////////
void send_airbag_signal(char airbag) {
	airbag_status = airbag;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = airbag_id;
	cf.len = airbag_len;
	cf.data[airbag_pos] = airbag_status;
	if (airbag_pos) randomize_pkt(0, airbag_pos);
	if (airbag_len != airbag_pos + 1) randomize_pkt(airbag_pos + 1, airbag_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND HAZARD PACKET/////////////
//////////////////////////////////
void send_hazard_signal(char hazard) {
	hazard_status = hazard;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = hazard_id;
	cf.len = hazard_len;
	cf.data[hazard_pos] = hazard_status;
	if (hazard_pos) randomize_pkt(0, hazard_pos);
	if (hazard_len != hazard_pos + 1) randomize_pkt(hazard_pos + 1, hazard_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND sunroof PACKET/////////////
//////////////////////////////////
void send_sunroof_signal(char sunroof) {
	sunroof_status = sunroof;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = sunroof_id;
	cf.len = sunroof_len;
	cf.data[sunroof_pos] = sunroof_status;
	if (sunroof_pos) randomize_pkt(0, sunroof_pos);
	if (sunroof_len != sunroof_pos + 1) randomize_pkt(sunroof_pos + 1, sunroof_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND sidemirror PACKET/////////////
//////////////////////////////////
void send_sidemirror_signal(char sidemirror) {
	sidemirror_status = sidemirror;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = sidemirror_id;
	cf.len = sidemirror_len;
	cf.data[sidemirror_pos] = sidemirror_status;
	if (sidemirror_pos) randomize_pkt(0, sidemirror_pos);
	if (sidemirror_len != sidemirror_pos + 1) randomize_pkt(sidemirror_pos + 1, sidemirror_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}

//////////////////////////////////
////SEND TRUNK PACKET/////////////
//////////////////////////////////
void send_trunk_signal(char trunk) {
	trunk_status = trunk;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = trunk_id;
	cf.len = trunk_len;
	cf.data[trunk_pos] = trunk_status;
	if (trunk_pos) randomize_pkt(0, trunk_pos);
	if (trunk_len != trunk_pos + 1) randomize_pkt(trunk_pos + 1, trunk_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND CRUISECONTROL PACKET/////////////
//////////////////////////////////
void send_cruisecontrol_signal(char cruisecontrol) {
	cruisecontrol_status = cruisecontrol;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = cruisecontrol_id;
	cf.len = cruisecontrol_len;
	cf.data[cruisecontrol_pos] = cruisecontrol_status;
	if (cruisecontrol_pos) randomize_pkt(0, cruisecontrol_pos);
	if (cruisecontrol_len != cruisecontrol_pos + 1) randomize_pkt(cruisecontrol_pos + 1, cruisecontrol_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND SPEED PACKET/////////////
//////////////////////////////////
void send_speed() {
	
	memset(&cf, 0, sizeof(cf));
	int kph = (current_speed / 0.6213751) * 100;
	cf.can_id = speed_id;
	cf.len = speed_len;
	cf.data[speed_pos+1] = (char)kph & 0xff;
	cf.data[speed_pos] = (char)(kph >> 8) & 0xff;
	if(kph == 0) { // IDLE
		cf.data[speed_pos] = 1;
		cf.data[speed_pos+1] = rand() % 255+100;
	}
	if (speed_pos) randomize_pkt(0, speed_pos);
	if (speed_len != speed_pos + 2) randomize_pkt(speed_pos+2, speed_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}

}



//////////////////////////////////
////SEND RPM PACKET///////////////
//////////////////////////////////
void send_rpm() {
	memset(&cf, 0, sizeof(cf));
	cf.can_id = rpm_id;
	cf.len = rpm_len;
	cf.data[rpm_pos+1] = (char)current_rpm & 0xff;
	cf.data[rpm_pos] = (char)(current_rpm >> 8) & 0xff;
	if(current_rpm == 0) { // IDLE
		cf.data[rpm_pos] = 1;
		cf.data[rpm_pos+1] = rand() % 255+100;
	}
	if (rpm_pos) randomize_pkt(0, rpm_pos);
	if (rpm_len != rpm_pos + 2) randomize_pkt(rpm_pos+2, rpm_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND STEERING PACKET/////////////
//////////////////////////////////
void send_steering_angle() {
	int steering = (int)current_steering_angle;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = steering_id;
	cf.len = steering_len;
	cf.data[steering_pos+1] = (char)steering & 0xff;
	cf.data[steering_pos] = (char)(steering >> 8) & 0xff;
	
	if (steering_pos) randomize_pkt(0, steering_pos);
	if (steering_len != steering_pos + 2) randomize_pkt(steering_pos+2, steering_len);

	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}

}



//////////////////////////////////
////SEND OIL TEMPERATURE PACKET///
//////////////////////////////////
void send_oil_temp() {
	
	unsigned char* oil_temp = (unsigned char*)&current_oil_temp; // Pointer to access float bytes
	memset(&cf, 0, sizeof(cf));
	cf.can_id = oil_temp_id;
	cf.len = oil_temp_len;
	cf.data[oil_temp_pos] = (char)(oil_temp[0]) & 0xff;
	cf.data[oil_temp_pos+1] = (char)oil_temp[1] & 0xff;
	cf.data[oil_temp_pos+2] = (char)oil_temp[2] & 0xff;
	cf.data[oil_temp_pos+3] = (char)oil_temp[3] & 0xff;
	
	if (oil_temp_pos) randomize_pkt(0, oil_temp_pos);
	if (oil_temp_len != oil_temp_pos + 4) randomize_pkt(oil_temp_pos + 4, oil_temp_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
	
}


//////////////////////////////////
////SEND AIRCONDITION PACKET////////
//////////////////////////////////
void send_aircondition_signal(char aircondition) {
	memset(&cf, 0, sizeof(cf));
	cf.can_id = aircondition_id;
	cf.len = aircondition_len;
	cf.data[aircondition_pos] = aircondition;
	if (aircondition_pos) randomize_pkt(0, aircondition_pos);
	if (aircondition_len != aircondition_pos + 1) randomize_pkt(aircondition_pos + 1, aircondition_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}

//////////////////////////////////
////SEND RADIATOR TEMPERATURE PACKET
//////////////////////////////////
void send_radiator_temp() {
	
	unsigned char* radiator_temp = (unsigned char*)&current_radiator_temp; // Pointer to access float bytes
	memset(&cf, 0, sizeof(cf));
	cf.can_id = radiator_temp_id;
	cf.len = radiator_temp_len;
	cf.data[radiator_temp_pos] = (char)(radiator_temp[0]) & 0xff;
	cf.data[radiator_temp_pos+1] = (char)radiator_temp[1] & 0xff;
	cf.data[radiator_temp_pos+2] = (char)radiator_temp[2] & 0xff;
	cf.data[radiator_temp_pos+3] = (char)radiator_temp[3] & 0xff;
	
	if (radiator_temp_pos) randomize_pkt(0, radiator_temp_pos);
	if (radiator_temp_len != radiator_temp_pos + 4) randomize_pkt(radiator_temp_pos + 4, radiator_temp_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
	
}


//////////////////////////////////
////SEND ENGINE LOAD PACKET
//////////////////////////////////
void send_engine_load() {
	
	unsigned char* engine_load = (unsigned char*)&current_engine_load; // Pointer to access float bytes
	memset(&cf, 0, sizeof(cf));
	cf.can_id = engine_load_id;
	cf.len = engine_load_len;
	cf.data[engine_load_pos] = (char)(engine_load[0]) & 0xff;
	cf.data[engine_load_pos+1] = (char)engine_load[1] & 0xff;
	cf.data[engine_load_pos+2] = (char)engine_load[2] & 0xff;
	cf.data[engine_load_pos+3] = (char)engine_load[3] & 0xff;
	
	if (engine_load_pos) randomize_pkt(0, engine_load_pos);
	if (engine_load_len != engine_load_pos + 4) randomize_pkt(engine_load_pos + 4, engine_load_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
	
}


//////////////////////////////////
////SEND GEAR PACKET
//////////////////////////////////
void send_gear() {
	
	int gear = (int)current_gear;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = gear_id;
	cf.len = gear_len;
	cf.data[gear_pos+1] = (char)gear & 0xff;
	cf.data[gear_pos] = (char)(gear >> 8) & 0xff;
	
	if (gear_pos) randomize_pkt(0, gear_pos);
	if (gear_len != gear_pos + 2) randomize_pkt(gear_pos+2, gear_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
	
}


//////////////////////////////////
////SEND AIR FLOW PACKET
//////////////////////////////////
void send_air_flow() {
	
	unsigned char* air_flow = (unsigned char*)&current_air_flow; // Pointer to access float bytes
	memset(&cf, 0, sizeof(cf));
	cf.can_id = air_flow_id;
	cf.len = air_flow_len;
	cf.data[air_flow_pos] = (char)(air_flow[0]) & 0xff;
	cf.data[air_flow_pos+1] = (char)air_flow[1] & 0xff;
	cf.data[air_flow_pos+2] = (char)air_flow[2] & 0xff;
	cf.data[air_flow_pos+3] = (char)air_flow[3] & 0xff;
	
	if (air_flow_pos) randomize_pkt(0, air_flow_pos);
	if (air_flow_len != air_flow_pos + 4) randomize_pkt(air_flow_pos + 4, air_flow_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
	
}


//////////////////////////////////
////SEND VVT PACKET
//////////////////////////////////
void send_VVT() {
	
	unsigned char* VVT = (unsigned char*)&current_VVT; // Pointer to access float bytes
	memset(&cf, 0, sizeof(cf));
	cf.can_id = VVT_id;
	cf.len = VVT_len;
	cf.data[VVT_pos] = (char)(VVT[0]) & 0xff;
	cf.data[VVT_pos+1] = (char)VVT[1] & 0xff;
	cf.data[VVT_pos+2] = (char)VVT[2] & 0xff;
	cf.data[VVT_pos+3] = (char)VVT[3] & 0xff;
	
	if (VVT_pos) randomize_pkt(0, VVT_pos);
	if (VVT_len != VVT_pos + 4) randomize_pkt(VVT_pos + 4, VVT_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
	
}



//////////////////////////////////
////SEND AIR FLOW PACKET
//////////////////////////////////
void send_oxygen_sensor() {
	
	unsigned char* oxygen_sensor = (unsigned char*)&current_oxygen_sensor; // Pointer to access float bytes
	memset(&cf, 0, sizeof(cf));
	cf.can_id = oxygen_sensor_id;
	cf.len = oxygen_sensor_len;
	cf.data[oxygen_sensor_pos] = (char)(oxygen_sensor[0]) & 0xff;
	cf.data[oxygen_sensor_pos+1] = (char)oxygen_sensor[1] & 0xff;
	cf.data[oxygen_sensor_pos+2] = (char)oxygen_sensor[2] & 0xff;
	cf.data[oxygen_sensor_pos+3] = (char)oxygen_sensor[3] & 0xff;
	
	if (oxygen_sensor_pos) randomize_pkt(0, oxygen_sensor_pos);
	if (oxygen_sensor_len != oxygen_sensor_pos + 4) randomize_pkt(oxygen_sensor_pos+4, oxygen_sensor_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
	
}


//////////////////////////////////
////SEND FUEL GUAGE PACKET////////
//////////////////////////////////
void send_fuel_status() {
	
	unsigned char* fuel = (unsigned char*)&current_fuel; // Pointer to access float bytes
	memset(&cf, 0, sizeof(cf));
	cf.can_id = fuel_id;
	cf.len = fuel_len;
	cf.data[fuel_pos] = (char)(fuel[0]) & 0xff;
	cf.data[fuel_pos+1] = (char)fuel[1] & 0xff;
	cf.data[fuel_pos+2] = (char)fuel[2] & 0xff;
	cf.data[fuel_pos+3] = (char)fuel[3] & 0xff;
	
	if (fuel_pos) randomize_pkt(0, fuel_pos);
	if (fuel_len != fuel_pos + 4) randomize_pkt(fuel_pos + 4, fuel_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
	
}


//////////////////////////////////
////SEND BATTERY STATUS PACKET////
//////////////////////////////////
void send_battery_status() {
	
	unsigned char* battery = (unsigned char*)&current_battery; // Pointer to access float bytes
	memset(&cf, 0, sizeof(cf));
	cf.can_id = battery_id;
	cf.len = battery_len;
	cf.data[battery_pos] = (char)(battery[0]) & 0xff;
	cf.data[battery_pos+1] = (char)battery[1] & 0xff;
	cf.data[battery_pos+2] = (char)battery[2] & 0xff;
	cf.data[battery_pos+3] = (char)battery[3] & 0xff;
	
	if (battery_pos) randomize_pkt(0, battery_pos);
	if (battery_len != battery_pos + 4) randomize_pkt(battery_pos + 4, battery_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
	
}

//////////////////////////////////
////SEND THROTTLE STATUS PACKET////
//////////////////////////////////
void send_throttle_status(int throttle_status) {
	current_throttle_status = throttle_status;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = throttle_id;
	cf.len = throttle_len;
	cf.data[throttle_pos] = (char)current_throttle_status & 0xff;
	if (throttle_pos) randomize_pkt(0, throttle_pos);
	if (throttle_len != throttle_pos + 1) randomize_pkt(throttle_pos + 1, throttle_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND HORN STATUS PACKET////
//////////////////////////////////
void send_horn_status(int horn_status) {
	horn_status = horn_status;
	memset(&cf, 0, sizeof(cf));
	cf.can_id = horn_id;
	cf.len = horn_len;
	cf.data[horn_pos] = (char)horn_status & 0xff;
	if (horn_pos) randomize_pkt(0, horn_pos);
	if (horn_len != horn_pos + 1) randomize_pkt(horn_pos + 1, horn_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////SEND TURN SIGNAL PACKET///////
//////////////////////////////////
void send_turn_signal() {
	memset(&cf, 0, sizeof(cf));
	cf.can_id = signal_id;
	cf.len = signal_len;
	cf.data[signal_pos] = signal_state;
	if(signal_pos) randomize_pkt(0, signal_pos);
	if(signal_len != signal_pos + 1) randomize_pkt(signal_pos+1, signal_len);
	if(CANType == CAN_MTU)
	{
		send_pkt(CAN_MTU);
	}
	else{
		send_pkt(CANFD_MTU);
	}
}


//////////////////////////////////
////Checks throttle to see if we should accelerate or decelerate the vehicle
//////////////////////////////////
void checkAccel() {
	//float rate = MAX_SPEED / (ACCEL_RATE * 100);
	
	if(hand_brake_status == CAN_HANDBRAKE_ON)
	{
		if(speed_brake_throttle < 180)
		{
			speed_brake_throttle += 1;
			if(abs_status == CAN_ABS_ON)
			{
				if(speed_brake_throttle < 180)
				{
					speed_brake_throttle += 0.3;
				}
			}
			if(brakecontrol_status == CAN_BRAKECONTROL_ON)
			{
				if(speed_brake_throttle < 180)
				{
					speed_brake_throttle += 0.75;
				}
			}
		}
	}
	else if(brakecontrol_status == CAN_BRAKECONTROL_ON)
	{
		if(speed_brake_throttle < 180)
		{
			speed_brake_throttle += 0.75;
		}
		if(abs_status == CAN_ABS_ON)
		{
			if(speed_brake_throttle < 180)
			{
				speed_brake_throttle += 0.3;
			}
		}
	}
	else {
		if(speed_brake_throttle > 1)
		{
			speed_brake_throttle -= 1;
		}
		else 
		{
			speed_brake_throttle = 0;
		}
	}

	// Updated every 10 ms
	if(currentTime > lastAccel + 10) {
		timeinmiliseconds += 10;
		//if fuel ends then engine will off and speed reduces, rpm reduces
		if(current_fuel <= 0 || airbag_status == CAN_AIRBAG_ON)
		{
			if(current_throttle_status != OFF)
			{
				send_throttle_status(OFF);
			}
			throttle = -1;
		}
		if(throttle < 0) {
			if(cruisecontrol_status == CAN_CRUISECONTROL_OFF)
			{
				throttle_position -= 0.01;
			}
			if(throttle_position < 0)
			{
				throttle_position = 0;
			}

			//New Formula Speed = (RPM * 8.056) / 1000 - brake throttle
			current_speed = ((current_rpm * current_gear_factor)/1000) - speed_brake_throttle;
			if(current_speed < 1) current_speed = 0;

			current_rpm = 800 - 5200 * pow(throttle_position,2) + 10400 * throttle_position;
			if(current_rpm <= 0 && current_speed <= 0) current_rpm = 0;
			else if(current_rpm < 900 ) current_rpm = 900;
		} else if(throttle > 0) {
			if(hand_brake_status == CAN_HANDBRAKE_OFF)
			{
				throttle_position += (0.001);
			}

			if(throttle_position > 1)
			{
				throttle_position = 1;
			}
			//New RPM Formula RPM = 800 - 5200 * (TP)2  + 10400 * (TP) 
			current_rpm = 800 - 5200 * pow(throttle_position,2) + 10400 * throttle_position;
			if(current_rpm <= 0 && current_speed <= 0) current_rpm = 0;
			else if(current_rpm < 900 ) current_rpm = 900;


			//Air Flow Formula - Air Flow = 0.016733 * RPM (g/s)
			current_air_flow = 0.016733 * current_rpm;


			//Speed Formula
			if(hand_brake_status == CAN_HANDBRAKE_OFF && brakecontrol_status == CAN_BRAKECONTROL_OFF && abs_status == CAN_ABS_OFF)
			{
				current_speed = ((current_rpm * current_gear_factor)/1000) - speed_brake_throttle;
				if(current_speed < 1) current_speed = 0;
			}
			else 
			{
				current_speed = ((current_rpm * current_gear_factor)/1000) - speed_brake_throttle;
				if(current_speed < 1) current_speed = 0;
			}
			
		}


		if(current_speed >= 25 && current_speed < 40)
		{
			current_gear = 2;
			current_gear_factor = 13.236;
		}
		else if(current_speed >= 40 && current_speed < 65)
		{
			current_gear = 3;
			current_gear_factor = 20.56;
		}
		else if(current_speed >= 65)
		{
			current_gear = 4;
			current_gear_factor = 28.994;
		}
		else 
		{
			current_gear = 1;
			current_gear_factor = 8.056;
		}
		
		//update every 1000ms = 1sec
		if(currentTime > lastTempCheck + 1000)
		{
			//oil temp calculation Formula
			//Temperature (C) = 20 +  80 * (1 – e-0.001 * RPM * t ) where t is time seconds since the engine started
			//Range 20C to 100C
			current_oil_temp = 20 + 80 * (1 - exp(-0.001 * current_rpm * timeinmiliseconds/1000));
			// if(current_oil_temp < 20) {
			// 	current_oil_temp = 20;
			// }
			// if(current_oil_temp > 100)
			// {
			// 	current_oil_temp = 100;
			// }

			//radiator temp calculation Formula
			//Radiator Temperature = Oil Temperature - 10
			//Range 10C to 90C
			current_radiator_temp = current_oil_temp - 10;
			// if(current_radiator_temp < 10) {
			// 	current_radiator_temp = 10;
			// }
			// if(current_radiator_temp > 90)
			// {
			// 	current_radiator_temp = 90;
			// }

			//battery calculation Formula
			//Battery Gauge =  13.8+0.1* sin(6.283185 * time in mins)
			//Range 13.70 to 13.90
			current_battery = 13.8 + 0.1 * sin(6.283185 * (timeinmiliseconds/(60*1000)));;
			

			//fuel calculation Formula
			current_engine_load = 200 * pow((current_rpm/1000),0.9);
			//Power = 0.00002255 * EL (mg/stroke)* RPM
			float power = 0.00002255 * current_engine_load * current_rpm;
			//Fuel consumption = ((0.3 * Power) / 0.74) * 100  (L/h)
			float fuel_consumption = (((0.3 * power) / 0.74) * 100) * 0.0001;
			//Fuel Level Guage =  50 – ((Fuel consumption * t) / 3600) 
			//Range 0 - 50 Liters
			current_fuel = 50 - ((fuel_consumption * (timeinmiliseconds/1000)) / 3600); 




			//Fuel Flow = 0.2056 * Fuel Consumption (L/h)
			float fuel_flow = 0.2056 * fuel_consumption;
			//Air Flow Ratio
			//AFR = Air Flow (g/s) / Fuel Flow (g/s)
			float air_flow_radio = current_air_flow / fuel_flow;
			//Oxygen Sensor has two voltage values depending on Air-Fuel Ratio (AFR) 0.1 V if AFR > 14.7 , 0.9 V if AFR < 14.7
			if(air_flow_radio > 14.7)
			{
				current_oxygen_sensor = 0.1;
			}
			else
			{
				current_oxygen_sensor = 0.9;	
			}

			//VVT Formula
			if(current_rpm < 1000)
			{
				current_VVT = 0;
			}
			current_VVT = 0.008 * ( current_rpm - 1000);
			if (current_rpm > 6000 || current_VVT > 40)
			{
				current_VVT = 40;
			}


			if(current_fuel <= 0 || airbag_status == CAN_AIRBAG_ON)
			{
				current_fuel = 0;
				current_speed = 0;
				current_rpm = 0;
				current_oil_temp = 0;
				current_radiator_temp = 0;
				current_battery = 0;
				current_engine_load = 0;
			}

			//send packets
			send_oil_temp();
			send_radiator_temp();
			send_battery_status();
			send_fuel_status();
			send_engine_load();
			send_gear();
			send_air_flow();
			send_oxygen_sensor();
			send_VVT();
			lastTempCheck = currentTime;
		}
		
		send_speed();
		send_rpm();
		lastAccel = currentTime;
	}
}


//////////////////////////////////
////Checks if turning and activates the turn signal
//////////////////////////////////
void checkTurn() {
	if(currentTime > lastTurnSignal + 500) {
		if(turning < 0) {
			signal_state ^= CAN_LEFT_SIGNAL;
		} else if(turning > 0) {
			signal_state ^= CAN_RIGHT_SIGNAL;
		} else {
			signal_state = 0;
		}
		if(signal_state != last_signal_state)
		{
			send_turn_signal();
		}
		lastTurnSignal = currentTime;
		last_signal_state= signal_state;
	}
}


//////////////////////////////////
////Set Accelrator Throttle///////
//////////////////////////////////
// Takes R2 joystick value and converts it to throttle speed
void accelerate(int value) {
	// Check dead zones
	printf("\n\nAccelrate\n\n");
	if(gControllerType == PS3_CONTROLLER) {
		printf("here");
		// PS3 works different.  the value range is 0-32k
		if (value < gLastAccelValue) {
			if(current_throttle_status != OFF)
			{
				send_throttle_status(OFF);
			}
			throttle = -1;
		} else if (value > gLastAccelValue) {
			if(current_throttle_status != ON)
			{
				send_throttle_status(ON);
				if(cruisecontrol_status == CAN_CRUISECONTROL_ON)
				{
					cruisecontrol_status = CAN_CRUISECONTROL_OFF;
					send_cruisecontrol_signal(CAN_CRUISECONTROL_OFF);
				}
			}
			throttle = 1;
		} else {
			if(current_throttle_status != OFF)
			{
				send_throttle_status(OFF);
			}
			throttle = 0;
		}
		gLastAccelValue = value;
	} else {
		printf("there");
		if(value < -JOYSTICK_DEAD_ZONE) {
			throttle = -1;
		} else if(value > JOYSTICK_DEAD_ZONE) {
			if(current_throttle_status != ON)
			{
				send_throttle_status(ON);
				if(cruisecontrol_status == CAN_CRUISECONTROL_ON)
				{
					cruisecontrol_status = CAN_CRUISECONTROL_OFF;
					send_cruisecontrol_signal(CAN_CRUISECONTROL_OFF);
				}
			}
			throttle = 1;
		} else {
			if(current_throttle_status != OFF)
			{
				send_throttle_status(OFF);
			}
			throttle = 0;
		}
	}
}


//////////////////////////////////
////Check LEFT_V axis to see if we are turning
//////////////////////////////////
void turn(int value) {
	if(value < -JOYSTICK_DEAD_ZONE) {
		turning = -1;
		kk_check(SDLK_f);
	} else if(value > JOYSTICK_DEAD_ZONE) {
		turning = 1;
		kk_check(SDLK_g);
	} else {
		turning = 0;
	}
}

void ud(int value) {
	if(value < -JOYSTICK_DEAD_ZONE) {
		kk_check(SDLK_UP);
	} else if(value > JOYSTICK_DEAD_ZONE) {
		kk_check(SDLK_DOWN);
	}
}

void kkpay() {
  printf("KK\n");
}

void kk_check(int k) {
  switch(k) {
    case SDLK_RETURN:
	if(kk == 0xa) kkpay();
	kk = 0;
	break;
    case SDLK_UP:
	kk = (kk < 2) ? kk+1 : 0;
	break;
    case SDLK_DOWN:
	kk = (kk > 1 && kk < 4) ? kk+1 : 0;
	break;
    case SDLK_f:
	kk = (kk == 4 || kk == 6) ? kk+1 : 0;
	break;
    case SDLK_g:
	kk = (kk == 5 || kk == 7) ? kk+1 : 0;
	break;
    case SDLK_e:
	kk = kk == 9 ? kk+1 : 0;
	break;
    case SDLK_q:
	kk = kk == 8 ? kk+1 : 0;
	break;
    default:
	kk = 0;
  }
}


//////////////////////////////////
////Plays background can traffic//
//////////////////////////////////
void play_can_traffic() {
	char can2can[50];
	snprintf(can2can, 49, "%s=can0", ifr.ifr_name);
	if(execlp("canplayer", "canplayer", "-I", traffic_log, "-l", "i", can2can, NULL) == -1) printf("WARNING: Could not execute canplayer. No bg data\n");
}


//////////////////////////////////
////Run Gateway//
//////////////////////////////////
void run_can_gateway() {
	if(execlp("./gateway", "./gateway", "vcan0", "vcan1", "vcan2", "vcan3", "vcan4", "vcan5", NULL) == -1) printf("WARNING: Could not execute gateway. \n");
}



//////////////////////////////////
////KILL CHILD/////////////////
//////////////////////////////////
void kill_child() {
	kill(play_id, SIGINT);
}

void kill_gateway_child() {
	kill(gateway_id, SIGINT);
}


//////////////////////////////////
////REDRAW SCREEN/////////////////
//////////////////////////////////
void redraw_screen() {
  SDL_RenderCopy(renderer, base_texture, NULL, NULL);
  SDL_RenderPresent(renderer);
}


//////////////////////////////////
////Maps the controllers buttons//
//////////////////////////////////
void map_joy() {
	switch(gControllerType) {
	case USB_CONTROLLER:
		gButtonA = BUTTON_A;
		gButtonB = BUTTON_B;
		gButtonX = BUTTON_X;
		gButtonY = BUTTON_Y;
		gButtonL = BUTTON_L;
		gButtonH = BUTTON_H;
		gButtonStart = BUTTON_START;
		gButtonLock = BUTTON_LOCK;
		gButtonUnlock = BUTTON_UNLOCK;
		gAxisL2 = AXIS_L2;
		gAxisR2 = AXIS_R2;
		gAxisRightH = AXIS_RIGHT_H;
		gAxisRightV = AXIS_RIGHT_V;
		gAxisLeftH = AXIS_LEFT_H;
		gAxisLeftV = AXIS_LEFT_V;
		break;
	case PS3_CONTROLLER:
		gButtonA = PS3_BUTTON_A;
		gButtonB = PS3_BUTTON_B;
		gButtonX = PS3_BUTTON_X;
		gButtonY = PS3_BUTTON_Y;
		gButtonL = PS3_BUTTON_L;
		gButtonH = PS3_BUTTON_H;
		gButtonStart = PS3_BUTTON_START;
		gButtonLock = PS3_BUTTON_LOCK;
		gButtonUnlock = PS3_BUTTON_UNLOCK;
		gAxisL2 = PS3_AXIS_L2;
		gAxisR2 = PS3_AXIS_R2;
		gAxisRightH = PS3_AXIS_RIGHT_H;
		gAxisRightV = PS3_AXIS_RIGHT_V;
		gAxisLeftH = PS3_AXIS_LEFT_H;
		gAxisLeftV = PS3_AXIS_LEFT_V;
		gJoyX = PS3_X_ROT;
		gJoyY = PS3_Y_ROT;
		gJoyZ = PS3_Z_ROT;
 		break; 
	default:
	printf("Unknown controller type for mapping\n");
  	}
}


//////////////////////////////////
////PRINT JOYSTICK INFO///////////
//////////////////////////////////
void print_joy_info() {
	printf("Name: %s\n", SDL_JoystickNameForIndex(0));
	printf("Number of Axes: %d\n", SDL_JoystickNumAxes(gJoystick));
	printf("Number of Buttons: %d\n", SDL_JoystickNumButtons(gJoystick));
	if(SDL_JoystickNumBalls(gJoystick) > 0) printf("Number of Balls: %d\n", SDL_JoystickNumBalls(gJoystick));
        if(strncmp(SDL_JoystickNameForIndex(0), "PLAYSTATION(R)3 Controller", 25) == 0) {
		// PS3 Rumble controller via BT
		gControllerType = PS3_CONTROLLER;
	}
        if(strncmp(SDL_JoystickNameForIndex(0), "Sony PLAYSTATION(R)3 Controller", 30) == 0) {
		// PS3 directly connected
		gControllerType = PS3_CONTROLLER;
	}
	map_joy();
}


//////////////////////////////////
////PRINT USAGE INFO//////////////
//////////////////////////////////
void usage(char *msg) {
  if(msg) printf("%s\n", msg);
  printf("Usage: controls [options] <can>\n");
  printf("\t-s\tseed value from IC\n");
  printf("\t-l\tdifficulty level. 0-2 (default: %d)\n", DEFAULT_DIFFICULTY);
  printf("\t-t\ttraffic file to use for bg CAN traffic\n");
  printf("\t-I\tScripted input for play scripted input to CANbus\n");
  printf("\t-F\tFor using CANFD Frame while transmission\n");
  printf("\t-X\tDisable background CAN traffic.  Cheating if doing RE but needed if playing on a real CANbus\n");
  printf("\t-d\tdebug mode\n");
  exit(1);
}


//////////////////////
///Read Segments//////
//////////////////////
int read_config() {
	char* network_segments_mapping_file_name = "./data/network_segments_mapping.txt";
    FILE *file = fopen(network_segments_mapping_file_name, "r");
    if (file == NULL) {
        perror("Error opening config file");
        return -1;
    }
    int count = 0;
    char line[100];
    while (fgets(line, sizeof(line), file) && count < MAX_SEGMENTS) {
        if (sscanf(line, "%19[^,], %9[^,], 0x%x, 0x%x", 
                   segments[count].name,
                   segments[count].interface, 
                   &segments[count].start_id, 
                   &segments[count].end_id) == 4) {
            segments[count].socket = -1;
            count++;
        }
    }
    fclose(file);
    return count;
}

/////////////////////////////////
///Initialize CAN Interface//////
/////////////////////////////////
int init_can_interface(const char *ifname) {
    int cs;
  	int enable_canfd = 1;
    struct sockaddr_can addr;
    struct ifreq ifr;

    if ((cs = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {
        perror("Socket");
        return -1;
    }

    strcpy(ifr.ifr_name, ifname);
    ioctl(cs, SIOCGIFINDEX, &ifr);

    addr.can_family = AF_CAN;
    addr.can_ifindex = ifr.ifr_ifindex;
	
	if (setsockopt(cs, SOL_CAN_RAW, CAN_RAW_FD_FRAMES,
					&enable_canfd, sizeof(enable_canfd))){
		printf("error when enabling CAN FD support\n");
		return 1;
	}
    if (bind(cs, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("Bind");
        return -1;
    }

    return cs;
}

void init_all_interfaces() {
    for (int i = 0; i < num_segments; i++) {
        segments[i].socket = init_can_interface(segments[i].interface);
        if (segments[i].socket < 0) {
            fprintf(stderr, "Failed to initialize interface %s\n", segments[i].interface);
            exit(1);
        }
    }
}


//////////////////////////////////
////PROGRAM STARTING POINT////////
//////////////////////////////////
int main(int argc, char *argv[]) {
  int opt;
  pthread_t server_thread;
  struct sockaddr_can addr;
  int running = 1;
  int enable_canfd = 1;
  int play_traffic = 1;
  int run_gateway = 1;
  struct stat st;
  SDL_Event event;
  signal(SIGINT, sigint_handler);
  signal(SIGTERM, sigint_handler);

  // Load mappings from file
  num_segments = read_config();
  if (num_segments < 0) {
    fprintf(stderr, "Failed to read configuration\n");
    exit(1);
  }
  printf("Loaded %d segments:\n", num_segments);
  // Initialize interfaces
  init_all_interfaces();

    for (int i = 0; i < num_segments; i++) {
        printf("Segment %d: Interface %s, ID Range 0x%X - 0x%X Socket %d\n", 
               i + 1, segments[i].interface, segments[i].start_id, segments[i].end_id, segments[i].socket);
    }

	
	
  while ((opt = getopt(argc, argv, "XFdl:s:t:m:I:h?")) != -1) {
    switch(opt) {
	case 'l':
		difficulty = atoi(optarg);
		break;
	case 's':
		seed = atoi(optarg);
		break;
	case 't':
		traffic_log = optarg;
		break;
	case 'd':
		debug = 1;
		break;
	case 'I':
		script_path = optarg;
		scripted_input = 1;
		break;
	case 'F':
		CANType = CANFD_MTU;
		traffic_log = DEFAULT_CANFD_TRAFFIC;
		break;
	case 'X':
		play_traffic = 0;
		break;
	case 'h':
	case '?':
	default:
		usage(NULL);
		break;
    }
  }

if(scripted_input == 0)
{
	// Set up signal handling
    struct sigaction sa;
    sa.sa_handler = sigint_handler;
    sa.sa_flags = 0;
    sigemptyset(&sa.sa_mask);
    sigaction(SIGINT, &sa, NULL);

    // Start the server thread
    if (pthread_create(&server_thread, NULL, socket_server, NULL) != 0) {
        perror("Failed to create server thread");
        return EXIT_FAILURE;
    }
}

  if (optind >= argc) usage("You must specify at least one can device");

  if(stat(traffic_log, &st) == -1) {
	char msg[256];
	snprintf(msg, 255, "CAN Traffic file not found: %s\n", traffic_log);
	usage(msg);
  }

  /* open socket */
  if ((s = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {
       perror("socket");
       return 1;
  }

  addr.can_family = AF_CAN;

  strcpy(ifr.ifr_name, argv[optind]);
  if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {
       perror("SIOCGIFINDEX");
       return 1;
  }
  addr.can_ifindex = ifr.ifr_ifindex;

  if (setsockopt(s, SOL_CAN_RAW, CAN_RAW_FD_FRAMES,
                 &enable_canfd, sizeof(enable_canfd))){
       printf("error when enabling CAN FD support\n");
       return 1;
  }

  if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
       perror("bind");
       return 1;
  }

  door_id = DEFAULT_DOOR_ID;
  window_id = DEFAULT_WINDOW_ID;
  signal_id = DEFAULT_SIGNAL_ID;
  speed_id = DEFAULT_SPEED_ID;
  rpm_id = DEFAULT_RPM_ID;
  oil_temp_id = DEFAULT_OIL_TEMPERATURE_ID;
  radiator_temp_id = DEFAULT_RADIATOR_TEMPERATURE_ID;
  engine_load_id = DEFAULT_ENGINE_LOAD_ID;
  gear_id = DEFAULT_GEAR_ID;
  air_flow_id = DEFAULT_AIR_FLOW_ID;
  VVT_id = DEFAULT_VVT_ID;
  oxygen_sensor_id = DEFAULT_OXYGEN_SENSOR_ID;
  fuel_id = DEFAULT_FUEL_TANK_ID;
  battery_id = DEFAULT_BATTERY_ID;
  light_id = DEFAULT_LIGHT_ID;
  bluetooth_id = DEFAULT_BLUETOOTH_ID;
  audiosys_id = DEFAULT_AUDIOSYSTEM_ID;
  aircondition_id = DEFAULT_AIRCONDITION_ID;
  satelitenavigation_id = DEFAULT_SATELITENAVIGATION_ID;
  defroster_id = DEFAULT_DEFROSTER_ID;
  handbrake_id = DEFAULT_HANDBRAKE_ID;
  brakecontrol_id = DEFAULT_BRAKECONTROL_ID;
  abs_id = DEFAULT_ABS_ID;
  wiper_id = DEFAULT_WIPER_ID;
  airbag_id = DEFAULT_AIRBAG_ID;
  hazard_id = DEFAULT_HAZARD_ID;
  sunroof_id = DEFAULT_SUNROOF_ID;
  sidemirror_id = DEFAULT_SIDEMIRROR_ID;
  trunk_id = DEFAULT_TRUNK_ID;
  steering_id = DEFAULT_STEERING_ID;
  cruisecontrol_id = DEFAULT_CRUISECONTROL_ID;
  throttle_id = DEFAULT_THROTTLE_ID;
  horn_id = DEFAULT_HORN_ID;

  if (seed) {
		srand(seed);
        door_id = (rand() % 2046) + 1;
		window_id = (rand() % 2046) + 1;
        signal_id = (rand() % 2046) + 1;
        speed_id = (rand() % 2046) + 1;
		rpm_id = (rand() % 2046) + 1;
		oil_temp_id = (rand() % 2046) + 1;
		radiator_temp_id = (rand() % 2046) + 1;
		engine_load_id = (rand() % 2046) + 1;
		gear_id = (rand() % 2046) + 1;
		air_flow_id = (rand() % 2046) + 1;
		VVT_id = (rand() % 2046) + 1;
		oxygen_sensor_id = (rand() % 2046) + 1;
		fuel_id = (rand() % 2046) + 1;
		battery_id = (rand() % 2046) + 1;
		light_id = (rand() % 2046) + 1;
		bluetooth_id = (rand() % 2046) + 1;
		audiosys_id = (rand() % 2046) + 1;
		aircondition_id = (rand() % 2046) + 1;
		satelitenavigation_id = (rand() % 2046) + 1;
		defroster_id = (rand() % 2046) + 1; 
		handbrake_id = (rand() % 2046) + 1;
		brakecontrol_id = (rand() % 2046) + 1;
		abs_id = (rand() % 2046) + 1;
		wiper_id = (rand() % 2046) + 1;
		airbag_id = (rand() % 2046) + 1;
		hazard_id = (rand() % 2046) + 1;
		sunroof_id = (rand() % 2046) + 1;
		sidemirror_id = (rand() % 2046) + 1;
		trunk_id = (rand() % 2046) + 1;
		steering_id = (rand() % 2046) + 1;
		cruisecontrol_id = (rand() % 2046) + 1;
		throttle_id = (rand() & 2046) + 1;
		horn_id = (rand() & 2046) + 1;
        door_pos = rand() % 9;
		window_pos = rand() % 9;
        signal_pos = rand() % 9;
        speed_pos = rand() % 8;
		rpm_pos = rand() % 8;
		oil_temp_pos = rand() % 8;
		radiator_temp_pos = rand() % 8;
		engine_load_pos = rand() % 8;
		gear_pos = rand() % 8;
		air_flow_pos = rand() % 8;
		VVT_pos = rand() % 8;
		oxygen_sensor_pos = rand() % 8;
		battery_pos = rand() % 8;
		throttle_pos = rand() % 8;
		horn_pos = rand() % 8;
		fuel_pos = rand() % 8;
		light_pos = rand() % 9;
		bluetooth_pos = rand() % 9;
		audiosys_pos = rand() % 9;
		aircondition_pos = rand() % 9;
		satelitenavigation_pos = rand() % 9;
		defroster_pos = rand() % 9;
		hand_brake_pos = rand() % 9;
		wiper_pos = rand() % 9;
		airbag_pos = rand() % 9;
		hazard_pos = rand() % 9;
		sunroof_pos = rand() % 9;
		sidemirror_pos = rand() % 9;
		trunk_pos = rand() % 9;
		steering_pos = rand() % 8;
		cruisecontrol_pos = rand() % 9;
        printf("Seed: %d\n", seed);
  	} 
	if(CANType == CANFD_MTU)
	{
		light_len = CANFD_MAX_DLEN - 1;
		light_pos = DEFAULT_LIGHT_POS + 16;
		bluetooth_len = CANFD_MAX_DLEN - 1;
		bluetooth_pos = DEFAULT_BLUETOOTH_POS + 16;
		audiosys_len = CANFD_MAX_DLEN - 1;
		audiosys_pos = DEFAULT_AUDIOSYSTEM_POS + 16;
		aircondition_len = CANFD_MAX_DLEN - 1;
		aircondition_pos = DEFAULT_AIRCONDITION_POS + 16;
		satelitenavigation_len = CANFD_MAX_DLEN - 1;
		satelitenavigation_pos =  DEFAULT_SATELITENAVIGATION_POS + 16;
		defroster_len = CANFD_MAX_DLEN - 1;
		defroster_pos = DEFAULT_DEFROSTER_POS + 16;
		hand_brake_len = CANFD_MAX_DLEN - 1;
		hand_brake_pos = DEFAULT_HAND_BRAKE_POS + 16;
		wiper_len = CANFD_MAX_DLEN - 1;
		wiper_pos = DEFAULT_WIPER_POS + 16;
		airbag_len = CANFD_MAX_DLEN - 1;
		airbag_pos = DEFAULT_AIRBAG_POS + 16;
		hazard_len = CANFD_MAX_DLEN - 1;
		hazard_pos = DEFAULT_HAZARD_POS + 16;
		sunroof_len = CANFD_MAX_DLEN - 1;
		sunroof_pos = DEFAULT_SUNROOF_POS + 16;
		sidemirror_len = CANFD_MAX_DLEN - 1;
		sidemirror_pos = DEFAULT_SIDEMIRROR_POS + 16;
		trunk_len = CANFD_MAX_DLEN - 1;
		trunk_pos = DEFAULT_TRUNK_POS + 16;
		steering_len = CANFD_MAX_DLEN - 1;
		steering_pos = DEFAULT_STEERING_POS + 16;
		cruisecontrol_len = CANFD_MAX_DLEN - 1;
		cruisecontrol_pos = DEFAULT_CRUISECONTROL_POS + 16;
		rpm_len = CANFD_MAX_DLEN - 1;
		rpm_pos = DEFAULT_RPM_POS  + 16;
		oil_temp_len = CANFD_MAX_DLEN - 1;
		oil_temp_pos = DEFAULT_OIL_TEMPERATURE_POS + 16;
		radiator_temp_len = CANFD_MAX_DLEN - 1;
		radiator_temp_pos = DEFAULT_RADIATOR_TEMPERATURE_POS  + 16;
		engine_load_len = CANFD_MAX_DLEN - 1;
		engine_load_pos = DEFAULT_ENGINE_LOAD_POS + 16;
		gear_len = CANFD_MAX_DLEN - 1;
		gear_pos = DEFAULT_GEAR_POS + 16;
		air_flow_len = CANFD_MAX_DLEN - 1;
		air_flow_pos = DEFAULT_AIR_FLOW_POS + 16;
		VVT_len = CANFD_MAX_DLEN - 1;
		VVT_pos = DEFAULT_VVT_POS + 16;
		oxygen_sensor_len = CANFD_MAX_DLEN - 1;
		oxygen_sensor_pos = DEFAULT_OXYGEN_SENSOR_POS + 16;
		fuel_len = CANFD_MAX_DLEN - 1;
		fuel_pos = DEFAULT_FUEL_TANK_POS + 16;
		battery_len = CANFD_MAX_DLEN - 1;
		battery_pos = DEFAULT_BATTERY_POS + 16;
		throttle_len = CANFD_MAX_DLEN - 1;
		throttle_pos = DEFAULT_THROTTLE_POS + 16;
		door_len = CANFD_MAX_DLEN - 1;
		door_pos = DEFAULT_DOOR_POS + 16;
		window_len = CANFD_MAX_DLEN - 1;
		window_pos = DEFAULT_WINDOW_POS + 16;
		signal_len = CANFD_MAX_DLEN - 1;
		signal_pos = DEFAULT_SIGNAL_POS + 16; 
		speed_len = CANFD_MAX_DLEN - 1;
		speed_pos = DEFAULT_SPEED_POS + 16;
		horn_len = CANFD_MAX_DLEN - 1;
		horn_pos = DEFAULT_HORN_POS + 16; 
		abs_len = CANFD_MAX_DLEN - 1;
		abs_pos = DEFAULT_ABS_POS + 16;
		brakecontrol_len = CANFD_MAX_DLEN -1;
		brakecontrol_pos = DEFAULT_BRAKECONTROL_POS + 16;
	}
	else 
	{
		light_len = CAN_MAX_DLEN;
		light_pos = DEFAULT_LIGHT_POS;
		bluetooth_len = CAN_MAX_DLEN;
		bluetooth_pos = DEFAULT_BLUETOOTH_POS;
		audiosys_len = CAN_MAX_DLEN;
		audiosys_pos = DEFAULT_AUDIOSYSTEM_POS;
		aircondition_len = CAN_MAX_DLEN;
		aircondition_pos = DEFAULT_AIRCONDITION_POS;
		satelitenavigation_len = CAN_MAX_DLEN;
		satelitenavigation_pos = DEFAULT_SATELITENAVIGATION_POS;
		defroster_len = CAN_MAX_DLEN;
		defroster_pos = DEFAULT_DEFROSTER_POS;
		hand_brake_len = CAN_MAX_DLEN;
		hand_brake_pos = DEFAULT_HAND_BRAKE_POS;
		wiper_len = CAN_MAX_DLEN;
		wiper_pos = DEFAULT_WIPER_POS;
		airbag_len = CAN_MAX_DLEN;
		airbag_pos = DEFAULT_AIRBAG_POS;
		hazard_len = CAN_MAX_DLEN;
		hazard_pos = DEFAULT_HAZARD_POS;
		sunroof_len = CAN_MAX_DLEN;
		sunroof_pos = DEFAULT_SUNROOF_POS;
		sidemirror_len = CAN_MAX_DLEN;
		sidemirror_pos = DEFAULT_SIDEMIRROR_POS;
		trunk_len = CAN_MAX_DLEN;
		trunk_pos = DEFAULT_TRUNK_POS;
		cruisecontrol_len = CAN_MAX_DLEN;
		cruisecontrol_pos = DEFAULT_CRUISECONTROL_POS;
		rpm_len = CAN_MAX_DLEN;
		rpm_pos = DEFAULT_RPM_POS;
		oil_temp_len = CAN_MAX_DLEN;
		oil_temp_pos = DEFAULT_OIL_TEMPERATURE_POS;
		radiator_temp_len = CAN_MAX_DLEN;
		radiator_temp_pos = DEFAULT_RADIATOR_TEMPERATURE_POS;
		engine_load_len = CAN_MAX_DLEN;
		engine_load_pos = DEFAULT_ENGINE_LOAD_POS;
		gear_len = CAN_MAX_DLEN;
		gear_pos = DEFAULT_GEAR_POS;
		air_flow_len = CAN_MAX_DLEN;
		air_flow_pos = DEFAULT_AIR_FLOW_POS;
		VVT_len = CAN_MAX_DLEN;
		VVT_pos = DEFAULT_VVT_POS;
		oxygen_sensor_len = CAN_MAX_DLEN;
		oxygen_sensor_pos = DEFAULT_OXYGEN_SENSOR_POS;
		fuel_len = CAN_MAX_DLEN;
		fuel_pos = DEFAULT_FUEL_TANK_POS;
		battery_len = CAN_MAX_DLEN;
		battery_pos = DEFAULT_BATTERY_POS;
		throttle_len = CAN_MAX_DLEN;
		throttle_pos = DEFAULT_THROTTLE_POS;
		door_len = CAN_MAX_DLEN;//CANFD_MAX_DLEN;//door_pos + 1;
		door_pos = DEFAULT_DOOR_POS;
		window_len = CAN_MAX_DLEN;
		window_pos = DEFAULT_WINDOW_POS;
		signal_len = CAN_MAX_DLEN; //signal_pos + 1;//CANFD_MAX_DLEN;//signal_pos + 1;
		signal_pos = DEFAULT_SIGNAL_POS; 
		speed_len = CAN_MAX_DLEN; //speed_pos + 2;//CANFD_MAX_DLEN;//speed_len + 2;
		speed_pos = DEFAULT_SPEED_POS; 
		steering_len = CAN_MAX_DLEN;
		steering_pos = DEFAULT_STEERING_POS;
		horn_len = CAN_MAX_DLEN;
		horn_pos = DEFAULT_HORN_POS;
		abs_len = CAN_MAX_DLEN;
		abs_pos = DEFAULT_ABS_POS;
		brakecontrol_len = CAN_MAX_DLEN;
		brakecontrol_pos = DEFAULT_BRAKECONTROL_POS;
	}

  if(play_traffic) {
	play_id = fork();
	if((int)play_id == -1) {
		printf("Error: Couldn't fork bg player\n");
		exit(-1);
	} else if (play_id == 0) {
		play_can_traffic();
		// Shouldn't return
		exit(0);
	}
	atexit(kill_child);
  }
  if(run_gateway) {
	gateway_id = fork();
	
	if((int)gateway_id == -1) {
		printf("Error: Couldn't fork bg gateway\n");
		exit(-1);
	} else if (gateway_id == 0) {
		run_can_gateway();
		
		// Shouldn't return
		exit(0);
	}
	atexit(kill_gateway_child);
  }

//scripted input
if(scripted_input)
{
	// Create a thread for input handling
	if (pthread_create(&inputThread, NULL, script_processor, NULL) != 0) {
		perror("Failed to create thread");
		return 1;
	}
}

  // GUI Setup
  SDL_Window *window = NULL;
  if(SDL_Init ( SDL_INIT_VIDEO | SDL_INIT_JOYSTICK ) < 0 ) {
        printf("SDL Could not initializes\n");
        exit(40);
  }
  
  window = SDL_CreateWindow("CANBus Control Panel", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
  if(window == NULL) {
        printf("Window could not be shown\n");
  }
  renderer = SDL_CreateRenderer(window, -1, 0);
  SDL_Surface *image = IMG_Load(get_data("joypad.png"));
  base_texture = SDL_CreateTextureFromSurface(renderer, image);
  SDL_RenderCopy(renderer, base_texture, NULL, NULL);
  SDL_RenderPresent(renderer);
  int button, axis; // Used for checking dynamic joystick mappings

  while(running) {
    while( SDL_PollEvent(&event) != 0 ) {
        switch(event.type) {
            case SDL_QUIT:
                running = 0;
                break;
			case SDL_WINDOWEVENT:
			switch(event.window.event) {
				case SDL_WINDOWEVENT_ENTER:
				case SDL_WINDOWEVENT_RESIZED:
					redraw_screen();
					break;
				}
                break;
	    case SDL_KEYDOWN:
		switch(event.key.keysym.sym) {
		    case SDLK_UP:
			if(current_throttle_status != ON)
			{
				send_throttle_status(ON);
			}
			throttle = 1;
			break;
			case SDLK_DOWN:
				if(brakecontrol_status != CAN_BRAKECONTROL_ON)
				{
					send_brakecontrol_signal(CAN_BRAKECONTROL_ON);
				}
				break;
			case SDLK_SPACE:
			if(horn_status != ON)
			{
				send_horn_status(ON);
			}
			//horn = 1;
			break;
			case SDLK_RIGHT:
				if(current_steering_angle < 90)
				{
					current_steering_angle += 10;
				}
				if(current_steering_angle > 90)
				{
					current_steering_angle = 90;
				}
				send_steering_angle();
			break;
			case SDLK_LEFT:
				current_steering_angle -= 10;
				if(current_steering_angle > -90)
				{
					current_steering_angle -= 10;
				}
				if(current_steering_angle < -90)
				{
					current_steering_angle = -90;
				}
				send_steering_angle();
			break;
		    case SDLK_f:
			turning = -1;
			break;
		    case SDLK_g:
			turning = 1;
			break;
		    case SDLK_LSHIFT:
			lock_enabled = 1;
			left_shift_enabled = 1;
			if(unlock_enabled) send_lock(CAN_DOOR1_LOCK | CAN_DOOR2_LOCK | CAN_DOOR3_LOCK | CAN_DOOR4_LOCK);
			break;
		    case SDLK_RSHIFT:
			unlock_enabled = 1;
			right_shift_enabled = 1;
			if(lock_enabled) send_unlock(CAN_DOOR1_LOCK | CAN_DOOR2_LOCK | CAN_DOOR3_LOCK | CAN_DOOR4_LOCK);
			break;
		    case SDLK_LCTRL:
				left_ctrl_enabled  = 1;
				break;
			case SDLK_RCTRL:
				right_ctrl_enabled = 1;
				break;
		    case SDLK_e:
			if(lock_enabled) {
				send_lock(CAN_DOOR1_LOCK);
			} else if(unlock_enabled) {
				send_unlock(CAN_DOOR1_LOCK);
			}
			break;
		    case SDLK_q:
			if(lock_enabled) {
				send_lock(CAN_DOOR2_LOCK);
			} else if(unlock_enabled) {
				send_unlock(CAN_DOOR2_LOCK);
			}
			break;
		    case SDLK_d:
			if(lock_enabled) {
				send_lock(CAN_DOOR3_LOCK);
			} else if(unlock_enabled) {
				send_unlock(CAN_DOOR3_LOCK);
			}
			break;
		    case SDLK_a:
			if(lock_enabled) {
				send_lock(CAN_DOOR4_LOCK);
			} else if(unlock_enabled) {
				send_unlock(CAN_DOOR4_LOCK);
			}
			break;
			case SDLK_l:
				if (lightButtonPressed == CAN_LIGHT_OFF) {
                	light_status = CAN_LIGHT_ON;
                	lightButtonPressed = CAN_LIGHT_ON;
              	}
				else
				{
					lightButtonPressed = CAN_LIGHT_OFF;
					light_status = CAN_LIGHT_OFF;
				}
			send_light_signal(light_status);
			
			break;
			case SDLK_b:
				if (bluetooth_status == CAN_BLUETOOTH_OFF) {
                	bluetooth_status = CAN_BLUETOOTH_ON;
              	}
				else
				{
					bluetooth_status = CAN_BLUETOOTH_OFF;
				}
				send_bluetooth_signal(bluetooth_status);
				
				break;
			case SDLK_r:
				//Left Shift + R combination
				if (audiosys_status == CAN_RADIO_ON && left_shift_enabled) {
					send_audiosys_signal(CAN_RADIO_NextStation);
				}
				//Left CTRL + R combination
				else if (audiosys_status == CAN_RADIO_ON && left_ctrl_enabled) {
					send_audiosys_signal(CAN_RADIO_PreviousStation);
				}
				else 
				{
					if (audiosys_status == CAN_RADIO_OFF) {
						audiosys_status = CAN_RADIO_ON;
					}
					else
					{
						audiosys_status = CAN_RADIO_OFF;
					}
					send_audiosys_signal(audiosys_status);
				}
				break;
			
			case SDLK_v:
				//Left Shift + V combination
				if (audiosys_status == CAN_RADIO_ON && left_shift_enabled) {
					send_audiosys_signal(CAN_RADIO_VolumeUp);
				}
				//Left Shift + V combination
				else if (audiosys_status == CAN_RADIO_ON && left_ctrl_enabled) {
					send_audiosys_signal(CAN_RADIO_VolumeDown);
				}
				break;
			case SDLK_z:
				//Left Shift + Z combination
				if (aircondition_status == CAN_AIRCONDITION_ON && left_shift_enabled) {
					send_aircondition_signal(CAN_AIRCONDITION_Up);
				}
				//Left CTRL + Z combination
				else if (aircondition_status == CAN_AIRCONDITION_ON && left_ctrl_enabled) {
					send_aircondition_signal(CAN_AIRCONDITION_Down);

				}
				else if(!(left_shift_enabled) && !(left_ctrl_enabled))
				{
					if (aircondition_status == CAN_AIRCONDITION_OFF) {
						aircondition_status = CAN_AIRCONDITION_ON;
					}
					else
					{
						aircondition_status = CAN_AIRCONDITION_OFF;
					}
					send_aircondition_signal(aircondition_status);
				}

				break;
			case SDLK_n:
				if (satelitenavigation_status == OFF) {
                	satelitenavigation_status = ON;
              	}
				else
				{
					satelitenavigation_status = OFF;
				}
				send_satelitenavigation_signal(satelitenavigation_status);
				
				break;
			case SDLK_y:
				
				//Right Shift + y combination
				if (right_shift_enabled) {
					if(defroster_status == CAN_DEFROSTER_REAR_ON)
					{
						defroster_status = CAN_DEFROSTER_REAR_OFF;
					}
					else 
					{
						defroster_status = CAN_DEFROSTER_REAR_ON;
					}
				}
				//Left Shift + y combination
				else if (left_shift_enabled) {

					if(defroster_status == CAN_DEFROSTER_FRONT_ON)
					{
						defroster_status = CAN_DEFROSTER_FRONT_OFF;
					}
					else {
						defroster_status = CAN_DEFROSTER_FRONT_ON;
					}
				}
				else {

					if(defroster_status == CAN_DEFROSTER_BOTH_ON)
					{
						defroster_status = CAN_DEFROSTER_BOTH_OFF;
					}
					else {
						defroster_status = CAN_DEFROSTER_BOTH_ON;
					}
				}
				
				send_defroster_signal(defroster_status);
				
				break;
				
			case SDLK_h:
				if(handbrakeOn == CAN_HANDBRAKE_OFF)
				{
					handbrakeOn=CAN_HANDBRAKE_ON;
					hand_brake_status = CAN_HANDBRAKE_ON;
				}
				else
				{
					handbrakeOn=CAN_HANDBRAKE_OFF;
					hand_brake_status = CAN_HANDBRAKE_OFF;
				}
				send_hand_brake_signal(hand_brake_status);
				break;
			case SDLK_x:
				if(abs_status == CAN_ABS_OFF)
				{
					abs_status=CAN_ABS_ON;
				}
				else
				{
					abs_status = CAN_ABS_OFF;
				}
				send_abs_signal(abs_status);
				break;
			case SDLK_w:
				//Left Shift + W combination
				if (left_shift_enabled) {
					send_window_lock(CAN_WINDOW1_LOCK | CAN_WINDOW2_LOCK | CAN_WINDOW3_LOCK | CAN_WINDOW4_LOCK);
				}
				//Left Shift + W combination
				else if (right_shift_enabled) {
					send_window_unlock(CAN_WINDOW1_LOCK | CAN_WINDOW2_LOCK | CAN_WINDOW3_LOCK | CAN_WINDOW4_LOCK);
				}
				else 
				{
					if(wiperOn == CAN_WIPER_OFF)
					{
						wiperOn=CAN_WIPER_ON;
						wiper_status=CAN_WIPER_ON;
					}
					else
					{
						wiperOn=CAN_WIPER_OFF;
						wiper_status=CAN_WIPER_OFF;
					}
					send_wiper_signal(wiper_status);
				}
				
				break;
			case SDLK_i:
				//Left Shift + W combination
				if (left_shift_enabled) {
					send_window_lock(CAN_WINDOW1_LOCK);
				}
				//Left Shift + W combination
				else if (right_shift_enabled) {
					send_window_unlock(CAN_WINDOW1_LOCK);
				}
				break;
			case SDLK_u:
				//Left Shift + W combination
				if (left_shift_enabled) {
					send_window_lock(CAN_WINDOW2_LOCK);
				}
				//Left Shift + W combination
				else if (right_shift_enabled) {
					send_window_unlock(CAN_WINDOW2_LOCK);
				}
				break;
			
			case SDLK_j:
				//Left Shift + W combination
				if (left_shift_enabled) {
					send_window_lock(CAN_WINDOW4_LOCK);
				}
				//Left Shift + W combination
				else if (right_shift_enabled) {
					send_window_unlock(CAN_WINDOW4_LOCK);
				}
				break;
			case SDLK_k:
				//Left Shift + W combination
				if (left_shift_enabled) {
					send_window_lock(CAN_WINDOW3_LOCK);
				}
				//Left Shift + W combination
				else if (right_shift_enabled) {
					send_window_unlock(CAN_WINDOW3_LOCK);
				}
				break;
			case SDLK_o:
				if(hazard_status == CAN_HAZARD_OFF)
				{
					hazard_status=CAN_HAZARD_ON;
				}
				else
				{
					hazard_status=CAN_HAZARD_OFF;
				}
				send_hazard_signal(hazard_status);
				break;
			case SDLK_p:
				if(airbag_status == CAN_AIRBAG_OFF)
				{
					airbag_status=CAN_AIRBAG_ON;
				}
				//Airbag when OFF then cannot ON untill application restart
				// else
				// {
				// 	airbag_status=CAN_AIRBAG_OFF;
				// }
				send_airbag_signal(airbag_status);
				break;
			case SDLK_s:
				if(sunroof_status == CAN_SUNROOF_OFF)
				{
					sunroof_status=CAN_SUNROOF_ON;
				}
				else
				{
					sunroof_status=CAN_SUNROOF_OFF;
				}
				send_sunroof_signal(sunroof_status);
				break;
			case SDLK_m:
				if(sidemirror_status == CAN_SIDEMIRROR_OFF)
				{
					sidemirror_status=CAN_SIDEMIRROR_ON;
				}
				else
				{
					sidemirror_status=CAN_SIDEMIRROR_OFF;
				}
				send_sidemirror_signal(sidemirror_status);
				break;
				
			case SDLK_t:
				if(trunk_status == CAN_TRUNK_OFF)
				{
					trunk_status=CAN_TRUNK_ON;
				}
				else
				{
					trunk_status=CAN_TRUNK_OFF;
				}
				send_trunk_signal(trunk_status);
				break;
				
			case SDLK_c:
				if(cruisecontrol_status == CAN_CRUISECONTROL_OFF)
				{
					cruisecontrol_status=CAN_CRUISECONTROL_ON;
				}
				else
				{
					cruisecontrol_status=CAN_CRUISECONTROL_OFF;
				}
				send_cruisecontrol_signal(cruisecontrol_status);
				break;
				
		}
		kk_check(event.key.keysym.sym);
	   	break;
	    case SDL_KEYUP:
		switch(event.key.keysym.sym) {
		    case SDLK_UP:
				if(current_throttle_status != OFF)
				{
					send_throttle_status(OFF);
				}
				throttle = -1;
				break;
			case SDLK_SPACE:
				if(horn_status != OFF)
				{
					send_horn_status(OFF);
				}
				break;
			case SDLK_DOWN:
				if(brakecontrol_status != CAN_BRAKECONTROL_OFF)
				{
					send_brakecontrol_signal(CAN_BRAKECONTROL_OFF);
				}
				if(current_throttle_status != ON)
				{
					current_throttle_status = -1;
				}
				break;
		    case SDLK_f:
		    case SDLK_g:
				turning = 0;
				break;
		    case SDLK_LSHIFT:
				lock_enabled = 0;
				left_shift_enabled = 0;
				break;
			case SDLK_RSHIFT:
				unlock_enabled = 0;
				right_shift_enabled = 0;
				break;
		    case SDLK_LCTRL:
				left_ctrl_enabled  = 0;
				break;
			case SDLK_RCTRL:
				right_ctrl_enabled = 0;
				break;
		}
		break;
	    case SDL_JOYAXISMOTION:
		axis = event.jaxis.axis;
		if(axis == gAxisLeftH) {
			ud(event.jaxis.value);
		} else if(axis == gAxisLeftV) {
			turn(event.jaxis.value);
		} else if(axis == gAxisR2) {
			accelerate(event.jaxis.value);
		} else if(axis == gAxisRightH ||
			  axis == gAxisRightV ||
			  axis == gAxisL2 ||
			  axis == gJoyX ||
			  axis == gJoyY ||
			  axis == gJoyZ) {
			// Do nothing, the axis is known just not connected
		} else {
			if (debug) printf("Unkown axis: %d\n", event.jaxis.axis);
		}
		break;
	    case SDL_JOYBUTTONDOWN:
                button = event.jbutton.button;
		if(button == gButtonLock) {
			lock_enabled = 1;
			if(unlock_enabled) send_lock(CAN_DOOR1_LOCK | CAN_DOOR2_LOCK | CAN_DOOR3_LOCK | CAN_DOOR4_LOCK);
		} else if(button == gButtonUnlock) {
			unlock_enabled = 1;
			if(lock_enabled) send_unlock(CAN_DOOR1_LOCK | CAN_DOOR2_LOCK | CAN_DOOR3_LOCK | CAN_DOOR4_LOCK);
		} else if(button == gButtonA) {
			if(lock_enabled) {
				send_lock(CAN_DOOR1_LOCK);
			} else if(unlock_enabled) {
				send_unlock(CAN_DOOR1_LOCK);
			}
			kk_check(SDLK_e);
		} else if (button == gButtonB) {
			if(lock_enabled) {
				send_lock(CAN_DOOR2_LOCK);
			} else if(unlock_enabled) {
				send_unlock(CAN_DOOR2_LOCK);
			}
			kk_check(SDLK_q);
		} else if (button == gButtonX) {
			if(lock_enabled) {
				send_lock(CAN_DOOR3_LOCK);
			} else if(unlock_enabled) {
				send_unlock(CAN_DOOR3_LOCK);
			}
			kk_check(SDLK_d);
		} else if (button == gButtonY) {
			if(lock_enabled) {
				send_lock(CAN_DOOR4_LOCK);
			} else if(unlock_enabled) {
				send_unlock(CAN_DOOR4_LOCK);
			}
			kk_check(SDLK_a);
		} else if (button == gButtonStart) {
			kk_check(SDLK_RETURN);
		} else {
			if(debug) printf("Unassigned button: %d\n", event.jbutton.button);
		}
		break;
	    case SDL_JOYBUTTONUP:
		button = event.jbutton.button;
		if(button == gButtonLock) {
			lock_enabled = 0;
		} else if(button == gButtonUnlock) {
			unlock_enabled = 0;
		} else {
			//if(debug) printf("Unassigned button: %d\n", event.jbutton.button);
		}
		break;
	    case SDL_JOYDEVICEADDED:
		// Only use the first controller
		if(event.cdevice.which == 0) {
			gJoystick = SDL_JoystickOpen(0);
			if(gJoystick) {
				gHaptic = SDL_HapticOpenFromJoystick(gJoystick);
				print_joy_info();
			}
		}
		break;
	    case SDL_JOYDEVICEREMOVED:
		if(event.cdevice.which == 0) {
			SDL_JoystickClose(gJoystick);
			gJoystick = NULL;
		}
		break;
	    case SDL_CONTROLLERDEVICEADDED:
		// Only use the first controller
		if(gGameController == NULL) {
			gGameController = SDL_GameControllerOpen(0);
			gJoystick = SDL_GameControllerGetJoystick(gGameController);
			gHaptic = SDL_HapticOpenFromJoystick(gJoystick);
			print_joy_info();
		}
		break;
	    case SDL_CONTROLLERDEVICEREMOVED:
		if(event.cdevice.which == 0) {
			SDL_GameControllerClose(gGameController);
			gGameController = NULL;
		}
		break;
        }
    }
	
	
    currentTime = SDL_GetTicks();
    checkAccel();
    checkTurn();
    SDL_Delay(5);
  }

  close(s);
  pthread_join(server_thread, NULL);
  pthread_join(inputThread, NULL);

  SDL_DestroyTexture(base_texture);
  SDL_FreeSurface(image);
  SDL_GameControllerClose(gGameController);
  SDL_DestroyRenderer(renderer);
  SDL_DestroyWindow(window);
  SDL_Quit();

}

//scripted input
void* script_processor()
{
	FILE *scripted_file = NULL;
	if(!scripted_file)
	{
		scripted_file = fopen(script_path, "r");
	}
		
	if (!scripted_file) {
		perror("Error opening script file");
	}
	else 
	{
		SDL_Delay(500);

		char line[MAX_LINE_LENGTH]; 
		while (fgets(line, sizeof(line), scripted_file)) {
			process_line(line);
			SDL_Delay(5);
		}

		fclose(scripted_file);
		printf("Script completed\n");
	}
	return NULL;
}

// Function to process a line of text
void *process_line(char *line) {
    if(line == NULL || *line == '\0')
    {
        return NULL;
    }
	printf("Processing  %s", line);
    //pthread_mutex_lock(&lock);
	simulate_key_press(SDLK_LSHIFT, Hold_Off);
	simulate_key_press(SDLK_RSHIFT, Hold_Off);
	simulate_key_press(SDLK_LCTRL, Hold_Off);
	simulate_key_press(SDLK_RCTRL, Hold_Off);


    line = convert_to_lowercase(line);
    // Split the line into tokens based on whitespace
    char *first_token = strtok(line, " "); // Split on space
    char *second_token = strtok(NULL, " "); // Split on space
	if (first_token == NULL) {
		return NULL;
	}
	if (second_token == NULL) {
		return NULL;
	}
    first_token=trim_whitespace(first_token);//trim spces
    second_token=trim_whitespace(second_token);//trim spces
    
    if (first_token != NULL && strcmp(first_token, "delay") == 0 && second_token != NULL) {
        // Convert the string to a long integer
        char *endptr; // Pointer to track where the conversion stopped
        errno = 0; // Reset errno before conversion
        long value = strtol(second_token, &endptr, 10); // Base 10 conversion

        // Check for conversion errors
        if (errno == ERANGE) {
            printf("Error: The number is out of range for long.\n");
        } else if (endptr == second_token) {
            printf("Error: No digits were found in the input string.\n");
        } 
		scripted_delay_time = currentTime + value;
		SDL_Delay(value);
        return NULL;
    }
	else if (first_token != NULL && strcmp(first_token, "all_window") == 0 && second_token != NULL && (strcmp(second_token, "unlocked") == 0 || strcmp(second_token, "unlock") == 0)) {
		simulate_key_press(SDLK_RSHIFT, Hold_On);
		simulate_key_press(SDLK_w, Hold_Off);
		simulate_key_press(SDLK_RSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "all_window") == 0 && second_token != NULL && (strcmp(second_token, "locked") == 0 || strcmp(second_token, "lock") == 0)) {
		simulate_key_press(SDLK_LSHIFT, Hold_On);
		simulate_key_press(SDLK_w, Hold_Off);
		simulate_key_press(SDLK_LSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "front_left_window") == 0 && second_token != NULL && (strcmp(second_token, "unlocked") == 0 || strcmp(second_token, "unlock") == 0)) {
		simulate_key_press(SDLK_RSHIFT, Hold_On);
		simulate_key_press(SDLK_u, Hold_Off);
		simulate_key_press(SDLK_RSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "front_left_window") == 0 && second_token != NULL && (strcmp(second_token, "locked") == 0 || strcmp(second_token, "lock") == 0)) {
		simulate_key_press(SDLK_LSHIFT, Hold_On);
		simulate_key_press(SDLK_u, Hold_Off);
		simulate_key_press(SDLK_LSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "front_right_window") == 0 && second_token != NULL && (strcmp(second_token, "unlocked") == 0 || strcmp(second_token, "unlock") == 0)) {
		simulate_key_press(SDLK_RSHIFT, Hold_On);
		simulate_key_press(SDLK_i, Hold_Off);
		simulate_key_press(SDLK_RSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "front_right_window") == 0 && second_token != NULL && (strcmp(second_token, "locked") == 0 || strcmp(second_token, "lock") == 0)) {
		simulate_key_press(SDLK_LSHIFT, Hold_On);
		simulate_key_press(SDLK_i, Hold_Off);
		simulate_key_press(SDLK_LSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "rear_left_window") == 0 && second_token != NULL && (strcmp(second_token, "unlocked") == 0 || strcmp(second_token, "unlock") == 0)) {
		simulate_key_press(SDLK_RSHIFT, Hold_On);
		simulate_key_press(SDLK_j, Hold_Off);
		simulate_key_press(SDLK_RSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "rear_left_window") == 0 && second_token != NULL && (strcmp(second_token, "locked") == 0 || strcmp(second_token, "lock") == 0)) {
		simulate_key_press(SDLK_LSHIFT, Hold_On);
		simulate_key_press(SDLK_j, Hold_Off);
		simulate_key_press(SDLK_LSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "rear_right_window") == 0 && second_token != NULL && (strcmp(second_token, "unlocked") == 0 || strcmp(second_token, "unlock") == 0)) {
		simulate_key_press(SDLK_RSHIFT, Hold_On);
		simulate_key_press(SDLK_k, Hold_Off);
		simulate_key_press(SDLK_RSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "rear_right_window") == 0 && second_token != NULL && (strcmp(second_token, "locked") == 0 || strcmp(second_token, "lock") == 0)) {
		simulate_key_press(SDLK_LSHIFT, Hold_On);
		simulate_key_press(SDLK_k, Hold_Off);
		simulate_key_press(SDLK_LSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "all_door") == 0 && second_token != NULL && (strcmp(second_token, "unlocked") == 0 || strcmp(second_token, "unlock") == 0)) {
		simulate_key_press(SDLK_LSHIFT, Hold_On);
		simulate_key_press(SDLK_RSHIFT, Hold_Off);
		simulate_key_press(SDLK_LSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "all_door") == 0 && second_token != NULL && (strcmp(second_token, "locked") == 0 || strcmp(second_token, "lock") == 0)) {
		simulate_key_press(SDLK_RSHIFT, Hold_On);
		simulate_key_press(SDLK_LSHIFT, Hold_Off);
		simulate_key_press(SDLK_RSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "front_left_door") == 0 && second_token != NULL && (strcmp(second_token, "unlocked") == 0 || strcmp(second_token, "unlock") == 0)) {
		simulate_key_press(SDLK_RSHIFT, Hold_On);
		simulate_key_press(SDLK_q, Hold_Off);
		simulate_key_press(SDLK_RSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "front_left_door") == 0 && second_token != NULL && (strcmp(second_token, "locked") == 0 || strcmp(second_token, "lock") == 0)) {
		simulate_key_press(SDLK_LSHIFT, Hold_On);
		simulate_key_press(SDLK_q, Hold_Off);
		simulate_key_press(SDLK_LSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "front_right_door") == 0 && second_token != NULL && (strcmp(second_token, "unlocked") == 0 || strcmp(second_token, "unlock") == 0)) {
		simulate_key_press(SDLK_RSHIFT, Hold_On);
		simulate_key_press(SDLK_e, Hold_Off);
		simulate_key_press(SDLK_RSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "front_right_door") == 0 && second_token != NULL && (strcmp(second_token, "locked") == 0 || strcmp(second_token, "lock") == 0)) {
		simulate_key_press(SDLK_LSHIFT, Hold_On);
		simulate_key_press(SDLK_e, Hold_Off);
		simulate_key_press(SDLK_LSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "rear_left_door") == 0 && second_token != NULL && (strcmp(second_token, "unlocked") == 0 || strcmp(second_token, "unlock") == 0)) {
		simulate_key_press(SDLK_RSHIFT, Hold_On);
		simulate_key_press(SDLK_a, Hold_Off);
		simulate_key_press(SDLK_RSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "rear_left_door") == 0 && second_token != NULL && (strcmp(second_token, "locked") == 0 || strcmp(second_token, "lock") == 0)) {
		simulate_key_press(SDLK_LSHIFT, Hold_On);
		simulate_key_press(SDLK_a, Hold_Off);
		simulate_key_press(SDLK_LSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "rear_right_door") == 0 && second_token != NULL && (strcmp(second_token, "unlocked") == 0 || strcmp(second_token, "unlock") == 0)) {
		simulate_key_press(SDLK_RSHIFT, Hold_On);
		simulate_key_press(SDLK_d, Hold_Off);
		simulate_key_press(SDLK_RSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "head_light") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_l, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "head_light") == 0 && second_token != NULL && strcmp(second_token, "off") == 0) {
		simulate_key_press(SDLK_l, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "bluetooth") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_b, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "bluetooth") == 0 && second_token != NULL && strcmp(second_token, "off") == 0) {
		simulate_key_press(SDLK_b, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "wiper") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_w, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "wiper") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_w, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "airbag") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_j, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "airbag") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_j, Hold_Off);
    }
	
	else if (first_token != NULL && strcmp(first_token, "hazard") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_o, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "hazard") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_o, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "sunroof") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_s, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "sunroof") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_s, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "sidemirror") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_m, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "sidemirror") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_m, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "trunk") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_t, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "trunk") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_t, Hold_Off);
    }
	
    else if (first_token != NULL && strcmp(first_token, "cruisecontrol") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_c, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "cruisecontrol") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_c, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "throttle") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_UP, Hold_On);
    }
    else if (first_token != NULL && strcmp(first_token, "throttle") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_UP, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "horn") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_SPACE, Hold_On);
    }
    else if (first_token != NULL && strcmp(first_token, "horn") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_SPACE, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "handbrake") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_h, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "handbrake") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_h, Hold_Off);
    }

    else if (first_token != NULL && strcmp(first_token, "brakecontrol") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_DOWN, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "brakecontrol") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_DOWN, Hold_Off);
	}
    else if (first_token != NULL && strcmp(first_token, "abs") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_x, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "abs") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_x, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "left_signal") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_f, Hold_On);
    }
    else if (first_token != NULL && strcmp(first_token, "left_signal") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_f, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "right_signal") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_g, Hold_On);
    }
    else if (first_token != NULL && strcmp(first_token, "right_signal") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_g, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "defroster_front") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_LSHIFT, Hold_On);
		simulate_key_press(SDLK_y, Hold_Off);
		simulate_key_press(SDLK_LSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "defroster_front") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_LSHIFT, Hold_On);
		simulate_key_press(SDLK_y, Hold_Off);
		simulate_key_press(SDLK_LSHIFT, Hold_Off);
	}
	else if (first_token != NULL && strcmp(first_token, "defroster_rear") == 0 && second_token != NULL && strcmp(second_token, "on") == 0 ) {
		simulate_key_press(SDLK_RSHIFT, Hold_On);
		simulate_key_press(SDLK_y, Hold_Off);
		simulate_key_press(SDLK_RSHIFT, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "defroster_rear") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_RSHIFT, Hold_On);
		simulate_key_press(SDLK_y, Hold_Off);
		simulate_key_press(SDLK_RSHIFT, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "defroster") == 0 && second_token != NULL && strcmp(second_token, "on") == 0 ) {
		simulate_key_press(SDLK_y, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "defroster") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_y, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "steering") == 0 && second_token != NULL && strcmp(second_token, "right") == 0 ) {
		simulate_key_press(SDLK_RIGHT, Hold_Off);
	}
	else if (first_token != NULL && strcmp(first_token, "steering") == 0 && second_token != NULL && strcmp(second_token, "left") == 0 ) {
		simulate_key_press(SDLK_LEFT, Hold_Off);
	}
	else if (first_token != NULL && strcmp(first_token, "satelitenavigation") == 0 && second_token != NULL && strcmp(second_token, "on") == 0 ) {
		simulate_key_press(SDLK_n, Hold_Off);
	}
	else if (first_token != NULL && strcmp(first_token, "satelitenavigation") == 0 && second_token != NULL && strcmp(second_token, "off") == 0 ) {
		simulate_key_press(SDLK_n, Hold_Off);
	}
	else if (first_token != NULL && strcmp(first_token, "radio") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_LSHIFT, Hold_Off);
		simulate_key_press(SDLK_r, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "radio") == 0 && second_token != NULL && strcmp(second_token, "nextstation") == 0) {
		simulate_key_press(SDLK_LSHIFT, Hold_On);
		simulate_key_press(SDLK_r, Hold_Off);
		simulate_key_press(SDLK_LSHIFT, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "radio") == 0 && second_token != NULL && strcmp(second_token, "previousstation") == 0) {
		simulate_key_press(SDLK_LCTRL, Hold_On);
		simulate_key_press(SDLK_r, Hold_Off);
		simulate_key_press(SDLK_LCTRL, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "radio") == 0 && second_token != NULL && strcmp(second_token, "volumeup") == 0) {
		simulate_key_press(SDLK_LSHIFT, Hold_On);
		simulate_key_press(SDLK_v, Hold_Off);
		simulate_key_press(SDLK_LSHIFT, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "radio") == 0 && second_token != NULL && strcmp(second_token, "volumedown") == 0) {
		simulate_key_press(SDLK_LCTRL, Hold_On);
		simulate_key_press(SDLK_v, Hold_Off);
		simulate_key_press(SDLK_LCTRL, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "radio") == 0 && second_token != NULL && strcmp(second_token, "off") == 0) {
		simulate_key_press(SDLK_r, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "aircondition") == 0 && second_token != NULL && strcmp(second_token, "on") == 0) {
		simulate_key_press(SDLK_z, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "aircondition") == 0 && second_token != NULL && strcmp(second_token, "up") == 0) {
		simulate_key_press(SDLK_LSHIFT, Hold_On);
		simulate_key_press(SDLK_z, Hold_Off);
		simulate_key_press(SDLK_LSHIFT, Hold_Off);
    }
	else if (first_token != NULL && strcmp(first_token, "aircondition") == 0 && second_token != NULL && strcmp(second_token, "down") == 0) {
		simulate_key_press(SDLK_LCTRL, Hold_On);
		simulate_key_press(SDLK_z, Hold_Off);
		simulate_key_press(SDLK_LCTRL, Hold_Off);
    }
    else if (first_token != NULL && strcmp(first_token, "aircondition") == 0 && second_token != NULL && strcmp(second_token, "off") == 0) {
		simulate_key_press(SDLK_z, Hold_Off);
    }
	
    else {
        return NULL;
    }
    
    return NULL; // Return the processed line
}

// Function to trim whitespace from the beginning and end of a string
char *trim_whitespace(char *str) {
    char *end;

    // Trim leading space
    while (isspace((unsigned char)*str)) str++;

    // Trim trailing space
    end = str + strlen(str) - 1;
    while (end > str && isspace((unsigned char)*end)) end--;

    // Null terminate the trimmed string
    end[1] = '\0';

    // Allocate memory for the trimmed string
    char *trimmed = malloc(strlen(str) + 1);
    if (trimmed == NULL) {
        printf("Memory allocation failed.\n");
        exit(1);
    }
    strcpy(trimmed, str); // Copy the trimmed string

    return trimmed; // Return the trimmed string
}

char *convert_to_lowercase(char *line) {
    char *result = malloc(strlen(line) + 1); // Allocate memory for the result
    if (result == NULL) {
        printf("Memory allocation failed.\n");
        exit(1);
    }

    // Copy the input line to the result
    strcpy(result, line);

    // Convert each character to lowercase
    for (int i = 0; result[i]; i++) {
        result[i] = tolower(result[i]);
    }

    return result; // Return the lowercase line
}

void simulate_key_press(SDL_Keycode key, int isHold) {
    // Create a new SDL event for key press
    SDL_Event event;
    memset(&event, 0, sizeof(event)); // Initialize the event structure

    // Simulate key down event
    event.type = SDL_KEYDOWN;
    event.key.keysym.sym = key;
    event.key.keysym.scancode = SDL_GetScancodeFromKey(key);
    event.key.state = SDL_PRESSED;
    if (SDL_PushEvent(&event) < 0) {
        fprintf(stderr, "Error pushing SDL_KEYDOWN event: %s\n", SDL_GetError());
    }

    if (isHold == Hold_Off) {
        // Simulate key up event
        memset(&event, 0, sizeof(event)); // Reinitialize event for key up
        event.type = SDL_KEYUP;
        event.key.keysym.sym = key;
        event.key.keysym.scancode = SDL_GetScancodeFromKey(key);
        event.key.state = SDL_RELEASED;
        if (SDL_PushEvent(&event) < 0) {
            fprintf(stderr, "Error pushing SDL_KEYUP event: %s\n", SDL_GetError());
        }
    }
}