icsim.c

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

#include <pthread.h> 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#include <getopt.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>


//////////////////////////////////
////DEFAULT CONSTANT VARIABLES////
//////////////////////////////////
#ifndef DATA_DIR
#define DATA_DIR "./data/"  // Needs trailing slash
#endif
#ifndef LOG_DIR
#define LOG_DIR "./logs/"  // Needs trailing slash
#endif
#define SCREEN_WIDTH 720
#define SCREEN_HEIGHT 329
#define DOOR_LOCKED 0
#define DOOR_UNLOCKED 1
#define WINDOW_LOCKED 0
#define WINDOW_UNLOCKED 1
#define OFF 0
#define ON 1
#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 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 DEFAULT_WARNING_POS 2
#define CAN_LEFT_SIGNAL 1
#define CAN_RIGHT_SIGNAL 2
#define CAN_WARNING_SIGNAL 3
#define CAN_LIGHT_ON 0x0B
#define CAN_LIGHT_OFF 0x0A
#define CAN_HAZARD_ON 0x05
#define CAN_HAZARD_OFF 0x06
#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_SIDEMIRROR_ON 0x0E
#define CAN_SIDEMIRROR_OFF 0x0F
#define CAN_SUNROOF_ON 0x01
#define CAN_SUNROOF_OFF 0x02
#define CAN_TRUNK_ON 0x0C
#define CAN_TRUNK_OFF 0x0D
#define CAN_STEERING_ON 0x07
#define CAN_STEERING_OFF 0x08
#define CAN_CRUISECONTROL_ON 0x05
#define CAN_CRUISECONTROL_OFF 0x06
#define MAX_SEGMENTS 50

//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 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


//////////////////////////////////
////VARIABLES INITIALIZATION//////
//////////////////////////////////
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; 
const int canfd_on = 1;
char vcanName[50];
struct timeval *tv;
int debug = 0;
int randomize = 0;
int seed = 0;
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 steering_pos = DEFAULT_STEERING_POS;
int rpm_pos = DEFAULT_RPM_POS;
int oil_temp_pos = DEFAULT_OIL_TEMPERATURE_POS;
int radiator_temp_pos = DEFAULT_RADIATOR_TEMPERATURE_POS;
int air_flow_pos = DEFAULT_AIR_FLOW_POS;
int fuel_pos = DEFAULT_FUEL_TANK_POS;
int engine_load_pos = DEFAULT_ENGINE_LOAD_POS;
int gear_pos = DEFAULT_GEAR_POS;
int vvt_pos = DEFAULT_VVT_POS;
int oxygen_sensor_pos = DEFAULT_OXYGEN_SENSOR_POS;
int battery_pos = DEFAULT_BATTERY_POS;
int throttle_pos = DEFAULT_THROTTLE_POS;  
int horn_pos = DEFAULT_HORN_POS;
int lightPos = DEFAULT_LIGHT_POS;
int bluetooth_pos = DEFAULT_BLUETOOTH_POS;
int aircondition_pos = DEFAULT_AIRCONDITION_POS;
int satelitenavigation_pos = DEFAULT_SATELITENAVIGATION_POS;
int defroster_pos = DEFAULT_DEFROSTER_POS;
int audiosys_pos = DEFAULT_AUDIOSYSTEM_POS;
int handbrake_pos = DEFAULT_HAND_BRAKE_POS;
int brakecontrol_pos = DEFAULT_BRAKECONTROL_POS;
int abs_pos = DEFAULT_ABS_POS;
int wiper_pos = DEFAULT_WIPER_POS;
int airbag_pos = DEFAULT_AIRBAG_POS;
int hazard_pos = DEFAULT_HAZARD_POS;
int sunroof_pos = DEFAULT_SUNROOF_POS;
int sidemirror_pos = DEFAULT_SIDEMIRROR_POS;
int trunk_pos = DEFAULT_TRUNK_POS;
int cruisecontrol_pos = DEFAULT_CRUISECONTROL_POS;
long current_speed = 0;
int16_t current_steering_angle = 0;
long current_rpm = 0;
float current_oil_temp = 30;
float current_radiator_temp = 30;
float current_engine_load = 0;
int current_gear = 0;
float current_vvt = 0;
float current_oxygen_sensor = 0.9;
float current_air_flow = 0;
float current_battery = 1000;
int current_throttle_status = OFF;
int current_horn_status = OFF;
int last_right_signal_status = OFF;
int last_left_signal_status = OFF;
float current_fuel = 0;
int current_temp = 25;
struct timeval t1, t2;
double elapsedTime;
int door_status[4];
int last_door_status[4];
int window_status[4];
int last_window_status[4];
int turn_status[2];
int aircondition_value = 20;
char lightStatus = CAN_LIGHT_OFF;
char bluetooth_status = CAN_BLUETOOTH_OFF;
char aircondition_status = CAN_AIRCONDITION_OFF;
char satelitenavigation_status = OFF;
char defroster_status = CAN_DEFROSTER_INIT;
char defroster_front_status = CAN_DEFROSTER_FRONT_OFF;
char defroster_rear_status = CAN_DEFROSTER_REAR_OFF;
char defroster_both_status = CAN_DEFROSTER_BOTH_OFF;
char audiosys_status = CAN_RADIO_OFF;
char handbrake_status = CAN_HANDBRAKE_OFF;
char brakecontrol_status = CAN_BRAKECONTROL_OFF;
char abs_status = CAN_ABS_OFF;
char wiper_status = 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 cruisecontrol_status = CAN_CRUISECONTROL_OFF;
char *logfilter = NULL;
char *commentsfilter = NULL;
int log_all_comments_enabled = 0;
int log_user_comments_enabled = 0;
int log_system_comments_enabled = 0;
int log_segment_comments_enabled = 0;
int log_all_enabled = 0;
int log_user_enabled = 0;
int log_system_enabled = 0;
int log_segment_enabled = 0;
int currentTime = 0;
int lastTimeCheck = 0;
char data_file[256];
SDL_Renderer *renderer = NULL;
SDL_Texture *base_texture = NULL;
SDL_Texture *needle_tex = NULL;
SDL_Texture *steering_tex = NULL;
SDL_Texture *rpm_needle_tex = NULL;
SDL_Texture *oil_temp_needle_tex = NULL;
SDL_Texture *radiator_temp_needle_tex = NULL;
SDL_Texture *fuel_needle_tex = NULL;
SDL_Texture *battery_needle_tex = NULL;
SDL_Texture *sprite_tex = NULL;
SDL_Rect speed_rect;
SDL_Rect rpm_rect;
SDL_Rect oil_temp_rect;
SDL_Rect radiator_temp_rect;
SDL_Rect battery_rect;
SDL_Rect fuel_rect;
SDL_Rect steering_rect;

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

///////////////////////////////////////////////
////Function prototypes for read functions////
///////////////////////////////////////////////
void read_speed_status(struct canfd_frame *cf, int maxdlen);
void read_rpm_status(struct canfd_frame *cf, int maxdlen);
void read_oil_temp_status(struct canfd_frame *cf, int maxdlen);
void read_fuel_status(struct canfd_frame *cf, int maxdlen);
void read_battery_status(struct canfd_frame *cf, int maxdlen);
void read_throttle_status(struct canfd_frame *cf, int maxdlen);
void read_horn_status(struct canfd_frame *cf, int maxdlen);
void read_light_status(struct canfd_frame *cf, int maxdlen);
void read_bluetooth_status(struct canfd_frame *cf, int maxdlen);
void read_aircondition_status(struct canfd_frame *cf, int maxdlen);
void read_satelitenavigation_status(struct canfd_frame *cf, int maxdlen);
void read_defroster_status(struct canfd_frame *cf, int maxdlen);
void read_audiosys_status(struct canfd_frame *cf, int maxdlen);
void read_handbrake_status(struct canfd_frame *cf, int maxdlen);
void read_brakecontrol_status(struct canfd_frame *cf, int maxdlen);
void read_abs_status(struct canfd_frame *cf, int maxdlen);
void read_wiper_status(struct canfd_frame *cf, int maxdlen);
void read_airbag_status(struct canfd_frame *cf, int maxdlen);
void read_hazard_status(struct canfd_frame *cf, int maxdlen);
void read_sunroof_status(struct canfd_frame *cf, int maxdlen);
void read_sidemirror_status(struct canfd_frame *cf, int maxdlen);
void read_trunk_status(struct canfd_frame *cf, int maxdlen);
void read_cruisecontrol_status(struct canfd_frame *cf, int maxdlen);
void read_steering_status(struct canfd_frame *cf, int maxdlen);
NetworkSegment get_segment_name(struct canfd_frame *cf);
int read_config();

//////////////////////////////////
////ANGLE MAPPING AS PER COORDINATES
//////////////////////////////////
// Simple map function
long map(long x, long in_min, long in_max, long out_min, long out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
// 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;
}


//////////////////////////////////
////Default vehicle state/////////
//////////////////////////////////
void init_car_state() {
  door_status[0] = DOOR_LOCKED;
  door_status[1] = DOOR_LOCKED;
  door_status[2] = DOOR_LOCKED;
  door_status[3] = DOOR_LOCKED;
  last_door_status[0] = DOOR_LOCKED;
  last_door_status[1] = DOOR_LOCKED;
  last_door_status[2] = DOOR_LOCKED;
  last_door_status[3] = DOOR_LOCKED;
  window_status[0] = WINDOW_LOCKED;
  window_status[1] = WINDOW_LOCKED;
  window_status[2] = WINDOW_LOCKED;
  window_status[3] = WINDOW_LOCKED;
  last_window_status[0] = WINDOW_LOCKED;
  last_window_status[1] = WINDOW_LOCKED;
  last_window_status[2] = WINDOW_LOCKED;
  last_window_status[3] = WINDOW_LOCKED;
  turn_status[0] = OFF;
  turn_status[1] = OFF;
  handbrake_status = CAN_HANDBRAKE_OFF;
  brakecontrol_status = CAN_BRAKECONTROL_OFF;
  abs_status = CAN_ABS_OFF;
  wiper_status = CAN_WIPER_OFF;
  airbag_status = CAN_AIRBAG_OFF;
  hazard_status = CAN_HAZARD_OFF;
  sunroof_status = CAN_SUNROOF_OFF;
  sidemirror_status = CAN_SIDEMIRROR_OFF;
  trunk_status = CAN_TRUNK_OFF;
  cruisecontrol_status = CAN_CRUISECONTROL_OFF;
  lightStatus = CAN_LIGHT_OFF;
  bluetooth_status = CAN_BLUETOOTH_OFF;
  aircondition_status = CAN_AIRCONDITION_OFF;
  satelitenavigation_status = OFF;
  defroster_front_status = CAN_DEFROSTER_FRONT_OFF;
  defroster_rear_status = CAN_DEFROSTER_FRONT_OFF;
  defroster_both_status = CAN_DEFROSTER_BOTH_OFF;
  audiosys_status = CAN_RADIO_OFF;
}

//////////////////////////////////
////Empty IC//////////////////////
//////////////////////////////////
void blank_ic() {
  SDL_RenderCopy(renderer, base_texture, NULL, NULL);
}

//////////////////////////////////
////Updates speedo////////////////
//////////////////////////////////
void update_speed() {
  SDL_Rect dial_rect;
  SDL_Point center;
  double angle = -100;
  dial_rect.x = 200;
  dial_rect.y = 80;
  dial_rect.h = 135;
  dial_rect.w = 300;
  SDL_RenderCopy(renderer, base_texture, &dial_rect, &dial_rect);
  /* Because it's a curve we do a smaller rect for the top */
  dial_rect.x = 250;
  dial_rect.y = 30;
  dial_rect.h = 65;
  dial_rect.w = 200;
  SDL_RenderCopy(renderer, base_texture, &dial_rect, &dial_rect);
  // And one more smaller box for the pivot point of the needle
  dial_rect.x = 253;
  dial_rect.y = 171;
  dial_rect.h = 52;
  dial_rect.w = 47;
  SDL_RenderCopy(renderer, base_texture, &dial_rect, &dial_rect);
  center.x = 77;
  center.y = 10;
  angle = map(current_speed*1, -270, 280, -270, 180);
  //printf("speed angle%f\r\n",angle);
  if(angle < -150) angle = -150;
  if(angle > 180) angle = 180;
  SDL_RenderCopyEx(renderer, needle_tex, NULL, &speed_rect, angle, &center, SDL_FLIP_NONE);
}



//////////////////////////////////
////Updates steering////////////////
//////////////////////////////////
void update_steering() {
  SDL_Rect dial_rect;
  SDL_Point center;
  int16_t angle = 0;
  dial_rect.x = 450;
  dial_rect.y = 220;
  dial_rect.h = 120;
  dial_rect.w = 120;
  SDL_RenderCopy(renderer, base_texture, &dial_rect, &dial_rect);
  /* Because it's a curve we do a smaller rect for the top */
  dial_rect.x = 450;
  dial_rect.y = 220;
  dial_rect.h = 120;
  dial_rect.w = 120;
  SDL_RenderCopy(renderer, base_texture, &dial_rect, &dial_rect);
  // And one more smaller box for the pivot point of the needle
  dial_rect.x = 450;
  dial_rect.y = 220;
  dial_rect.h = 120;
  dial_rect.w = 120;
  SDL_RenderCopy(renderer, base_texture, &dial_rect, &dial_rect);
  center.x = 50;
  center.y = 50;
  angle = current_steering_angle;//map(current_steering_angle, 100, 90, 100, 90);
  if(angle < -90) angle = -90;
  if(angle > 90) angle = 90;
  SDL_RenderCopyEx(renderer, steering_tex, NULL, &steering_rect, angle, &center, SDL_FLIP_NONE);

}

//////////////////////////////////
////Updates rpm //////////////////
//////////////////////////////////
void update_rpm() {
  SDL_Rect rpm_dial_rect;
  SDL_Point rpm_center;
  double angle = 0;
  rpm_dial_rect.x = 40;
  rpm_dial_rect.y = 80;
  rpm_dial_rect.h = 130;
  rpm_dial_rect.w = 80;
  SDL_RenderCopy(renderer, base_texture, &rpm_dial_rect, &rpm_dial_rect);
  /* Because it's a curve we do a smaller rect for the top */
  rpm_dial_rect.x = 50;
  rpm_dial_rect.y = 30;
  rpm_dial_rect.h = 65;
  rpm_dial_rect.w = 80;
  SDL_RenderCopy(renderer, base_texture, &rpm_dial_rect, &rpm_dial_rect);
  // And one more smaller box for the pivot point of the rpm needle
  rpm_dial_rect.x = 40;
  rpm_dial_rect.y = 171;
  rpm_dial_rect.h = 52;
  rpm_dial_rect.w = 47;
  SDL_RenderCopy(renderer, base_texture, &rpm_dial_rect, &rpm_dial_rect);
  rpm_center.x = 59.5;
  rpm_center.y = 7.5;
  angle = map(current_rpm/30, -620, 280, -620, 180);
  if(angle < -480) angle = -480;
  if(angle > 180) angle = 180;
  SDL_RenderCopyEx(renderer, rpm_needle_tex, NULL, &rpm_rect, angle, &rpm_center, SDL_FLIP_NONE);
}

//////////////////////////////////
////Updates oil temp /////////////
//////////////////////////////////
void update_oil_temp() {
  SDL_Rect oil_temp_dial_rect;
  SDL_Point oil_temp_center;
  double angle = 0;
  oil_temp_dial_rect.x = 120;
  oil_temp_dial_rect.y = 80;
  oil_temp_dial_rect.h = 130;
  oil_temp_dial_rect.w = 100;
  SDL_RenderCopy(renderer, base_texture, &oil_temp_dial_rect, &oil_temp_dial_rect);
  /* Because it's a curve we do a smaller rect for the top */
  oil_temp_dial_rect.x =  110;
  oil_temp_dial_rect.y = 30;
  oil_temp_dial_rect.h = 65;
  oil_temp_dial_rect.w = 100;
  SDL_RenderCopy(renderer, base_texture, &oil_temp_dial_rect, &oil_temp_dial_rect);
  // And one more smaller box for the pivot point of the oil_temp needle
  oil_temp_dial_rect.x = 120;
  oil_temp_dial_rect.y = 171;
  oil_temp_dial_rect.h = 52;
  oil_temp_dial_rect.w = 47;
  SDL_RenderCopy(renderer, base_texture, &oil_temp_dial_rect, &oil_temp_dial_rect);
  oil_temp_center.x = 6;
  oil_temp_center.y = 6;
  angle = map(current_oil_temp*-1, 100, 280, 100, 180);
  if(angle <-150) angle = -150;
  if(angle > 480) angle = 480;
  SDL_RenderCopyEx(renderer, oil_temp_needle_tex, NULL, &oil_temp_rect, angle, &oil_temp_center, SDL_FLIP_HORIZONTAL);
}


//////////////////////////////////
////Updates radiator temp ////////
//////////////////////////////////
void update_radiator_temp() {
  SDL_Rect radiator_temp_dial_rect;
  SDL_Point radiator_temp_center;
  double angle = 0;
  radiator_temp_dial_rect.x = 570;
  radiator_temp_dial_rect.y = 80;
  radiator_temp_dial_rect.h = 130;
  radiator_temp_dial_rect.w = 100;
  SDL_RenderCopy(renderer, base_texture, &radiator_temp_dial_rect, &radiator_temp_dial_rect);
  /* Because it's a curve we do a smaller rect for the top */
  radiator_temp_dial_rect.x =  560;
  radiator_temp_dial_rect.y = 30;
  radiator_temp_dial_rect.h = 65;
  radiator_temp_dial_rect.w = 100;
  SDL_RenderCopy(renderer, base_texture, &radiator_temp_dial_rect, &radiator_temp_dial_rect);
  // And one more smaller box for the pivot point of the radiator_temp needle
  radiator_temp_dial_rect.x = 570;
  radiator_temp_dial_rect.y = 171;
  radiator_temp_dial_rect.h = 52;
  radiator_temp_dial_rect.w = 47;
  SDL_RenderCopy(renderer, base_texture, &radiator_temp_dial_rect, &radiator_temp_dial_rect);
  radiator_temp_center.x = 6;
  radiator_temp_center.y = 6;
  angle = map(current_radiator_temp*-1.3, 60, 280, 60, 180);
  if(angle < -150) angle = -150;
  if(angle > 480) angle = 480;
  SDL_RenderCopyEx(renderer, radiator_temp_needle_tex, NULL, &radiator_temp_rect, angle, &radiator_temp_center, SDL_FLIP_HORIZONTAL);
}


//////////////////////////////////
////Updates battery //////////////
//////////////////////////////////
void update_battery() {
  SDL_Rect battery_dial_rect;
  SDL_Point battery_center;
  double angle = 0;
  battery_dial_rect.x = 470;
  battery_dial_rect.y = 80;
  battery_dial_rect.h = 130;
  battery_dial_rect.w = 100;
  SDL_RenderCopy(renderer, base_texture, &battery_dial_rect, &battery_dial_rect);
  /* Because it's a curve we do a smaller rect for the top */
  battery_dial_rect.x =  470;
  battery_dial_rect.y = 30;
  battery_dial_rect.h = 65;
  battery_dial_rect.w = 100;
  SDL_RenderCopy(renderer, base_texture, &battery_dial_rect, &battery_dial_rect);
  // And one more smaller box for the pivot point of the battery needle
  battery_dial_rect.x = 470;
  battery_dial_rect.y = 171;
  battery_dial_rect.h = 52;
  battery_dial_rect.w = 47;
  SDL_RenderCopy(renderer, base_texture, &battery_dial_rect, &battery_dial_rect);
  battery_center.x = 34;
  battery_center.y = 6;
  angle = map(current_battery*0.1, -220, 280, -220, 180);
  if(angle < -220) angle = -220;
  if(angle > 480) angle = 480;
  SDL_RenderCopyEx(renderer, battery_needle_tex, NULL, &battery_rect, angle, &battery_center, SDL_FLIP_NONE);
}

//////////////////////////////////
////Updates Horn Status //////////
//////////////////////////////////
void update_horn() {
  //printf("current_throttle_status=%d\r\n",current_throttle_status);
  SDL_Rect horn_area, pos;

  horn_area.x = 676;
  horn_area.y = 235;
  horn_area.w = 50;
  horn_area.h = 40;
  memcpy(&pos, &horn_area, sizeof(SDL_Rect));
  if(current_horn_status == OFF){
    SDL_RenderCopy(renderer, base_texture, &horn_area, &horn_area);
  }
  else {
    SDL_RenderCopy(renderer, sprite_tex, &horn_area, &pos);
  }
}


//////////////////////////////////
////Updates fuel /////////////////
//////////////////////////////////
void update_fuel() {
  SDL_Rect fuel_dial_rect;
  SDL_Point fuel_center;
  double angle = 0;
  fuel_dial_rect.x = 570;
  fuel_dial_rect.y = 160;
  fuel_dial_rect.h = 85;
  fuel_dial_rect.w = 100;
  SDL_RenderCopy(renderer, base_texture, &fuel_dial_rect, &fuel_dial_rect);
  /* Because it's a curve we do a smaller rect for the top */
  fuel_dial_rect.x =  570;
  fuel_dial_rect.y = 160;
  fuel_dial_rect.h = 85;
  fuel_dial_rect.w = 100;
  SDL_RenderCopy(renderer, base_texture, &fuel_dial_rect, &fuel_dial_rect);
  // And one more smaller box for the pivot point of the fuel needle
  fuel_dial_rect.x = 570;
  fuel_dial_rect.y = 160;
  fuel_dial_rect.h = 85;
  fuel_dial_rect.w = 100;
  SDL_RenderCopy(renderer, base_texture, &fuel_dial_rect, &fuel_dial_rect);
  fuel_center.x = 6;
  fuel_center.y = 6;
  angle = map(current_fuel*-3*2, 135, 280, 135, 180);
  if(angle < -150) angle = -150;
  if(angle > 480) angle = 480;
  SDL_RenderCopyEx(renderer, fuel_needle_tex, NULL, &fuel_rect, angle, &fuel_center, SDL_FLIP_HORIZONTAL);
}

//////////////////////////////////
////Updates window unlocks simulated by open icons
//////////////////////////////////
void update_doors() {
  SDL_Rect door_area, update, pos;
  door_area.x = 310;
  door_area.y = 195;
  door_area.w = 100;
  door_area.h = 125;
  SDL_RenderCopy(renderer, base_texture, &door_area, &door_area);
  // No update if all doors are locked
  if(door_status[0] == DOOR_LOCKED && door_status[1] == DOOR_LOCKED &&
     door_status[2] == DOOR_LOCKED && door_status[3] == DOOR_LOCKED) return;
 
  if(door_status[0] == DOOR_UNLOCKED) {
    update.x = 374;
    update.y = 185;
    update.w = 35;
    update.h = 65;
    memcpy(&pos, &update, sizeof(SDL_Rect));
    SDL_RenderCopy(renderer, sprite_tex, &update, &pos);
  }
  if(door_status[1] == DOOR_UNLOCKED) {
    update.x = 310;
    update.y = 185;
    update.w = 35;
    update.h = 65;
    memcpy(&pos, &update, sizeof(SDL_Rect));
    SDL_RenderCopy(renderer, sprite_tex, &update, &pos);
  }
  if(door_status[2] == DOOR_UNLOCKED) {
    update.x = 374;
    update.y = 250;
    update.w = 35;
    update.h = 45;
    memcpy(&pos, &update, sizeof(SDL_Rect));
    SDL_RenderCopy(renderer, sprite_tex, &update, &pos);
  }
  if(door_status[3] == DOOR_UNLOCKED) {
    update.x = 310;
    update.y = 250;
    update.w = 35;
    update.h = 45;
    memcpy(&pos, &update, sizeof(SDL_Rect));
    SDL_RenderCopy(renderer, sprite_tex, &update, &pos);
  }

}


//////////////////////////////////
////Updates door unlocks simulated by open icons
//////////////////////////////////
void update_windows() {
  SDL_Rect window_area, update, pos;
  window_area.x = 280;
  window_area.y = 240;
  window_area.w = 35;
  window_area.h = 35;
  SDL_RenderCopy(renderer, base_texture, &window_area, &window_area);
  window_area.x = 410;
  window_area.y = 240;
  window_area.w = 35;
  window_area.h = 35;
  SDL_RenderCopy(renderer, base_texture, &window_area, &window_area);
  window_area.x = 280;
  window_area.y = 280;
  window_area.w = 35;
  window_area.h = 35;
  SDL_RenderCopy(renderer, base_texture, &window_area, &window_area);
  window_area.x = 410;
  window_area.y = 280;
  window_area.w = 35;
  window_area.h = 35;
  SDL_RenderCopy(renderer, base_texture, &window_area, &window_area);
  // No update if all windows are locked
  if(window_status[0] == WINDOW_LOCKED && window_status[1] == WINDOW_LOCKED &&
     window_status[2] == WINDOW_LOCKED && window_status[3] == WINDOW_LOCKED) return;
 
  if(window_status[0] == WINDOW_UNLOCKED) {
    update.x = 410;
    update.y = 240;
    update.w = 35;
    update.h = 35;

    
    memcpy(&pos, &update, sizeof(SDL_Rect));
    SDL_RenderCopy(renderer, sprite_tex, &update, &pos);
  }
  if(window_status[1] == WINDOW_UNLOCKED) {
    update.x = 280;
    update.y = 240;
    update.w = 35;
    update.h = 35;
    memcpy(&pos, &update, sizeof(SDL_Rect));
    SDL_RenderCopy(renderer, sprite_tex, &update, &pos);
  }
  if(window_status[2] == WINDOW_UNLOCKED) {
    
    update.x = 410;
    update.y = 280;
    update.w = 35;
    update.h = 35;
    memcpy(&pos, &update, sizeof(SDL_Rect));
    SDL_RenderCopy(renderer, sprite_tex, &update, &pos);
  }
  if(window_status[3] == WINDOW_UNLOCKED) {
    update.x = 280;
    update.y = 280;
    update.w = 35;
    update.h = 35;
    memcpy(&pos, &update, sizeof(SDL_Rect));
    SDL_RenderCopy(renderer, sprite_tex, &update, &pos);
  }

}


//////////////////////////////////
////Updates turn signals /////////
//////////////////////////////////
void update_turn_signals() {
  SDL_Rect left, right, lpos, rpos;
  left.x = 232;
  left.y = 21;
  left.w = 75;
  left.h = 75;
  memcpy(&right, &left, sizeof(SDL_Rect));
  right.x = 402;
  memcpy(&lpos, &left, sizeof(SDL_Rect));
  memcpy(&rpos, &right, sizeof(SDL_Rect));
  lpos.x -= 22;
  lpos.y -= 22;
  rpos.x += 22;
  rpos.y -= 22;
  if(turn_status[0] == OFF) {
	SDL_RenderCopy(renderer, base_texture, &lpos, &lpos);
  } else {
	SDL_RenderCopy(renderer, sprite_tex, &left, &lpos);
  }
  if(turn_status[1] == OFF) {
	SDL_RenderCopy(renderer, base_texture, &rpos, &rpos);
  } else {
	SDL_RenderCopy(renderer, sprite_tex, &right, &rpos);
  }
}


//////////////////////////////////
////Updates light status /////////
//////////////////////////////////
void update_light() {
  SDL_Rect light_area, pos;

  light_area.x = 566;
  light_area.y = 230;
  light_area.w = 50;
  light_area.h = 40;
  memcpy(&pos, &light_area, sizeof(SDL_Rect));
  if(lightStatus == CAN_LIGHT_OFF){
    SDL_RenderCopy(renderer, base_texture, &light_area, &light_area);
  }
  else {
    SDL_RenderCopy(renderer, sprite_tex, &light_area, &pos);
  }
}


//////////////////////////////////
////Updates BLUETOOTH status /////////
//////////////////////////////////
void update_bluetooth() {
  SDL_Rect bluetooth_area, pos;

  bluetooth_area.x = 50;
  bluetooth_area.y = 285;
  bluetooth_area.w = 30;
  bluetooth_area.h = 35;
  memcpy(&pos, &bluetooth_area, sizeof(SDL_Rect));
  if(bluetooth_status == CAN_BLUETOOTH_OFF){
    SDL_RenderCopy(renderer, base_texture, &bluetooth_area, &bluetooth_area);
  }
  else {
    SDL_RenderCopy(renderer, sprite_tex, &bluetooth_area, &pos);
  }
}

void update_bluetooth_status(struct canfd_frame *cf, int maxdlen) {
  read_bluetooth_status(cf, maxdlen);
  update_bluetooth();
  SDL_RenderPresent(renderer);
}

void read_bluetooth_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    bluetooth_pos = DEFAULT_BLUETOOTH_POS + 16;
  }
  else 
  {
    bluetooth_pos = DEFAULT_BLUETOOTH_POS;
  }
  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  
  if (len < bluetooth_pos) {
    return;
  }

  bluetooth_status = cf->data[bluetooth_pos] ;
}



//////////////////////////////////
////Updates AUDIOSYSTEM status /////////
//////////////////////////////////
void update_audiosys() {
  SDL_Rect audiosys_area, pos;

  audiosys_area.x = 30;
  audiosys_area.y = 215;
  audiosys_area.w = 50;
  audiosys_area.h = 70;
  memcpy(&pos, &audiosys_area, sizeof(SDL_Rect));

  SDL_Rect audiosys_next_area, audiosys_next_pos;

  audiosys_next_area.x = 80;
  audiosys_next_area.y = 215;
  audiosys_next_area.w = 30;
  audiosys_next_area.h = 70;
  memcpy(&audiosys_next_pos, &audiosys_next_area, sizeof(SDL_Rect));

  SDL_Rect audiosys_prev_area, audiosys_prev_pos;

  audiosys_prev_area.x = 8;
  audiosys_prev_area.y = 215;
  audiosys_prev_area.w = 25;
  audiosys_prev_area.h = 70;
  memcpy(&audiosys_prev_pos, &audiosys_prev_area, sizeof(SDL_Rect));

  SDL_Rect audiosys_volumeUP_area, audiosys_volumeUP_pos;

  audiosys_volumeUP_area.x = 8;
  audiosys_volumeUP_area.y = 290;
  audiosys_volumeUP_area.w = 25;
  audiosys_volumeUP_area.h = 30;
  memcpy(&audiosys_volumeUP_pos, &audiosys_volumeUP_area, sizeof(SDL_Rect));

  SDL_Rect audiosys_volumeDown_area, audiosys_volumeDown_pos;

  audiosys_volumeDown_area.x = 65;
  audiosys_volumeDown_area.y = 290;
  audiosys_volumeDown_area.w = 35;
  audiosys_volumeDown_area.h = 30;
  memcpy(&audiosys_volumeDown_pos, &audiosys_volumeDown_area, sizeof(SDL_Rect));

  if(audiosys_status == CAN_RADIO_OFF){
    SDL_RenderCopy(renderer, base_texture, &audiosys_area, &audiosys_area);
    SDL_RenderCopy(renderer, base_texture, &audiosys_next_area, &audiosys_next_area);
    SDL_RenderCopy(renderer, base_texture, &audiosys_prev_area, &audiosys_prev_area);
    SDL_RenderCopy(renderer, base_texture, &audiosys_volumeUP_area, &audiosys_volumeUP_area);
    SDL_RenderCopy(renderer, base_texture, &audiosys_volumeDown_area, &audiosys_volumeDown_area);
  }
  else if(audiosys_status == CAN_RADIO_NextStation){
    SDL_RenderCopy(renderer, sprite_tex, &audiosys_next_area, &audiosys_next_area);
    SDL_RenderCopy(renderer, base_texture, &audiosys_prev_area, &audiosys_prev_area);
    SDL_RenderCopy(renderer, base_texture, &audiosys_volumeUP_area, &audiosys_volumeUP_area);
    SDL_RenderCopy(renderer, base_texture, &audiosys_volumeDown_area, &audiosys_volumeDown_area);
    lastTimeCheck = currentTime;
  }
  else if(audiosys_status == CAN_RADIO_PreviousStation){
    SDL_RenderCopy(renderer, base_texture, &audiosys_next_area, &audiosys_next_area);
    SDL_RenderCopy(renderer, sprite_tex, &audiosys_prev_area, &audiosys_prev_area);
    SDL_RenderCopy(renderer, base_texture, &audiosys_volumeUP_area, &audiosys_volumeUP_area);
    SDL_RenderCopy(renderer, base_texture, &audiosys_volumeDown_area, &audiosys_volumeDown_area);
    lastTimeCheck = currentTime;
  }
  else if(audiosys_status == CAN_RADIO_VolumeUp){
    SDL_RenderCopy(renderer, base_texture, &audiosys_next_area, &audiosys_next_area);
    SDL_RenderCopy(renderer, base_texture, &audiosys_prev_area, &audiosys_prev_area);
    SDL_RenderCopy(renderer, sprite_tex, &audiosys_volumeUP_area, &audiosys_volumeUP_area);
    SDL_RenderCopy(renderer, base_texture, &audiosys_volumeDown_area, &audiosys_volumeDown_area);
    lastTimeCheck = currentTime;
  }
  else if(audiosys_status == CAN_RADIO_VolumeDown){
    SDL_RenderCopy(renderer, base_texture, &audiosys_next_area, &audiosys_next_area);
    SDL_RenderCopy(renderer, base_texture, &audiosys_prev_area, &audiosys_prev_area);
    SDL_RenderCopy(renderer, base_texture, &audiosys_volumeUP_area, &audiosys_volumeUP_area);
    SDL_RenderCopy(renderer, sprite_tex, &audiosys_volumeDown_area, &audiosys_volumeDown_area);
    lastTimeCheck = currentTime;
  }
  else {
    SDL_RenderCopy(renderer, sprite_tex, &audiosys_area, &pos);
    SDL_RenderCopy(renderer, base_texture, &audiosys_next_area, &audiosys_next_area);
    SDL_RenderCopy(renderer, base_texture, &audiosys_prev_area, &audiosys_prev_area);
    SDL_RenderCopy(renderer, base_texture, &audiosys_volumeUP_area, &audiosys_volumeUP_area);
    SDL_RenderCopy(renderer, base_texture, &audiosys_volumeDown_area, &audiosys_volumeDown_area);
  }
}

void update_audiosys_status(struct canfd_frame *cf, int maxdlen) {
  read_audiosys_status(cf, maxdlen);
  update_audiosys();
  SDL_RenderPresent(renderer);
}

void read_audiosys_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    audiosys_pos = DEFAULT_AUDIOSYSTEM_POS + 16;
  }
  else 
  {
    audiosys_pos = DEFAULT_AUDIOSYSTEM_POS;
  }
  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  
  if (len < audiosys_pos) {
    return;
  }
  
  audiosys_status = cf->data[audiosys_pos] ;
}

//////////////////////////////////
////Updates AIRCONDITION status /////////
//////////////////////////////////
void update_aircondition() {
  SDL_Rect aircondition_area, pos;

  aircondition_area.x = 130;
  aircondition_area.y = 220;
  aircondition_area.w = 40;
  aircondition_area.h = 70;
  memcpy(&pos, &aircondition_area, sizeof(SDL_Rect));

  SDL_Rect aircondition_area_up, aircondition_area_up_pos;

  aircondition_area_up.x = 110;
  aircondition_area_up.y = 220;
  aircondition_area_up.w = 20;
  aircondition_area_up.h = 70;
  memcpy(&aircondition_area_up_pos, &aircondition_area_up, sizeof(SDL_Rect));

  SDL_Rect aircondition_area_down, aircondition_area_down_pos;

  aircondition_area_down.x = 175;
  aircondition_area_down.y = 220;
  aircondition_area_down.w = 20;
  aircondition_area_down.h = 70;

  memcpy(&aircondition_area_down_pos, &aircondition_area_down, sizeof(SDL_Rect));
  if(aircondition_status == CAN_AIRCONDITION_OFF){
    SDL_RenderCopy(renderer, base_texture, &aircondition_area, &aircondition_area);
    SDL_RenderCopy(renderer, base_texture, &aircondition_area_up, &aircondition_area_up_pos);
    SDL_RenderCopy(renderer, base_texture, &aircondition_area_down, &aircondition_area_down_pos);
  }
  else if(aircondition_status == CAN_AIRCONDITION_Down){
    SDL_RenderCopy(renderer, sprite_tex, &aircondition_area_up, &aircondition_area_up_pos);
    SDL_RenderCopy(renderer, base_texture, &aircondition_area_down, &aircondition_area_down_pos);
    lastTimeCheck = currentTime;
  }
  else if(aircondition_status == CAN_AIRCONDITION_Up){
    SDL_RenderCopy(renderer, base_texture, &aircondition_area_up, &aircondition_area_up_pos);
    SDL_RenderCopy(renderer, sprite_tex, &aircondition_area_down, &aircondition_area_down_pos);
    lastTimeCheck = currentTime;
  }
  else {
    SDL_RenderCopy(renderer, sprite_tex, &aircondition_area, &pos);
    SDL_RenderCopy(renderer, base_texture, &aircondition_area_up, &aircondition_area_up_pos);
    SDL_RenderCopy(renderer, base_texture, &aircondition_area_down, &aircondition_area_down_pos);
  }
}

void update_aircondition_status(struct canfd_frame *cf, int maxdlen) {
  read_aircondition_status(cf, maxdlen);
  update_aircondition();
  SDL_RenderPresent(renderer);
}

void read_aircondition_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    aircondition_pos = DEFAULT_AIRCONDITION_POS + 16;
  }
  else 
  {
    aircondition_pos = DEFAULT_AIRCONDITION_POS;
  }
  
  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if (len < aircondition_pos) {
    return;
  }
  
  aircondition_status = cf->data[aircondition_pos] ;
}



//////////////////////////////////
////Updates SATELITE NAVIGATION status /////////
//////////////////////////////////
void update_satelitenavigation() {
  SDL_Rect satelitenavigation_area, pos;

  satelitenavigation_area.x = 620;
  satelitenavigation_area.y = 270;
  satelitenavigation_area.w = 50;
  satelitenavigation_area.h = 55;
  memcpy(&pos, &satelitenavigation_area, sizeof(SDL_Rect));
  if(satelitenavigation_status == OFF){
    SDL_RenderCopy(renderer, base_texture, &satelitenavigation_area, &satelitenavigation_area);
  }
  else {
    SDL_RenderCopy(renderer, sprite_tex, &satelitenavigation_area, &pos);
  }
}

void update_satelitenavigation_status(struct canfd_frame *cf, int maxdlen) {
  read_satelitenavigation_status(cf, maxdlen);
  update_satelitenavigation();
  SDL_RenderPresent(renderer);
}

void read_satelitenavigation_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    satelitenavigation_pos = DEFAULT_SATELITENAVIGATION_POS + 16;
  }
  else 
  {
    satelitenavigation_pos = DEFAULT_SATELITENAVIGATION_POS;
  }
  
  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  
  if (len < satelitenavigation_pos) {
    return;
  }
  
  satelitenavigation_status = cf->data[satelitenavigation_pos] ;
}



//////////////////////////////////
////Updates DEFROSTER status /////////
//////////////////////////////////
void update_defroster() {
  SDL_Rect defroster_area, pos;

  defroster_area.x = 120;
  defroster_area.y = 290;
  defroster_area.w = 30;
  defroster_area.h = 25;
  memcpy(&pos, &defroster_area, sizeof(SDL_Rect));

  SDL_Rect defroster_rear_area, rear_pos;

  defroster_rear_area.x = 160;
  defroster_rear_area.y = 290;
  defroster_rear_area.w = 30;
  defroster_rear_area.h = 25;
  memcpy(&rear_pos, &defroster_rear_area, sizeof(SDL_Rect));

  if(defroster_status == CAN_DEFROSTER_FRONT_ON || defroster_status == CAN_DEFROSTER_FRONT_OFF)
  {
    if(defroster_front_status == CAN_DEFROSTER_FRONT_OFF){
      SDL_RenderCopy(renderer, sprite_tex, &defroster_area, &defroster_area);
      defroster_front_status = CAN_DEFROSTER_FRONT_ON;
      if(defroster_rear_status == CAN_DEFROSTER_REAR_ON)
      {
        defroster_both_status = CAN_DEFROSTER_BOTH_ON;
      }
    }
    else if(defroster_front_status == CAN_DEFROSTER_FRONT_ON)
    {
      SDL_RenderCopy(renderer, base_texture, &defroster_area, &defroster_area);
      defroster_front_status = CAN_DEFROSTER_FRONT_OFF;
      defroster_both_status = CAN_DEFROSTER_BOTH_OFF;
    }
  }
  else if (defroster_status == CAN_DEFROSTER_REAR_ON || defroster_status == CAN_DEFROSTER_REAR_OFF)
  {
    if (defroster_rear_status == CAN_DEFROSTER_REAR_OFF)
    {
      SDL_RenderCopy(renderer, sprite_tex, &defroster_rear_area, &defroster_rear_area);
      defroster_rear_status = CAN_DEFROSTER_REAR_ON;
      if(defroster_front_status == CAN_DEFROSTER_FRONT_ON)
      {
        defroster_both_status = CAN_DEFROSTER_BOTH_ON;
      }
    }
    else if (defroster_rear_status == CAN_DEFROSTER_REAR_ON)
    {
      SDL_RenderCopy(renderer, base_texture, &defroster_rear_area, &defroster_rear_area);
      defroster_rear_status = CAN_DEFROSTER_REAR_OFF;
      defroster_both_status = CAN_DEFROSTER_BOTH_OFF;
    }
  }
  else if (defroster_status == CAN_DEFROSTER_BOTH_ON  || defroster_status == CAN_DEFROSTER_BOTH_OFF)
  {

    if (defroster_both_status == CAN_DEFROSTER_BOTH_OFF)
    {
      SDL_RenderCopy(renderer, sprite_tex, &defroster_area, &defroster_area);
      SDL_RenderCopy(renderer, sprite_tex, &defroster_rear_area, &defroster_rear_area);
      defroster_both_status = CAN_DEFROSTER_BOTH_ON;
      defroster_front_status = CAN_DEFROSTER_FRONT_ON;
      defroster_rear_status = CAN_DEFROSTER_REAR_ON;
    }
    else if (defroster_both_status == CAN_DEFROSTER_BOTH_ON)
    {
      SDL_RenderCopy(renderer, base_texture, &defroster_area, &defroster_area);
      SDL_RenderCopy(renderer, base_texture, &defroster_rear_area, &defroster_rear_area);
      defroster_both_status = CAN_DEFROSTER_BOTH_OFF;
      defroster_front_status = CAN_DEFROSTER_FRONT_OFF;
      defroster_rear_status = CAN_DEFROSTER_REAR_OFF;
    }
  }
}

void update_defroster_status(struct canfd_frame *cf, int maxdlen) {
  read_defroster_status(cf, maxdlen);
  update_defroster();
  SDL_RenderPresent(renderer);
}

void read_defroster_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    defroster_pos = DEFAULT_DEFROSTER_POS + 16;
  }
  else 
  {
    defroster_pos = DEFAULT_DEFROSTER_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if (len < defroster_pos) {
    return;
  }
  
  defroster_status = cf->data[defroster_pos] ;
}



//////////////////////////////////
////Updates hand brake status/////
//////////////////////////////////
void update_handbrake() {
  SDL_Rect handbrake_area, pos;

  handbrake_area.x = 236;
  handbrake_area.y = 216;
  handbrake_area.w = 35;
  handbrake_area.h = 55;
  memcpy(&pos, &handbrake_area, sizeof(SDL_Rect));

  if(handbrake_status == CAN_HANDBRAKE_OFF){
    SDL_RenderCopy(renderer, base_texture, &handbrake_area, &handbrake_area);
  }
  else {
    SDL_RenderCopy(renderer, sprite_tex, &handbrake_area, &pos);
  }
}



//////////////////////////////////
////Updates brakecontrol status/////
//////////////////////////////////
void update_brakecontrol() {
  SDL_Rect brakecontrol_area, pos;

  brakecontrol_area.x = 310;
  brakecontrol_area.y = 305;
  brakecontrol_area.w = 105;
  brakecontrol_area.h = 15;
  memcpy(&pos, &brakecontrol_area, sizeof(SDL_Rect));
  if(brakecontrol_status == CAN_BRAKECONTROL_OFF){
    SDL_RenderCopy(renderer, base_texture, &brakecontrol_area, &brakecontrol_area);
  }
  else {
    SDL_RenderCopy(renderer, sprite_tex, &brakecontrol_area, &pos);
  }
}



//////////////////////////////////
////Updates ABS status/////
//////////////////////////////////
void update_abs() {
  SDL_Rect abs_area, pos;

  abs_area.x = 200;
  abs_area.y = 220;
  abs_area.w = 30;
  abs_area.h = 55;
  memcpy(&pos, &abs_area, sizeof(SDL_Rect));
  if(abs_status == CAN_ABS_OFF){
    SDL_RenderCopy(renderer, base_texture, &abs_area, &abs_area);
  }
  else {
    SDL_RenderCopy(renderer, sprite_tex, &abs_area, &pos);
  }
}


//////////////////////////////////
////Updates wiper status /////////
//////////////////////////////////
void update_wiper() {
  SDL_Rect wiper_area, wiper_pos;

  wiper_area.x = 620;
  wiper_area.y = 240;
  wiper_area.w = 45;
  wiper_area.h = 25;
  memcpy(&wiper_pos, &wiper_area, sizeof(SDL_Rect));
  if(wiper_status == CAN_WIPER_OFF){
    SDL_RenderCopy(renderer, base_texture, &wiper_area, &wiper_pos);
  }
  else {
    SDL_RenderCopy(renderer, sprite_tex, &wiper_area, &wiper_pos);
  }
}

//////////////////////////////////
////Updates airbag status /////////
//////////////////////////////////
void update_airbag() {
  SDL_Rect airbag_area, airbag_pos;

  airbag_area.x = 230;
  airbag_area.y = 270;
  airbag_area.w = 45;
  airbag_area.h = 55;
  memcpy(&airbag_pos, &airbag_area, sizeof(SDL_Rect));
  if(airbag_status == CAN_AIRBAG_OFF){
    SDL_RenderCopy(renderer, base_texture, &airbag_area, &airbag_pos);
  }
  else {
    SDL_RenderCopy(renderer, sprite_tex, &airbag_area, &airbag_pos);
  }
}



//////////////////////////////////
////Updates hazard status /////////
//////////////////////////////////
void update_hazard() {
  SDL_Rect hazard_area, hazard_pos;

  hazard_area.x = 670;
  hazard_area.y = 280;
  hazard_area.w = 45;
  hazard_area.h = 45;
  memcpy(&hazard_pos, &hazard_area, sizeof(SDL_Rect));
  if(hazard_status == CAN_HAZARD_OFF){
    SDL_RenderCopy(renderer, base_texture, &hazard_area, &hazard_pos);
  }
  else {
    SDL_RenderCopy(renderer, sprite_tex, &hazard_area, &hazard_pos);
  }
}



//////////////////////////////////
////Updates SUNROOF status /////////
//////////////////////////////////
void update_sunroof() {
  SDL_Rect sunroof_area, sunroof_pos;

  sunroof_area.x = 350;
  sunroof_area.y = 220;
  sunroof_area.w = 30;
  sunroof_area.h = 55;
  memcpy(&sunroof_pos, &sunroof_area, sizeof(SDL_Rect));
  if(sunroof_status == CAN_SUNROOF_OFF){
    SDL_RenderCopy(renderer, base_texture, &sunroof_area, &sunroof_pos);
  }
  else {
    SDL_RenderCopy(renderer, sprite_tex, &sunroof_area, &sunroof_pos);
  }
}


//////////////////////////////////
////Updates sidemirror status /////////
//////////////////////////////////
void update_sidemirror() {
  SDL_Rect sidemirror_area, sidemirror_pos;

  sidemirror_area.x = 270;
  sidemirror_area.y = 180;
  sidemirror_area.w = 40;
  sidemirror_area.h = 55;
  memcpy(&sidemirror_pos, &sidemirror_area, sizeof(SDL_Rect));

  SDL_Rect sidemirror_right_area, sidemirror_right_pos;

  sidemirror_right_area.x = 420;
  sidemirror_right_area.y = 180;
  sidemirror_right_area.w = 45;
  sidemirror_right_area.h = 55;
  memcpy(&sidemirror_right_pos, &sidemirror_right_area, sizeof(SDL_Rect));
  if(sidemirror_status == CAN_SIDEMIRROR_OFF){
    SDL_RenderCopy(renderer, base_texture, &sidemirror_area, &sidemirror_pos);
    SDL_RenderCopy(renderer, base_texture, &sidemirror_right_area, &sidemirror_right_pos);
    
  }
  else {
    SDL_RenderCopy(renderer, sprite_tex, &sidemirror_area, &sidemirror_pos);
    SDL_RenderCopy(renderer, sprite_tex, &sidemirror_right_area, &sidemirror_right_pos);
  }
}


//////////////////////////////////
////Updates trunk status /////////
//////////////////////////////////
void update_trunk() {
  SDL_Rect trunk_area, trunk_pos;

  trunk_area.x = 566;
  trunk_area.y = 270;
  trunk_area.w = 55;
  trunk_area.h = 55;
  memcpy(&trunk_pos, &trunk_area, sizeof(SDL_Rect));
  if(trunk_status == CAN_TRUNK_OFF){
    SDL_RenderCopy(renderer, base_texture, &trunk_area, &trunk_pos);
  }
  else {
    SDL_RenderCopy(renderer, sprite_tex, &trunk_area, &trunk_pos);
  }
}


//////////////////////////////////
////Updates cruisecontrol status /////////
//////////////////////////////////
void update_cruisecontrol() {
  SDL_Rect cruisecontrol_area, cruisecontrol_pos;

  cruisecontrol_area.x = 200;
  cruisecontrol_area.y = 270;
  cruisecontrol_area.w = 40;
  cruisecontrol_area.h = 55;
  memcpy(&cruisecontrol_pos, &cruisecontrol_area, sizeof(SDL_Rect));
  if(cruisecontrol_status == CAN_CRUISECONTROL_OFF){
    SDL_RenderCopy(renderer, base_texture, &cruisecontrol_area, &cruisecontrol_pos);
  }
  else {
    SDL_RenderCopy(renderer, sprite_tex, &cruisecontrol_area, &cruisecontrol_pos);
  }
}

//////////////////////////////////
////Parses CAN frame and updates cruisecontrol status
//////////////////////////////////
void update_cruisecontrol_status(struct canfd_frame *cf, int maxdlen) {
  read_cruisecontrol_status(cf, maxdlen);
  update_cruisecontrol();
  SDL_RenderPresent(renderer);
}

void read_cruisecontrol_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    cruisecontrol_pos = DEFAULT_CRUISECONTROL_POS + 16;
  }
  else 
  {
    cruisecontrol_pos = DEFAULT_CRUISECONTROL_POS;
  }
  
  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if (len < cruisecontrol_pos) {
    return;
  }
  
  cruisecontrol_status = cf->data[cruisecontrol_pos];
}

/* Redraws the IC updating everything
 * Slowest way to go.  Should only use on init
 */
void redraw_ic() {
  SDL_RenderClear(renderer); // Clear the renderer

  blank_ic();
  update_speed();
  update_rpm();
  update_oil_temp();
  update_radiator_temp();
  update_battery();
  update_horn();
  update_fuel();
  update_doors();
  update_windows();
  update_turn_signals();
  update_steering();
  update_light();
  update_bluetooth();
  update_audiosys();
  update_aircondition();
  update_satelitenavigation();
  update_defroster();
  update_handbrake();
  update_brakecontrol();
  update_abs();
  update_wiper();
  update_airbag();
  update_hazard();
  update_sunroof();
  update_sidemirror();
  update_trunk();
  update_cruisecontrol();
  
  SDL_RenderPresent(renderer);
}

//////////////////////////////////
////Parses CAN fram and updates current_speed
//////////////////////////////////
void update_speed_status(struct canfd_frame *cf, int maxdlen) {
  read_speed_status(cf, maxdlen);
  update_speed();
  SDL_RenderPresent(renderer);
}

void read_speed_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    speed_pos = DEFAULT_SPEED_POS + 16;
  }
  else 
  {
    speed_pos = DEFAULT_SPEED_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < speed_pos + 1) return;

  int speed = 0;
  speed = cf->data[speed_pos] << 8;
  speed += cf->data[speed_pos + 1];
  speed = speed / 100; // speed in kilometers
  current_speed = speed * 0.6213751; // mph

  gettimeofday(&t2, NULL);
  // compute and print the elapsed time in millisec
  elapsedTime = (t2.tv_sec - t1.tv_sec) * 1000.0;      // sec to ms
  elapsedTime += (t2.tv_usec - t1.tv_usec) / 1000.0;   // us to ms
      
}


//////////////////////////////////
////Parses CAN fram and updates current_steering_angle
//////////////////////////////////
void update_steering_status(struct canfd_frame *cf, int maxdlen) {
  read_steering_status(cf, maxdlen);
  update_steering();
  SDL_RenderPresent(renderer);
}

void read_steering_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    steering_pos = DEFAULT_STEERING_POS + 16;
  }
  else 
  {
    steering_pos = DEFAULT_STEERING_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < steering_pos + 1) return;

  current_steering_angle = cf->data[steering_pos] << 8;
  current_steering_angle += cf->data[steering_pos + 1];
}

//////////////////////////////////
////Parses CAN fram and updates current_rpm 
//////////////////////////////////
void update_rpm_status(struct canfd_frame *cf, int maxdlen) {
  read_rpm_status(cf, maxdlen);
  update_rpm();
  SDL_RenderPresent(renderer);
}

void read_rpm_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    rpm_pos = DEFAULT_RPM_POS + 16;
  }
  else 
  {
    rpm_pos = DEFAULT_RPM_POS;
  }
  
  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < rpm_pos + 1) return;
  
  current_rpm = cf->data[rpm_pos] << 8;
  current_rpm += cf->data[rpm_pos + 1];
}

//////////////////////////////////
////Parses CAN fram and updates current_oil_temp
//////////////////////////////////
void update_oil_temp_status(struct canfd_frame *cf, int maxdlen) {
  read_oil_temp_status(cf, maxdlen);
  update_oil_temp();
  SDL_RenderPresent(renderer);
}

void read_oil_temp_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    oil_temp_pos = DEFAULT_OIL_TEMPERATURE_POS + 16;
  }
  else 
  {
    oil_temp_pos = DEFAULT_OIL_TEMPERATURE_POS;
  }
  
  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < oil_temp_pos + 1) return;
  
  unsigned char float_bytes[4] = {
      cf->data[oil_temp_pos],
      cf->data[oil_temp_pos + 1],
      cf->data[oil_temp_pos + 2],
      cf->data[oil_temp_pos + 3]
  };
  float *float_ptr = (float *)float_bytes; // Treat the bytes as a float
  current_oil_temp = *float_ptr;
}


//////////////////////////////////
////Parses CAN fram and read current engine load
//////////////////////////////////
void read_radiator_temp(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    radiator_temp_pos = DEFAULT_RADIATOR_TEMPERATURE_POS + 16;
  }
  else 
  {
    radiator_temp_pos = DEFAULT_RADIATOR_TEMPERATURE_POS;
  }
  
  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < radiator_temp_pos + 1) return;
  
  unsigned char float_bytes[4] = {
      cf->data[radiator_temp_pos],
      cf->data[radiator_temp_pos + 1],
      cf->data[radiator_temp_pos + 2],
      cf->data[radiator_temp_pos + 3]
  };
  float *float_ptr = (float *)float_bytes; // Treat the bytes as a float
  current_radiator_temp = *float_ptr;
}


//////////////////////////////////
////Parses CAN fram and updates current_radiator_temp
//////////////////////////////////
void update_radiator_temp_status(struct canfd_frame *cf, int maxdlen) {
  read_radiator_temp(cf, maxdlen);
  update_radiator_temp();
  SDL_RenderPresent(renderer);
}


//////////////////////////////////
////Parses CAN fram and read current engine load
//////////////////////////////////
void read_engine_load(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    engine_load_pos = DEFAULT_ENGINE_LOAD_POS + 16;
  }
  else 
  {
    engine_load_pos = DEFAULT_ENGINE_LOAD_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < engine_load_pos + 1) return;

  unsigned char float_bytes[4] = {
      cf->data[engine_load_pos],
      cf->data[engine_load_pos + 1],
      cf->data[engine_load_pos + 2],
      cf->data[engine_load_pos + 3]
  };
  float *float_ptr = (float *)float_bytes; // Treat the bytes as a float
  current_engine_load = *float_ptr;
}

//////////////////////////////////
////Parses CAN fram and read current gear
//////////////////////////////////
void read_gear(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    gear_pos = DEFAULT_GEAR_POS + 16;
  }
  else 
  {
    gear_pos = DEFAULT_GEAR_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < gear_pos + 1) return;

  current_gear = cf->data[gear_pos] << 8;
  current_gear += cf->data[gear_pos + 1];
}

//////////////////////////////////
////Parses CAN fram and read current vvt
//////////////////////////////////
void read_vvt(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    vvt_pos = DEFAULT_VVT_POS + 16;
  }
  else 
  {
    vvt_pos = DEFAULT_VVT_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < vvt_pos + 1) return;
  
  unsigned char float_bytes[4] = {
      cf->data[vvt_pos],
      cf->data[vvt_pos + 1],
      cf->data[vvt_pos + 2],
      cf->data[vvt_pos + 3]
  };
  float *float_ptr = (float *)float_bytes; // Treat the bytes as a float
  current_vvt = *float_ptr;
}


//////////////////////////////////
////Parses CAN fram and read current oxygen sensor
//////////////////////////////////
void read_oxygen_sensor(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    oxygen_sensor_pos = DEFAULT_OXYGEN_SENSOR_POS + 16;
  }
  else 
  {
    oxygen_sensor_pos = DEFAULT_OXYGEN_SENSOR_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < oxygen_sensor_pos + 1) return;
  
  unsigned char float_bytes[4] = {
      cf->data[oxygen_sensor_pos],
      cf->data[oxygen_sensor_pos + 1],
      cf->data[oxygen_sensor_pos + 2],
      cf->data[oxygen_sensor_pos + 3]
  };
  float *float_ptr = (float *)float_bytes; // Treat the bytes as a float
  current_oxygen_sensor = *float_ptr;
}


//////////////////////////////////
////Parses CAN fram and read current air flow
//////////////////////////////////
void read_air_flow(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    air_flow_pos = DEFAULT_AIR_FLOW_POS + 16;
  }
  else 
  {
    air_flow_pos = DEFAULT_AIR_FLOW_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < air_flow_pos + 1) return;

  unsigned char float_bytes[4] = {
      cf->data[air_flow_pos],
      cf->data[air_flow_pos + 1],
      cf->data[air_flow_pos + 2],
      cf->data[air_flow_pos + 3]
  };
  float *float_ptr = (float *)float_bytes; // Treat the bytes as a float
  current_air_flow = *float_ptr;
}

//////////////////////////////////
////updates current_fuel status
//////////////////////////////////
void update_fuel_status(struct canfd_frame *cf, int maxdlen) {
  read_fuel_status(cf, maxdlen);
  update_fuel();
  SDL_RenderPresent(renderer);
}

//////////////////////////////////
////Parses CAN fram and read current_fuel
//////////////////////////////////
void read_fuel_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    fuel_pos = DEFAULT_FUEL_TANK_POS + 16;
  }
  else 
  {
    fuel_pos = DEFAULT_FUEL_TANK_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < fuel_pos + 1) return;
  
  unsigned char float_bytes[4] = {
      cf->data[fuel_pos],
      cf->data[fuel_pos + 1],
      cf->data[fuel_pos + 2],
      cf->data[fuel_pos + 3]
  };
  float *float_ptr = (float *)float_bytes; // Treat the bytes as a float
  current_fuel = *float_ptr;
}

//////////////////////////////////
////Parses CAN fram and updates current_battery 
//////////////////////////////////
void update_battery_status(struct canfd_frame *cf, int maxdlen) {
  read_battery_status(cf, maxdlen);
  update_battery();
  SDL_RenderPresent(renderer);
}

void read_battery_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    battery_pos = DEFAULT_BATTERY_POS + 16;
  }
  else 
  {
    battery_pos = DEFAULT_BATTERY_POS;
  }
  
  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < battery_pos + 1) return;

  unsigned char float_bytes[4] = {
      cf->data[battery_pos],
      cf->data[battery_pos + 1],
      cf->data[battery_pos + 2],
      cf->data[battery_pos + 3]
  };
  float *float_ptr = (float *)float_bytes; // Treat the bytes as a float
  current_battery = *float_ptr;
}
//////////////////////////////////
////Parses CAN fram and updates current_throttle_status 
//////////////////////////////////
void update_throttle_status(struct canfd_frame *cf, int maxdlen) {
  read_throttle_status(cf, maxdlen);
  SDL_RenderPresent(renderer);
}

void read_throttle_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    throttle_pos = DEFAULT_THROTTLE_POS + 16;
  }
  else 
  {
    throttle_pos = DEFAULT_THROTTLE_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < throttle_pos + 1) return;

  current_throttle_status = cf->data[throttle_pos];// << 8;
}

//////////////////////////////////
////Parses CAN fram and updates current_horn_status 
//////////////////////////////////
void update_horn_status(struct canfd_frame *cf, int maxdlen) {
  read_horn_status(cf, maxdlen);
  update_horn();
  SDL_RenderPresent(renderer);
}

void read_horn_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    horn_pos = DEFAULT_HORN_POS + 16;
  }
  else 
  {
    horn_pos = DEFAULT_HORN_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < horn_pos + 1) return;

  current_horn_status = cf->data[horn_pos];// << 8;
}

//////////////////////////////////
////Parses CAN frame and updates turn signal status
//////////////////////////////////
void update_signal_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    signal_pos = DEFAULT_SIGNAL_POS + 16;
  }
  else 
  {
    signal_pos = DEFAULT_SIGNAL_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < signal_pos) return;
  if(cf->data[signal_pos] & CAN_LEFT_SIGNAL) {
    turn_status[0] = ON;
  } else {
    turn_status[0] = OFF;
  }
  if(cf->data[signal_pos] & CAN_RIGHT_SIGNAL) {
    turn_status[1] = ON;
  } else {
    turn_status[1] = OFF;
  }
  update_turn_signals();
  SDL_RenderPresent(renderer);
}


//////////////////////////////////
////Parses CAN frame and updates door status
//////////////////////////////////
void update_door_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    door_pos = DEFAULT_DOOR_POS + 16;
  }
  else 
  {
    door_pos = DEFAULT_DOOR_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < door_pos) return;
  if(cf->data[door_pos] & CAN_DOOR1_LOCK) {
	door_status[0] = DOOR_LOCKED;
  } else {
	door_status[0] = DOOR_UNLOCKED;
  }
  if(cf->data[door_pos] & CAN_DOOR2_LOCK) {
	door_status[1] = DOOR_LOCKED;
  } else {
	door_status[1] = DOOR_UNLOCKED;
  }
  if(cf->data[door_pos] & CAN_DOOR3_LOCK) {
	door_status[2] = DOOR_LOCKED;
  } else {
	door_status[2] = DOOR_UNLOCKED;
  }
  if(cf->data[door_pos] & CAN_DOOR4_LOCK) {
	door_status[3] = DOOR_LOCKED;
  } else {
	door_status[3] = DOOR_UNLOCKED;
  }
  update_doors();
  SDL_RenderPresent(renderer);
}
void update_light_status(struct canfd_frame *cf, int maxdlen) {
  read_light_status(cf, maxdlen);
  update_light();
  SDL_RenderPresent(renderer);
}

void read_light_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    lightPos = DEFAULT_LIGHT_POS + 16;
  }
  else 
  {
    lightPos = DEFAULT_LIGHT_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  
  if (len < lightPos) {
    return;
  }

  lightStatus = cf->data[lightPos] ;
}




//////////////////////////////////
////Parses CAN frame and updates window status
//////////////////////////////////
void update_window_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    window_pos = DEFAULT_WINDOW_POS + 16;
  }
  else 
  {
    window_pos = DEFAULT_WINDOW_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if(len < window_pos) return;
  if(cf->data[window_pos] & CAN_WINDOW1_LOCK) {
	  window_status[0] = WINDOW_LOCKED;
  } else {
	  window_status[0] = WINDOW_UNLOCKED;
  }
  if(cf->data[window_pos] & CAN_WINDOW2_LOCK) {
	  window_status[1] = WINDOW_LOCKED;
  } else {
	  window_status[1] = WINDOW_UNLOCKED;
  }
  if(cf->data[window_pos] & CAN_WINDOW3_LOCK) {
	  window_status[2] = WINDOW_LOCKED;
  } else {
	  window_status[2] = WINDOW_UNLOCKED;
  }
  if(cf->data[window_pos] & CAN_WINDOW4_LOCK) {
	  window_status[3] = WINDOW_LOCKED;
  } else {
	  window_status[3] = WINDOW_UNLOCKED;
  }
  update_windows();
  SDL_RenderPresent(renderer);
}


//////////////////////////////////
////Parses CAN frame and updates handbrake status
//////////////////////////////////
void update_handbrake_status(struct canfd_frame *cf, int maxdlen) {
  read_handbrake_status(cf, maxdlen);
  update_handbrake();
  SDL_RenderPresent(renderer);
}

void read_handbrake_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    handbrake_pos = DEFAULT_HAND_BRAKE_POS + 16;
  }
  else 
  {
    handbrake_pos = DEFAULT_HAND_BRAKE_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if (len < handbrake_pos) {
    return;
  }

  handbrake_status = cf->data[handbrake_pos];
}


//////////////////////////////////
////Parses CAN frame and updates brakecontrol status
//////////////////////////////////
void update_brakecontrol_status(struct canfd_frame *cf, int maxdlen) {
  read_brakecontrol_status(cf, maxdlen);
  update_brakecontrol();
  SDL_RenderPresent(renderer);
}

void read_brakecontrol_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    brakecontrol_pos = DEFAULT_BRAKECONTROL_POS + 16;
  }
  else 
  {
    brakecontrol_pos = DEFAULT_BRAKECONTROL_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if (len < brakecontrol_pos) {
    return;
  }
  
  brakecontrol_status = cf->data[brakecontrol_pos];
}


//////////////////////////////////
////Parses CAN frame and updates ABS status
//////////////////////////////////
void update_abs_status(struct canfd_frame *cf, int maxdlen) {
  read_abs_status(cf, maxdlen);
  update_abs();
  SDL_RenderPresent(renderer);
}

void read_abs_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    abs_pos = DEFAULT_ABS_POS + 16;
  }
  else 
  {
    abs_pos = DEFAULT_ABS_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if (len < abs_pos) {
    return;
  }
  
  abs_status = cf->data[abs_pos];
}

//////////////////////////////////
////Parses CAN frame and updates wiper status
//////////////////////////////////
void update_wiper_status(struct canfd_frame *cf, int maxdlen) {
  read_wiper_status(cf, maxdlen);
  update_wiper();
  SDL_RenderPresent(renderer);
}

void read_wiper_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    wiper_pos = DEFAULT_WIPER_POS + 16;
  }
  else 
  {
    wiper_pos = DEFAULT_WIPER_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if (len < wiper_pos) {
    return;
  }
  
  wiper_status = cf->data[wiper_pos];
}


//////////////////////////////////
////Parses CAN frame and updates airbag status
//////////////////////////////////
void update_airbag_status(struct canfd_frame *cf, int maxdlen) {
  read_airbag_status(cf, maxdlen);
  update_airbag();
  SDL_RenderPresent(renderer);
}

void read_airbag_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    airbag_pos = DEFAULT_AIRBAG_POS + 16;
  }
  else 
  {
    airbag_pos = DEFAULT_AIRBAG_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if (len < airbag_pos) {
    return;
  }
  
  airbag_status = cf->data[airbag_pos];
}


//////////////////////////////////
////Parses CAN frame and updates hazard status
//////////////////////////////////
void update_hazard_status(struct canfd_frame *cf, int maxdlen) {
  read_hazard_status(cf, maxdlen);
  update_hazard();
  SDL_RenderPresent(renderer);
}

void read_hazard_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    hazard_pos = DEFAULT_HAZARD_POS + 16;
  }
  else 
  {
    hazard_pos = DEFAULT_HAZARD_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if (len < hazard_pos) {
    return;
  }
  
  hazard_status = cf->data[hazard_pos];
}

//////////////////////////////////
////Parses CAN frame and updates sunroof status
//////////////////////////////////
void update_sunroof_status(struct canfd_frame *cf, int maxdlen) {
  read_sunroof_status(cf, maxdlen);
  update_sunroof();
  SDL_RenderPresent(renderer);
}

void read_sunroof_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    sunroof_pos = DEFAULT_SUNROOF_POS + 16;
  }
  else 
  {
    sunroof_pos = DEFAULT_SUNROOF_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if (len < sunroof_pos) {
    return;
  }
  
  sunroof_status = cf->data[sunroof_pos];
}


//////////////////////////////////
////Parses CAN frame and updates sidemirror status
//////////////////////////////////
void update_sidemirror_status(struct canfd_frame *cf, int maxdlen) {
  read_sidemirror_status(cf, maxdlen);
  update_sidemirror();
  SDL_RenderPresent(renderer);
}

void read_sidemirror_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    sidemirror_pos = DEFAULT_SIDEMIRROR_POS + 16;
  }
  else 
  {
    sidemirror_pos = DEFAULT_SIDEMIRROR_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if (len < sidemirror_pos) {
    return;
  }
  
  sidemirror_status = cf->data[sidemirror_pos];
}


//////////////////////////////////
////Parses CAN frame and updates trunk status
//////////////////////////////////
void update_trunk_status(struct canfd_frame *cf, int maxdlen) {
  read_trunk_status(cf, maxdlen);
  update_trunk();
  SDL_RenderPresent(renderer);
}

void read_trunk_status(struct canfd_frame *cf, int maxdlen) {
  if(maxdlen == CANFD_MAX_DLEN)
  {
    trunk_pos = DEFAULT_TRUNK_POS + 16;
  }
  else 
  {
    trunk_pos = DEFAULT_TRUNK_POS;
  }

  int len = (cf->len > maxdlen) ? maxdlen : cf->len;
  if (len < trunk_pos) {
    return;
  }
  
  trunk_status = cf->data[trunk_pos];
}


//////////////////////////////////
////Usage Info////////////////////
//////////////////////////////////
void Usage(char *msg) {
  if(msg) printf("%s\n", msg);
  printf("Usage: icsim [options] <can>\n");
  printf("\t-r\trandomize IDs\n");
  printf("\t-s\tseed value\n");
  printf("\t-d\tdebug mode\n");
  printf("\t-l\tgenerate log  a: all, u:user controls, s: system controls, a+u+s for all together\n");
  printf("\t-c\tcomments in logs a:all else user and system\n");
  exit(1);
}


//////////////////////////////////
////CAN LOGGER TO SAVE LOGS////////
//////////////////////////////////
void canlogger(char *msg)
{
  char dateformat[32];
  struct timeval tv;
  gettimeofday(&tv, NULL);
    
  mkdir("./logs", S_IRWXU | S_IRWXG | S_IRWXO);
    
  // Format the filename
  strftime(dateformat, sizeof(dateformat), "./logs/%Y%m%d_CAN_Logs.txt", localtime(&tv.tv_sec));
    
  FILE *fcanlogger = fopen(dateformat, "a");
    
  // Format the timestamp
  fprintf(fcanlogger, "(%010llu.%06llu) %s ", 
          (unsigned long long)tv.tv_sec, 
          (unsigned long long)tv.tv_usec, 
          msg);
}

//////////////////////////////////
////CAN LOGGER TO SAVE FRAME LOGS////////
//////////////////////////////////
void canlogger_frame(struct canfd_frame *cf, int maxdlen, int frameloglevel, int log_comments_enabled)
{
  pthread_mutex_lock(&lock);
  struct timeval tv;
  gettimeofday(&tv, NULL);
    
  mkdir("./logs", S_IRWXU | S_IRWXG | S_IRWXO);
    
  // Format the filename
  char filename[100];
  strftime(filename, sizeof(filename), "./logs/%Y%m%d", localtime(&tv.tv_sec));
    
  if(frameloglevel == Frame_Log_Level_Both_User_System)
    strcat(filename, "_CAN_Both_user_System_Logs.txt");
  else if(frameloglevel == Frame_Log_Level_UserOnly)
    strcat(filename, "_CAN_UserOnly_Logs.txt");
  else if(frameloglevel == Frame_Log_Level_SegmentOnly)
  {
    NetworkSegment segment = get_segment_name(cf);
    strcat(filename, "_CAN_");
    strcat(filename, segment.name);
    strcat(filename, "_Segment_Logs.txt");
    strcpy(vcanName, segment.interface);
  }
  else
    strcat(filename, "_CAN_All_Logs.txt");
   
  FILE *fcanlogger = fopen(filename, "a");
    
  // Format the timestamp
  // Format the timestamp and write the log entry
  fprintf(fcanlogger, "(%010llu.%06llu) %s ", 
          (unsigned long long)tv.tv_sec, 
          (unsigned long long)tv.tv_usec, 
          vcanName);
  fprint_canframe(fcanlogger, cf, "", 0, maxdlen);
  

  if(log_comments_enabled == 1)
  {
    char comments[200];
    char commentsDetails[200];
    strcpy(comments, "");
    strcpy(commentsDetails, "");
    if(cf->can_id == DEFAULT_THROTTLE_ID)
    {
      read_throttle_status(cf, maxdlen);
      
      if(current_throttle_status == ON){
        strcpy(commentsDetails, " ON");
      }
      else {
        strcpy(commentsDetails, " OFF");
      }
      strcpy(comments, "Throttle");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_HORN_ID)
    {
      read_horn_status(cf, maxdlen);
      
      if(current_horn_status == ON){
        strcpy(commentsDetails, " ON");
      }
      else {
        strcpy(commentsDetails, " OFF");
      }
      strcpy(comments, "horn");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_SPEED_ID)
    {
      read_speed_status(cf,maxdlen);
      
      sprintf(commentsDetails," %ld", current_speed);
      strcpy(comments, "Speed");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_RPM_ID)
    {
      read_rpm_status(cf,maxdlen);
      
      sprintf(commentsDetails," %ld", current_rpm);
      strcpy(comments, "RPM");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_STEERING_ID)
    {
      read_steering_status(cf,maxdlen);
      
      sprintf(commentsDetails," %d", current_steering_angle);
      strcpy(comments, "STEERING ANGLE");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_SIGNAL_ID)
    {
      if(maxdlen == CANFD_MAX_DLEN)
      {
        signal_pos = DEFAULT_SIGNAL_POS + 16;
      }
      else 
      {
        signal_pos = DEFAULT_SIGNAL_POS;
      }

      int len = (cf->len > maxdlen) ? maxdlen : cf->len;
      if(len < signal_pos) {
          printf("Exiting due to len < signal_pos\n");
          return;
      }
      
      if(cf->data[signal_pos] & CAN_LEFT_SIGNAL) {
          strcpy(commentsDetails, " Left ON");
          last_left_signal_status = ON;
          last_right_signal_status = OFF;
      } 
      else if(cf->data[signal_pos] & CAN_RIGHT_SIGNAL) {
          strcpy(commentsDetails, " Right ON");
          last_right_signal_status = ON;
          last_left_signal_status = OFF;
      }
      else {
          
          if(last_left_signal_status == ON && last_right_signal_status == OFF){
            strcpy(commentsDetails, " Left OFF");
          }
          else if(last_right_signal_status == ON && last_left_signal_status == OFF)
          {
            strcpy(commentsDetails, " Right OFF");
          }
          else {
              //printf("No signal change detected\n");
          }
      }
     
      strcpy(comments, "Signal");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_DOOR_ID)
    {
      if(maxdlen == CANFD_MAX_DLEN)
      {
        door_pos = DEFAULT_DOOR_POS + 16;
      }
      else 
      {
        door_pos = DEFAULT_DOOR_POS;
      }

      int len = (cf->len > maxdlen) ? maxdlen : cf->len;
      if(len < door_pos) return;
      if(cf->data[door_pos] & CAN_DOOR1_LOCK) {
      door_status[0] = DOOR_LOCKED;
      } else {
      door_status[0] = DOOR_UNLOCKED;
      }
      if(cf->data[door_pos] & CAN_DOOR2_LOCK) {
      door_status[1] = DOOR_LOCKED;
      } else {
      door_status[1] = DOOR_UNLOCKED;
      }
      if(cf->data[door_pos] & CAN_DOOR3_LOCK) {
      door_status[2] = DOOR_LOCKED;
      } else {
      door_status[2] = DOOR_UNLOCKED;
      }
      if(cf->data[door_pos] & CAN_DOOR4_LOCK) {
      door_status[3] = DOOR_LOCKED;
      } else {
      door_status[3] = DOOR_UNLOCKED;
      }
      if(last_door_status[0] != door_status[0] && last_door_status[1] != door_status[1] && last_door_status[2] != door_status[2] && last_door_status[3] != door_status[3])
      {
        if(door_status[0] == DOOR_LOCKED && door_status[1] == DOOR_LOCKED &&
          door_status[2] == DOOR_LOCKED && door_status[3] == DOOR_LOCKED){
            strcpy(commentsDetails, " All Locked");
        }
        else if(door_status[0] == DOOR_UNLOCKED && door_status[1] == DOOR_UNLOCKED &&
          door_status[2] == DOOR_UNLOCKED && door_status[3] == DOOR_UNLOCKED){
            strcpy(commentsDetails, " All Unlocked");
        }
      }
      else if(last_door_status[0] != door_status[0] && last_door_status[1] == door_status[1] && last_door_status[2] == door_status[2] && last_door_status[3] == door_status[3])
      {
        if(door_status[0] == DOOR_LOCKED)
        {
          strcpy(commentsDetails, " Front Right Locked");
        }
        else 
        {
          strcpy(commentsDetails, " Front Right Unlocked");
        }
      }
      else if(last_door_status[0] == door_status[0] && last_door_status[1] != door_status[1] && last_door_status[2] == door_status[2] && last_door_status[3] == door_status[3])
      {
        if(door_status[1] == DOOR_LOCKED)
        {
          strcpy(commentsDetails, " Front Left Locked");
        }
        else 
        {
          strcpy(commentsDetails, " Front Left Unlocked");
        }
      }
      else if(last_door_status[0] == door_status[0] && last_door_status[1] == door_status[1] && last_door_status[2] != door_status[2] && last_door_status[3] == door_status[3])
      {
        if(door_status[2] == DOOR_LOCKED)
        {
          strcpy(commentsDetails, " Rear Right Locked");
        }
        else 
        {
          strcpy(commentsDetails, " Rear Right Unlocked");
        }
      }
      else if(last_door_status[0] == door_status[0] && last_door_status[1] == door_status[1] && last_door_status[2] == door_status[2] && last_door_status[3] != door_status[3])
      {
        if(door_status[3] == DOOR_LOCKED)
        {
          strcpy(commentsDetails, " Rear Left Locked");
        }
        else 
        {
          strcpy(commentsDetails, " Rear Left Unlocked");
        }
      }
      else 
      {
        if(door_status[0] == DOOR_LOCKED && door_status[1] == DOOR_LOCKED &&
          door_status[2] == DOOR_LOCKED && door_status[3] == DOOR_LOCKED){
            strcpy(commentsDetails, " All Locked");
        }
        else if(door_status[0] == DOOR_UNLOCKED && door_status[1] == DOOR_UNLOCKED &&
          door_status[2] == DOOR_UNLOCKED && door_status[3] == DOOR_UNLOCKED){
            strcpy(commentsDetails, " All Unlocked");
        }
      }
      

      strcpy(comments, "Door");
      strcat(comments, commentsDetails);
      last_door_status[0] = door_status[0];
      last_door_status[1] = door_status[1];
      last_door_status[2] = door_status[2];
      last_door_status[3] = door_status[3];
    }
     else if(cf->can_id == DEFAULT_WINDOW_ID)
    {
      if(maxdlen == CANFD_MAX_DLEN)
      {
        window_pos = DEFAULT_WINDOW_POS + 16;
      }
      else 
      {
        window_pos = DEFAULT_WINDOW_POS;
      }

      int len = (cf->len > maxdlen) ? maxdlen : cf->len;
      if(len < window_pos) return;
      if(cf->data[window_pos] & CAN_WINDOW1_LOCK) {
      window_status[0] = WINDOW_LOCKED;
      } else {
      window_status[0] = WINDOW_UNLOCKED;
      }
      if(cf->data[window_pos] & CAN_WINDOW2_LOCK) {
      window_status[1] = WINDOW_LOCKED;
      } else {
      window_status[1] = WINDOW_UNLOCKED;
      }
      if(cf->data[window_pos] & CAN_WINDOW3_LOCK) {
      window_status[2] = WINDOW_LOCKED;
      } else {
      window_status[2] = WINDOW_UNLOCKED;
      }
      if(cf->data[window_pos] & CAN_WINDOW4_LOCK) {
      window_status[3] = WINDOW_LOCKED;
      } else {
      window_status[3] = WINDOW_UNLOCKED;
      }
      if(last_window_status[0] != window_status[0] && last_window_status[1] != window_status[1] && last_window_status[2] != window_status[2] && last_window_status[3] != window_status[3])
      {
        if(window_status[0] == WINDOW_LOCKED && window_status[1] == WINDOW_LOCKED &&
          window_status[2] == WINDOW_LOCKED && window_status[3] == WINDOW_LOCKED){
            strcpy(commentsDetails, " All Locked");
        }
        else if(window_status[0] == WINDOW_UNLOCKED && window_status[1] == WINDOW_UNLOCKED &&
          window_status[2] == WINDOW_UNLOCKED && window_status[3] == WINDOW_UNLOCKED){
            strcpy(commentsDetails, " All Unlocked");
        }
      }
      else if(last_window_status[0] != window_status[0] && last_window_status[1] == window_status[1] && last_window_status[2] == window_status[2] && last_window_status[3] == window_status[3])
      {
        if(window_status[0] == WINDOW_LOCKED)
        {
          strcpy(commentsDetails, " Front Right Locked");
        }
        else 
        {
          strcpy(commentsDetails, " Front Right Unlocked");
        }
      }
      else if(last_window_status[0] == window_status[0] && last_window_status[1] != window_status[1] && last_window_status[2] == window_status[2] && last_window_status[3] == window_status[3])
      {
        if(window_status[1] == WINDOW_LOCKED)
        {
          strcpy(commentsDetails, " Front Left Locked");
        }
        else 
        {
          strcpy(commentsDetails, " Front Left Unlocked");
        }
      }
      else if(last_window_status[0] == window_status[0] && last_window_status[1] == window_status[1] && last_window_status[2] != window_status[2] && last_window_status[3] == window_status[3])
      {
        if(window_status[2] == WINDOW_LOCKED)
        {
          strcpy(commentsDetails, " Rear Right Locked");
        }
        else 
        {
          strcpy(commentsDetails, " Rear Right Unlocked");
        }
      }
      else if(last_window_status[0] == window_status[0] && last_window_status[1] == window_status[1] && last_window_status[2] == window_status[2] && last_window_status[3] != window_status[3])
      {
        if(window_status[3] == WINDOW_LOCKED)
        {
          strcpy(commentsDetails, " Rear Left Locked");
        }
        else 
        {
          strcpy(commentsDetails, " Rear Left Unlocked");
        }
      }
      else 
      {
        if(window_status[0] == WINDOW_LOCKED && window_status[1] == WINDOW_LOCKED &&
          window_status[2] == WINDOW_LOCKED && window_status[3] == WINDOW_LOCKED){
            strcpy(commentsDetails, " All Locked");
        }
        else if(window_status[0] == WINDOW_UNLOCKED && window_status[1] == WINDOW_UNLOCKED &&
          window_status[2] == WINDOW_UNLOCKED && window_status[3] == WINDOW_UNLOCKED){
            strcpy(commentsDetails, " All Unlocked");
        }
      }
      

      strcpy(comments, "window");
      strcat(comments, commentsDetails);
      last_window_status[0] = window_status[0];
      last_window_status[1] = window_status[1];
      last_window_status[2] = window_status[2];
      last_window_status[3] = window_status[3];
    }
    else if(cf->can_id == DEFAULT_LIGHT_ID)
    {
      read_light_status(cf, maxdlen);
      
      if(lightStatus == CAN_LIGHT_OFF){
        strcpy(commentsDetails, " OFF");
      }
      else {
        strcpy(commentsDetails, " ON");
      }
      strcpy(comments, "Light");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_BLUETOOTH_ID)
    {
      read_bluetooth_status(cf, maxdlen);
      
      if(bluetooth_status == CAN_BLUETOOTH_OFF){
        strcpy(commentsDetails, " OFF");
      }
      else {
        strcpy(commentsDetails, " ON");
      }
      strcpy(comments, "BLUETOOTH");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_AUDIOSYSTEM_ID)
    {
      read_audiosys_status(cf, maxdlen);
      
      if(audiosys_status == CAN_RADIO_OFF){
        strcpy(commentsDetails, " OFF");
      }
      else if(audiosys_status == CAN_RADIO_NextStation){
        strcpy(commentsDetails, " NextStation");
      }
      else if(audiosys_status == CAN_RADIO_PreviousStation){
        strcpy(commentsDetails, " PreviousStation");
      }
      else if(audiosys_status == CAN_RADIO_VolumeUp){
        strcpy(commentsDetails, " VolumeUp");
      }
      else if(audiosys_status == CAN_RADIO_VolumeDown){
        strcpy(commentsDetails, " VolumeDown");
      }
      else {
        strcpy(commentsDetails, " ON");
      }
      strcpy(comments, "Radio");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_AIRCONDITION_ID)
    {
      read_aircondition_status(cf, maxdlen);
      
      if(aircondition_status == CAN_AIRCONDITION_OFF){
        strcpy(commentsDetails, " OFF");
      }
      else if(aircondition_status == CAN_AIRCONDITION_Up){
        strcpy(commentsDetails, " UP");
      }
      else if(aircondition_status == CAN_AIRCONDITION_Down){
        strcpy(commentsDetails, " DOWN");
      }
      else {
        strcpy(commentsDetails, " ON");
      }
      strcpy(comments, "AIRCONDITION");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_SATELITENAVIGATION_ID)
    {
      read_satelitenavigation_status(cf, maxdlen);
      
      if(satelitenavigation_status == OFF){
        strcpy(commentsDetails, " OFF");
      }
      else {
        strcpy(commentsDetails, " ON");
      }
      strcpy(comments, "SATELITENAVIGATION");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_DEFROSTER_ID)
    {
      read_defroster_status(cf, maxdlen);
      
      if(defroster_status == CAN_DEFROSTER_FRONT_ON){
        strcpy(commentsDetails, " FRONT ON");
      }
      else if(defroster_status == CAN_DEFROSTER_FRONT_OFF){
        strcpy(commentsDetails, " FRONT OFF");
      }
      else if(defroster_status == CAN_DEFROSTER_REAR_ON){
        strcpy(commentsDetails, " REAR ON");
      }
      else if(defroster_status == CAN_DEFROSTER_REAR_OFF){
        strcpy(commentsDetails, " REAR OFF");
      }
      else if(defroster_status == CAN_DEFROSTER_BOTH_ON){
        strcpy(commentsDetails, " BOTH ON");
      }
      else if(defroster_status == CAN_DEFROSTER_BOTH_OFF){
        strcpy(commentsDetails, " BOTH OFF");
      }
      
      strcpy(comments, "DEFROSTER");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_HANDBRAKE_ID)
    {
      read_handbrake_status(cf, maxdlen);

      if(handbrake_status == CAN_HANDBRAKE_OFF){
        strcpy(commentsDetails, " OFF");
      }
      else {
        strcpy(commentsDetails, " ON");
      }
      strcpy(comments, "Handbrake");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_BRAKECONTROL_ID)
    {
      read_brakecontrol_status(cf, maxdlen);

      if(brakecontrol_status == CAN_BRAKECONTROL_OFF){
        strcpy(commentsDetails, " OFF");
      }
      else {
        strcpy(commentsDetails, " ON");
      }
      strcpy(comments, "BrakeControl");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_ABS_ID)
    {
      read_abs_status(cf, maxdlen);

      if(abs_status == CAN_ABS_OFF){
        strcpy(commentsDetails, " OFF");
      }
      else {
        strcpy(commentsDetails, " ON");
      }
      strcpy(comments, "ABS");
      strcat(comments, commentsDetails);
    }
    
    else if(cf->can_id == DEFAULT_WIPER_ID)
    {
      read_wiper_status(cf, maxdlen);
      
      if(wiper_status == CAN_WIPER_OFF){
        strcpy(commentsDetails, " OFF");
      }
      else {
        strcpy(commentsDetails, " ON");
      }
      strcpy(comments, "Wiper");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_AIRBAG_ID)
    {
      read_airbag_status(cf, maxdlen);
      
      if(airbag_status == CAN_AIRBAG_OFF){
        strcpy(commentsDetails, " OFF");
      }
      else {
        strcpy(commentsDetails, " ON");
      }
      strcpy(comments, "airbag");
      strcat(comments, commentsDetails);
    }
    
    else if(cf->can_id == DEFAULT_HAZARD_ID)
    {
      read_hazard_status(cf, maxdlen);
      
      if(hazard_status == CAN_HAZARD_OFF){
        strcpy(commentsDetails, " OFF");
      }
      else {
        strcpy(commentsDetails, " ON");
      }
      strcpy(comments, "hazard");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_SUNROOF_ID)
    {
      read_sunroof_status(cf, maxdlen);
      
      if(sunroof_status == CAN_SUNROOF_OFF){
        strcpy(commentsDetails, " OFF");
      }
      else {
        strcpy(commentsDetails, " ON");
      }
      strcpy(comments, "Sunroof");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_SIDEMIRROR_ID)
    {
      read_sidemirror_status(cf, maxdlen);
      
      if(sidemirror_status == CAN_SIDEMIRROR_OFF){
        strcpy(commentsDetails, " OFF");
      }
      else {
        strcpy(commentsDetails, " ON");
      }
      strcpy(comments, "sidemirror");
      strcat(comments, commentsDetails);
    }
    
    else if(cf->can_id == DEFAULT_TRUNK_ID)
    {
      read_trunk_status(cf, maxdlen);
      
      if(trunk_status == CAN_TRUNK_OFF){
        strcpy(commentsDetails, " OFF");
      }
      else {
        strcpy(commentsDetails, " ON");
      }
      strcpy(comments, "Trunk");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_CRUISECONTROL_ID)
    {
      read_cruisecontrol_status(cf, maxdlen);
      
      if(cruisecontrol_status == CAN_CRUISECONTROL_OFF){
        strcpy(commentsDetails, " OFF");
      }
      else {
        strcpy(commentsDetails, " ON");
      }
      strcpy(comments, "CruiseControl");
      strcat(comments, commentsDetails);
    }
    
    else if(cf->can_id == DEFAULT_RADIATOR_TEMPERATURE_ID)
    {
      read_radiator_temp(cf, maxdlen);
      
      sprintf(commentsDetails," %f", current_radiator_temp);
      strcpy(comments, "RadiatorTemp");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_ENGINE_LOAD_ID)
    {
      read_engine_load(cf, maxdlen);
      
      sprintf(commentsDetails," %f", current_engine_load);
      strcpy(comments, "Engine_Load");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_GEAR_ID)
    {
      read_gear(cf, maxdlen);
      
      sprintf(commentsDetails," %d", current_gear);
      strcpy(comments, "Gear");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_VVT_ID)
    {
      read_vvt(cf, maxdlen);
      
      sprintf(commentsDetails," %f", current_vvt);
      strcpy(comments, "VVT");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_OXYGEN_SENSOR_ID)
    {
      read_oxygen_sensor(cf, maxdlen);
      
      
      sprintf(commentsDetails," %f", current_oxygen_sensor);
      strcpy(comments, "Oxygen_Sensor");
      strcat(comments, commentsDetails);
    }
    
    else if(cf->can_id == DEFAULT_AIR_FLOW_ID)
    {
      read_air_flow(cf, maxdlen);
      
      sprintf(commentsDetails," %f", current_air_flow);
      strcpy(comments, "Air_Flow");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_OIL_TEMPERATURE_ID)
    {
      read_oil_temp_status(cf, maxdlen);
      
      sprintf(commentsDetails," %f", current_oil_temp);
      strcpy(comments, "OilTemp");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_FUEL_TANK_ID)
    {
      read_fuel_status(cf, maxdlen);
      
      sprintf(commentsDetails," %f", current_fuel);
      strcpy(comments, "FuelTank");
      strcat(comments, commentsDetails);
    }
    else if(cf->can_id == DEFAULT_BATTERY_ID)
    {
      read_battery_status(cf, maxdlen);
      
      sprintf(commentsDetails," %f", current_battery);
      strcpy(comments, "Battery");
      strcat(comments, commentsDetails);
    }
    if(comments[0] != '\0')
    {
      fprintf(fcanlogger, " //%s\n",comments);
    }
    else {
      fprintf(fcanlogger, "\n");
    }
  }
  else
  {
   fprintf(fcanlogger, "\n"); 
  }
	fclose(fcanlogger);
  pthread_mutex_unlock(&lock);
}

//////////////////////////////////
////PROGRAM STARTING POINT////////
//////////////////////////////////
int main(int argc, char *argv[]) {
  int opt;
  int can;
  struct ifreq ifr;
  struct sockaddr_can addr;
  struct canfd_frame frame;
  struct iovec iov;
  struct msghdr msg;
  struct cmsghdr *cmsg;
  struct stat dirstat;
  char ctrlmsg[CMSG_SPACE(sizeof(struct timeval)) + CMSG_SPACE(sizeof(__u32))];
  int running = 1;
  int nbytes, maxdlen;
  int seed = 0;
  // start timer
  gettimeofday(&t1, NULL);
  // 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);

  canid_t door_id, signal_id, speed_id, light_id, handbrake_id, wiper_id, rpm_id, oil_temp_id, radiator_temp_id, fuel_id, battery_id, throttle_id, bluetooth_id, audiosys_id, aircondition_id, satelitenavigation_id, defroster_id, brakecontrol_id, abs_id, cruisecontrol_id, window_id, horn_id, trunk_id, sidemirror_id, sunroof_id, hazard_id, airbag_id, steering_id, engine_load_id, air_flow_id, oxygen_sensor_id, vvt_id, gear_id;
  SDL_Event event;
  while ((opt = getopt(argc, argv, "rsl:dmc:h?")) != -1) {
    switch(opt) {
	case 'r':
		randomize = 1;
		break;
	case 's':
		seed = atoi(optarg);
		break;
	case 'd':
		debug = 1;
		break;
  case 'c':
    commentsfilter = optarg;
    log_all_comments_enabled = 0;
    log_system_comments_enabled = 0;
    log_user_comments_enabled = 0;
    log_segment_comments_enabled = 0;
    if (commentsfilter != NULL && commentsfilter[0] != '\0' ) {
      if(strchr(commentsfilter, 'a' )){
        log_all_comments_enabled = 1;
      }
      if(strchr(commentsfilter, 'u' )){
        log_user_comments_enabled = 1;
      }
      if(strchr(commentsfilter, 's' )){
        log_system_comments_enabled = 1;
      }
      if(strchr(commentsfilter, 't' )){
        log_segment_comments_enabled = 1;
      }
    }
    break;
  case 'l':
    logfilter = optarg;
    if(logfilter == NULL)
    {
      log_all_enabled = 1;
      log_user_enabled = 1;
      log_system_enabled = 1;
      log_segment_enabled = 1;
    }
    if (strchr( logfilter, 'a' )) {
      log_all_enabled = 1;
    }
    if (strchr( logfilter, 'u' )) {
      log_user_enabled = 1;
    }
    if (strchr( logfilter, 's' )) {
      log_system_enabled = 1;
    }
    if (strchr( logfilter, 't' )) {
      log_segment_enabled = 1;
    } 
    break;
	case 'h':
	case '?':
	default:
		Usage(NULL);
		break;
    }
  }
  if (optind >= argc) Usage("You must specify at least one can device");
  if (seed && randomize) Usage("You can not specify a seed value AND randomize the seed");
  // Verify data directory exists
  if(stat(DATA_DIR, &dirstat) == -1) {
  	printf("ERROR: DATA_DIR not found.  Define in make file or run in src dir\n");
	exit(34);
  }

  // Create a new raw CAN socket
  can = socket(PF_CAN, SOCK_RAW, CAN_RAW);
  if(can < 0) Usage("Couldn't create raw socket");
  addr.can_family = AF_CAN;
  memset(&ifr.ifr_name, 0, sizeof(ifr.ifr_name));
  strncpy(ifr.ifr_name, argv[optind], strlen(argv[optind]));
  strcpy(vcanName, ifr.ifr_name);
  printf("Using CAN interface %s\n", ifr.ifr_name);
  if (ioctl(can, SIOCGIFINDEX, &ifr) < 0) {
    perror("SIOCGIFINDEX");
    exit(1);
  }
  addr.can_ifindex = ifr.ifr_ifindex;
  // CAN FD Mode
  setsockopt(can, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on));
  iov.iov_base = &frame;
  iov.iov_len = sizeof(frame);
  msg.msg_name = &addr;
  msg.msg_namelen = sizeof(addr);
  msg.msg_iov = &iov;
  msg.msg_iovlen = 1;
  msg.msg_control = &ctrlmsg;
  msg.msg_controllen = sizeof(ctrlmsg);
  msg.msg_flags = 0;
  if (bind(can, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
	perror("bind");
	return 1;
  }
  init_car_state();
  door_id = DEFAULT_DOOR_ID;
  window_id = DEFAULT_WINDOW_ID;
  signal_id = DEFAULT_SIGNAL_ID;
  speed_id = DEFAULT_SPEED_ID;
  steering_id = DEFAULT_STEERING_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;
  vvt_id = DEFAULT_VVT_ID;
  oxygen_sensor_id = DEFAULT_OXYGEN_SENSOR_ID;
  air_flow_id = DEFAULT_AIR_FLOW_ID;
  fuel_id = DEFAULT_FUEL_TANK_ID;
  battery_id = DEFAULT_BATTERY_ID;
  throttle_id = DEFAULT_THROTTLE_ID;
  horn_id = DEFAULT_HORN_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;
  cruisecontrol_id = DEFAULT_CRUISECONTROL_ID;
  if (randomize || seed) {
    if(randomize) seed = time(NULL);

    srand(seed);
    door_id = (rand() % 2046) + 1;
    window_id = (rand() % 2046) + 1;
    signal_id = (rand() % 2046) + 1;
    speed_id = (rand() % 2046) + 1;
    steering_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;
    vvt_id = (rand() % 2046) +1;
    oxygen_sensor_id = (rand() % 2046) + 1;
    air_flow_id = (rand() % 2046) + 1;
    battery_id = (rand() % 2046) + 1;
    throttle_id = (rand() % 2046) + 1;
    horn_id = (rand() % 2046) + 1;
    fuel_id = (rand() % 2046) + 1;
    door_pos = rand() % 9;
    window_pos = rand() % 9;
    signal_pos = rand() % 9;
    speed_pos = rand() % 8;
    steering_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;
    vvt_pos = rand() % 8;
    oxygen_sensor_pos = rand() % 8;
    air_flow_pos = rand() % 8;
    battery_pos = rand() % 8;
    throttle_pos = rand() % 8;
    horn_pos = rand() % 8;
    fuel_pos = rand() % 8;
    printf("Seed: %d\n", seed);
    FILE *fdseed = fopen("/tmp/icsim_seed.txt", "w");
    fprintf(fdseed, "%d\n", seed);
    fclose(fdseed);
  } 

  SDL_Window *window = NULL;
  if(SDL_Init ( SDL_INIT_VIDEO ) < 0 ) {
	printf("SDL Could not initializes\n");
	exit(40);
  }
  window = SDL_CreateWindow("IC Simulator", 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("ic.png"));
  SDL_Surface *needle = IMG_Load(get_data("needle.png"));
  SDL_Surface *steering = IMG_Load(get_data("steering.png"));
  SDL_Surface *rpm_needle = IMG_Load(get_data("rpm_needle.png"));
  SDL_Surface *oil_temp_needle = IMG_Load(get_data("oil_temp_needle.png"));
  SDL_Surface *radiator_temp_needle = IMG_Load(get_data("radiator_temp_needle.png"));
  SDL_Surface *fuel_needle = IMG_Load(get_data("fuel_needle.png"));
  SDL_Surface *battery_needle = IMG_Load(get_data("battery_needle.png"));
  SDL_Surface *sprites = IMG_Load(get_data("spritesheet.png"));
  base_texture = SDL_CreateTextureFromSurface(renderer, image);
  needle_tex = SDL_CreateTextureFromSurface(renderer, needle);
  steering_tex = SDL_CreateTextureFromSurface(renderer, steering);
  rpm_needle_tex = SDL_CreateTextureFromSurface(renderer, rpm_needle);
  oil_temp_needle_tex = SDL_CreateTextureFromSurface(renderer, oil_temp_needle);
  radiator_temp_needle_tex = SDL_CreateTextureFromSurface(renderer, radiator_temp_needle);
  fuel_needle_tex = SDL_CreateTextureFromSurface(renderer, fuel_needle);
  battery_needle_tex = SDL_CreateTextureFromSurface(renderer, battery_needle);
  
  sprite_tex = SDL_CreateTextureFromSurface(renderer, sprites);
  speed_rect.x = 285;
  speed_rect.y = 110;
  speed_rect.h = 20;
  speed_rect.w = 90;

  steering_rect.x = 455;
  steering_rect.y = 220;
  steering_rect.h = 100;
  steering_rect.w = 100;

  rpm_rect.x = 45;
  rpm_rect.y = 130;
  rpm_rect.h = 15;
  rpm_rect.w = 70;

  oil_temp_rect.x = 145;
  oil_temp_rect.y = 140;
  oil_temp_rect.h = 12;
  oil_temp_rect.w = 40;

  radiator_temp_rect.x = 610;
  radiator_temp_rect.y = 100;
  radiator_temp_rect.h = 12;
  radiator_temp_rect.w = 40;

  fuel_rect.x = 615;
  fuel_rect.y = 170;
  fuel_rect.h = 12;
  fuel_rect.w = 40;

  battery_rect.x = 535;
  battery_rect.y = 135;
  battery_rect.h = 12;
  battery_rect.w = 40;


  // Draw the IC
  redraw_ic();
  /* For now we will just operate on one CAN interface */
  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_ic();
		break;
	    }
   	}
      SDL_Delay(3);
    }
      ///////////////////////
      ///Receive CAN FRAME///
      ///////////////////////
      nbytes = recvmsg(can, &msg, 0);
      if (nbytes < 0) {
        perror("read");
        return 1;
      }
      if ((size_t)nbytes == CAN_MTU)
      {
        maxdlen = CAN_MAX_DLEN;
      }
      else if ((size_t)nbytes == CANFD_MTU)
      {
        maxdlen = CANFD_MAX_DLEN;
      }
      else {
        fprintf(stderr, "read: incomplete CAN frame\n");
        return 1;
      }
      for (cmsg = CMSG_FIRSTHDR(&msg);
           cmsg && (cmsg->cmsg_level == SOL_SOCKET);
           cmsg = CMSG_NXTHDR(&msg,cmsg)) {
             if (cmsg->cmsg_type == SO_TIMESTAMP) {
                memcpy(&tv, CMSG_DATA(cmsg), sizeof(tv));
             }
             else if (cmsg->cmsg_type == SO_RXQ_OVFL)
  	            fprintf(stderr, "Dropped packet\n");
             }
      
      //All Controls
      if(log_all_enabled == 1)
      {
        canlogger_frame(&frame, maxdlen, Frame_Log_Level_All, log_all_comments_enabled);
      }
      //User + System Controll
      if(log_system_enabled == 1){
        if(frame.can_id == door_id 
          ||frame.can_id == window_id
          ||frame.can_id == signal_id
          ||frame.can_id == speed_id
          ||frame.can_id == wiper_id
          ||frame.can_id == airbag_id
          ||frame.can_id == hazard_id
          ||frame.can_id == sunroof_id
          ||frame.can_id == sidemirror_id
          ||frame.can_id == trunk_id
          ||frame.can_id == cruisecontrol_id
          ||frame.can_id == handbrake_id
          ||frame.can_id == brakecontrol_id
          ||frame.can_id == abs_id
          ||frame.can_id == light_id
          ||frame.can_id == bluetooth_id
          ||frame.can_id == audiosys_id
          ||frame.can_id == aircondition_id
          ||frame.can_id == satelitenavigation_id
          ||frame.can_id == defroster_id
          ||frame.can_id == rpm_id
          ||frame.can_id == oil_temp_id
          ||frame.can_id == radiator_temp_id
          ||frame.can_id == engine_load_id
          ||frame.can_id == gear_id
          ||frame.can_id == vvt_id
          ||frame.can_id == oxygen_sensor_id
          ||frame.can_id == air_flow_id
          ||frame.can_id == fuel_id
          ||frame.can_id == battery_id
          ||frame.can_id == throttle_id
          ||frame.can_id == horn_id
          ||frame.can_id == steering_id
          )
        {
          canlogger_frame(&frame, maxdlen, Frame_Log_Level_Both_User_System, log_system_comments_enabled);
        }
      }
      //User Control
      if(log_user_enabled == 1){
        if(frame.can_id == door_id 
          ||frame.can_id == window_id
          ||frame.can_id == steering_id
          ||frame.can_id == signal_id
          ||frame.can_id == throttle_id
          ||frame.can_id == horn_id
          ||frame.can_id == wiper_id
          ||frame.can_id == airbag_id
          ||frame.can_id == hazard_id
          ||frame.can_id == sunroof_id
          ||frame.can_id == sidemirror_id
          ||frame.can_id == trunk_id
          ||frame.can_id == cruisecontrol_id
          ||frame.can_id == handbrake_id
          ||frame.can_id == brakecontrol_id
          ||frame.can_id == abs_id
          ||frame.can_id == light_id
          ||frame.can_id == bluetooth_id
          ||frame.can_id == audiosys_id
          ||frame.can_id == aircondition_id
          ||frame.can_id == satelitenavigation_id
          ||frame.can_id == defroster_id
          )
        {
          canlogger_frame(&frame, maxdlen, Frame_Log_Level_UserOnly, log_user_comments_enabled);
        }
      }
      //Segment Log
      if(log_segment_enabled == 1){
        if(frame.can_id == door_id 
          ||frame.can_id == window_id
          ||frame.can_id == steering_id
          ||frame.can_id == signal_id
          ||frame.can_id == speed_id
          ||frame.can_id == rpm_id
          ||frame.can_id == fuel_id
          ||frame.can_id == battery_id
          ||frame.can_id == oil_temp_id
          ||frame.can_id == radiator_temp_id
          ||frame.can_id == engine_load_id
          ||frame.can_id == gear_id
          ||frame.can_id == vvt_id
          ||frame.can_id == oxygen_sensor_id
          ||frame.can_id == air_flow_id
          ||frame.can_id == throttle_id
          ||frame.can_id == horn_id
          ||frame.can_id == wiper_id
          ||frame.can_id == airbag_id
          ||frame.can_id == hazard_id
          ||frame.can_id == sunroof_id
          ||frame.can_id == sidemirror_id
          ||frame.can_id == trunk_id
          ||frame.can_id == cruisecontrol_id
          ||frame.can_id == handbrake_id
          ||frame.can_id == brakecontrol_id
          ||frame.can_id == abs_id
          ||frame.can_id == light_id
          ||frame.can_id == bluetooth_id
          ||frame.can_id == audiosys_id
          ||frame.can_id == aircondition_id
          ||frame.can_id == satelitenavigation_id
          ||frame.can_id == defroster_id
          )
        {
          canlogger_frame(&frame, maxdlen, Frame_Log_Level_SegmentOnly, log_segment_comments_enabled);
        }
      }

      if(frame.can_id == door_id) update_door_status(&frame, maxdlen);
      if(frame.can_id == window_id) update_window_status(&frame, maxdlen);
      if(frame.can_id == signal_id) update_signal_status(&frame, maxdlen);
      if(frame.can_id == speed_id) update_speed_status(&frame, maxdlen);
      if(frame.can_id == steering_id) update_steering_status(&frame, maxdlen);
      if(frame.can_id == wiper_id) update_wiper_status(&frame, maxdlen);
      if(frame.can_id == airbag_id) update_airbag_status(&frame, maxdlen);
      if(frame.can_id == hazard_id) update_hazard_status(&frame, maxdlen);
      if(frame.can_id == sunroof_id) update_sunroof_status(&frame, maxdlen);
      if(frame.can_id == sidemirror_id) update_sidemirror_status(&frame, maxdlen);
      if(frame.can_id == trunk_id) update_trunk_status(&frame, maxdlen);
      if(frame.can_id == cruisecontrol_id) update_cruisecontrol_status(&frame, maxdlen);
      
      if (frame.can_id == handbrake_id) update_handbrake_status(&frame, maxdlen);
      if (frame.can_id == brakecontrol_id) update_brakecontrol_status(&frame, maxdlen);
      if (frame.can_id == abs_id) update_abs_status(&frame, maxdlen);
      if (frame.can_id == light_id) update_light_status(&frame, maxdlen);
      if(frame.can_id == bluetooth_id) update_bluetooth_status(&frame, maxdlen);
      if(frame.can_id == audiosys_id) update_audiosys_status(&frame, maxdlen);
      if(frame.can_id == aircondition_id) update_aircondition_status(&frame, maxdlen);
      if(frame.can_id == satelitenavigation_id) update_satelitenavigation_status(&frame, maxdlen);
      if(frame.can_id == defroster_id) update_defroster_status(&frame, maxdlen);
      if (frame.can_id == rpm_id) update_rpm_status(&frame, maxdlen);
      if (frame.can_id == oil_temp_id) update_oil_temp_status(&frame, maxdlen);
      if (frame.can_id == radiator_temp_id) update_radiator_temp_status(&frame, maxdlen);
      if(frame.can_id == engine_load_id) read_engine_load(&frame, maxdlen);
      if(frame.can_id == gear_id) read_gear(&frame, maxdlen);
      if(frame.can_id == vvt_id) read_vvt(&frame, maxdlen);
      if(frame.can_id == oxygen_sensor_id) read_oxygen_sensor(&frame, maxdlen);
      if(frame.can_id == air_flow_id) read_air_flow(&frame, maxdlen);
      if (frame.can_id == fuel_id) update_fuel_status(&frame, maxdlen);
      if (frame.can_id == battery_id) update_battery_status(&frame, maxdlen);
      if(frame.can_id == throttle_id) update_throttle_status(&frame, maxdlen);
      if(frame.can_id == horn_id) update_horn_status(&frame, maxdlen);

      currentTime = SDL_GetTicks();
      if(currentTime > lastTimeCheck + 1000)
      {
          if(aircondition_status == CAN_AIRCONDITION_Up || aircondition_status == CAN_AIRCONDITION_Down)
          {
            aircondition_status = CAN_AIRCONDITION_ON;
            update_aircondition(); 
          }
          if(audiosys_status == CAN_RADIO_NextStation || audiosys_status == CAN_RADIO_PreviousStation || audiosys_status == CAN_RADIO_VolumeUp || audiosys_status == CAN_RADIO_VolumeDown)
          {
            audiosys_status = CAN_RADIO_ON;
            update_audiosys(); 
          }
          else 
          {
            lastTimeCheck = currentTime;
          }
      }

  }

  SDL_DestroyTexture(base_texture);
  SDL_DestroyTexture(needle_tex);
  SDL_DestroyTexture(steering_tex);
  SDL_DestroyTexture(rpm_needle_tex);
  SDL_DestroyTexture(oil_temp_needle_tex);
  SDL_DestroyTexture(radiator_temp_needle_tex);
  SDL_DestroyTexture(fuel_needle_tex);
  SDL_DestroyTexture(battery_needle_tex);
  SDL_DestroyTexture(sprite_tex);
  SDL_FreeSurface(image);
  SDL_FreeSurface(needle);
  SDL_FreeSurface(rpm_needle);
  SDL_FreeSurface(oil_temp_needle);
  SDL_FreeSurface(radiator_temp_needle);
  SDL_FreeSurface(fuel_needle);
  SDL_FreeSurface(battery_needle);
  SDL_FreeSurface(sprites);
  SDL_DestroyRenderer(renderer);
  SDL_DestroyWindow(window);
  IMG_Quit();
  SDL_Quit();
  return 0;
}



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

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
    printf("default_segment");
    return default_segment;
  
}