Close

CAN-BUS REDUX (1) - Slave side

A project log for Retro-futuristic automobile control panel

Conversion of dashboard from an old, Communist clone of the French Renault 12 (Dacia 1310)

skaarj[skaarj] 05/04/2016 at 12:060 Comments

Slave-side software is almost done, so it's time to make it public.

No GitHub account, nothing. Just copy-paste this into an arduino Sketch, go get the parts, find the missing libraries and it will work.

Some terms are in Romanian but as a "comment" the English translations are also provided.


Hardware ingredients:

- 2 x automotive gauges (stepper motors) with three connectors: +V, +SIG and GND. +V goes to +12V; +SIG goes to ULN-2003 outputs, GND goes to minus.

- 1 x ULN2003: outputs go to stepper motors (gauges), inputs come from an Adafruit 16-Channel 12-bit PWM/Servo Driver - I2C interface (PCA9685). This one is required to protect the PCA9685 - because it works with max. 6V and the automobile gauges require at least 12V.

- 1 x PCA9685 Adafruit 16-Channel 12-bit PWM/Servo Driver - I2C interface;
- 1 x Arduino Due;

- 1 x Liquid Flow sensor Olimex SNS-FLOW401 - with the same functionality as Olimex SNS-FLOW201 (but more sensitive) and GitHub Water Flow Gauge Software;

- 1 x Light Intensity Sensor ( whatever light brick sensor ) capable of analog output proportional with ambient light intensity;

- 1 x TLC5947 Adafruit 24-Channel 12-bit PWM LED Driver - SPI Interface to control the back lights and pointer lights for the gauges;

- a ton of patience.


Software ingredients - pieces of software.

For making everything possible, all Credits and Respect will go as following:

- Arduino Task Scheduler Library Copyright (c) 2015 Anatoli Arkhipenko;

- Adafruit PWM servo driver;

- Adafruit PWM LED driver library.

Analog/Digital connections will be performed according to the defined pins in the code.

The data is outputted via Serial.print() to the serial programming port. No SerialUSB streams are currently detected by FreeBSD 11.0-CURRENT-RPI2 due to some imprefect usb-modem drivers.

This is slave-side software. Master-side software will come soon.


"Code Snippet" displays the software in some bad way. Copy-paste it into an Arduino Sketch and it will appear normal. Also, it seems the Code Snippet somehow removes all the #include libraries. Syntax highlighting causes problems - it does not allow me to upload the log unless the "no syntax" is chosen.


How does it work?

- Every 5 seconds the task scheduler execute the wits() function, which sends out all "hotdogs" through the serial line. There are no visible delays, meaning the process is not "visible" paused;

- Ambient light is measured and gauges back light + pointer light intensities are modified according to the environment;

- All this big amount of data is defined as a structure so everything can later be pushed to some "black box recorder" for later inspections with little effort;

- One of the gauges outputs the light intensity, the other outputs the fluid flow while blowing through the flow sensor.


#include <TaskScheduler.h>
/* DEFINES:  GAUGES */
#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

/*  DEFINES: dials lights */
#include "Adafruit_TLC5947.h"

#define NUM_TLC5974 1
#define data   4
#define clock   5
#define latch   6
#define oe_lights  -1  // set to -1 to not use the enable pin (its optional)
Adafruit_TLC5947 tlc = Adafruit_TLC5947(NUM_TLC5974, clock, data, latch);

/* PWM CHANNELS
THESE ARE NOT ARDUINO DIGITAL CHANNELS!!!
*/
const byte canal_limba_gaz = 0x00;   // "canal" = "channel"; "limba" = "tongue"/"pointer needle"
const byte canal_cadran_gaz = 1;    // "cadran = "dial";   "gaz" = gas;
const byte canal_limba_apa = 2;     // "apa" = "water"/"coolant liquid"
const byte canal_cadran_apa = 3;
const byte canal_limba_bat = 4;     // "bat" = battery
const byte canal_cadran_bat = 5;
const byte canal_limba_ulei = 6;   // " ulei " = "oil"
const byte canal_cadran_ulei = 7;
const byte canal_limba_kmh = 8;
const byte canal_limba_rpm = 9;
const byte canal_limba_rad = 10;
const byte canal_limba_electro = 11;
  
const byte canal_cadran_kmh_5 = 23;
const byte canal_cadran_kmh_4 = 22;
const byte canal_cadran_kmh_3 = 21;
const byte canal_cadran_kmh_2 = 20;
const byte canal_cadran_kmh_1 = 19;
const byte canal_cadran_rpm_5 = 18;
const byte canal_cadran_rpm_4 = 17;
const byte canal_cadran_rpm_3 = 16;
const byte canal_cadran_rpm_2 = 15;
const byte canal_cadran_rpm_1 = 14;
const byte canal_iluminare_superioara = 13;   // "channel for upper dash lights
  
  
/* end DEFINES: lights */
//#########################################################################################
  
/*  DEFINES:  GAUGES  */
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);
int oe_gauges = -1;
  
/* end DEFINES: GAUGES */
//#########################################################################################

/* DEFNIES: CANBUS  WITS STYLE */

struct WITS_CONFIG {
  /* index / categories */
  const int8_t num_cats = 0x05;
  const int8_t cat_pwr_ctrl = 0x00;   // index0 - computer power controls
  const int8_t cat_measurements = 0x01; // index1 - measurements
  const int8_t cat_manual_input_state = 0x02; // index2 - manual input states
  const int8_t cat_autowarning = 0x03;  // index3 -- automatic input states
  const int8_t cat_ambient_params = 0x04; // index4 - ambient parameters
  const int8_t cat_TBD = 0x05;  // index5 - to be determined

  /* pos */
  /* index 0   computer power controls */
  const int8_t num_idx0 = 0x02;
  const int8_t pwr_relay0 = 0x00;  
  const int8_t pwr_relay1 = 0x01;  
  int index0[2];
  bool index0_modif[2] = { false, false };

  /* index 1   measurements*/
  const int num_idx1 = 0x0A;
  const int8_t gas_level = 0x00;
  const int8_t core_temp = 0x01;
  const int8_t bat_voltage = 0x02;
  const int8_t engine_core_press = 0x03;
  const int8_t speed_kmh = 0x04;
  const int8_t rpm = 0x05;
  const int8_t rads = 0x06;
  const int8_t battchg = 0x07;
  const int8_t gas_lpm = 0x08;
  const int8_t gas_inst = 0x09;
  int index1[0x0A];
  bool index1_modif[0x0A] = {false, false, false, false, false, false, false, false, false, false };
  // index modif -  is any of these parameters under manual calibration?

  /* index 2    manual input states / user input states / user interaction states */
  const int num_idx2 = 0x17;
  const int8_t poz_lights = 0x00;
  const int8_t short_lights = 0x01;
  const int8_t long_lights = 0x02;
  const int8_t rear_fog_lights = 0x03;
  const int8_t front_fog_lights = 0x04; // projectors
  const int8_t dir_signal_left = 0x05;
  const int8_t dir_signal_right = 0x05;
  const int8_t foot_brake = 0x06;
  const int8_t manual_brake = 0x07;
  const int8_t belt_driver = 0x08;
  const int8_t seat_driver = 0x09;
  const int8_t belt_left = 0x0A;   
  const int8_t seat_left = 0x0B;   
  const int8_t belt_3 = 0x0C;
  const int8_t seat_3 = 0x0D;
  const int8_t belt_4 = 0x0E;
  const int8_t seat_4 = 0x0F;
  const int belt_5 = 0x10;  
  const int seat_5 = 0x11;
  const int front_left_door = 0x12;
  const int front_right_door = 0x13;
  const int rear_left_door = 0x14;
  const int rear_right_door = 0x15;
  const int trunk = 0x16; 
  const int marche_a_rierre = 0x17;
  bool index2[0x17];
  bool index2_modif[0x17] = { false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false };
   
/* index 3   automatic input states */
  const int num_idx3 = 0x04;
  const int8_t low_fuel_alarm = 0x00;
  const int8_t overheat_alarm = 0x01;
  const int8_t low_press_alarm = 0x02;
  const int8_t vent_engine_alarm = 0x03;
  const int8_t neural_net_alarm = 0x04;
  bool index3[0x04];
  byte index3_modif[5] = { false, false, false, false };   
  
  
  /* index 4   ambient parameters */   
  const int num_idx4 = 0x17;
  const int8_t ambient_light = 0x00;
  const int8_t power_state = 0x01;
  const int8_t bk_gas_gauge = 0x02;
  const int8_t pointer_gas_gauge = 0x03;
  const int8_t bk_press_gauge = 0x04;
  const int8_t pointer_press_gauge = 0x05;
  const int8_t bk_batt_gauge = 0x06;
  const int8_t pointer_batt_gauge = 0x07;
  const int8_t bk_coretemp = 0x08;
  const int8_t pointer_coretemp = 0x09;
  const int8_t bk_speed_0 = 0x0A;
  const int8_t bk_speed_1 = 0x0B;  
  const int8_t bk_speed_2 = 0x0C;   
  const int8_t bk_speed_3 = 0x0D; 
  const int8_t bk_speed_4 = 0x0E;  
  const int8_t pointer_speed_gauge = 0x0F;
  const int bk_rpm_0 = 0x10;
  const int bk_rpm_1 = 0x11;
  const int bk_rpm_2 = 0x12;
  const int bk_rpm_3 = 0x13;
  const int bk_rpm_4 = 0x14;
  const int pointer_rpm_gauge = 0x15;
  const int pointer_rad_gauge = 0x16;
  const int pointer_chg_gauge = 0x17;
  int index4[0x17];
  byte index4_modif[0x17] = { false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false };
  
} sysctl;
// END DEFINES: CANBUS
//#########################################################################################

  
/* DEFINES:  DIGITAL OUTPUT CHANNELS
 WITS CAT 0
*/
#define pin_relay0 0
#define pin_relay1 0
//#########################################################################################
  
/*
DEFINES:  ANALOG INPUT CHANNELS
WITS CAT 1
analog inputs?  LAN-AD16? USB-AD12?
*/
#define pin_gas_sensor A0
//#########################################################################################
  
/* DEFINES: DIGITAL INPUT CHANNELS 
WARNING: OPTOCOUPLERS!!!
*/
  
// WITS CAT 2
#define pin_poz_lights 22   
#define pin_short_lights 23 
#define pin_long_lights 24
#define pin_rear_fog_lights 25
#define pin_front_fog_lights 26
#define pin_dir_signal_left 27
#define pin_dir_signal_right 28
#define pin_foot_brake 29
#define pin_manual_brake 30
#define pin_belt_driver 31
#define pin_seat_driver 32
#define pin_belt_left 33
#define pin_seat_left 34
#define pin_belt_3 35
#define pin_seat_3 36
#define pin_belt_4 37
#define pin_seat_4 38
#define pin_belt_5 39
#define pin_seat_5 40
#define pin_front_left_door 41
#define pin_front_right_door 42
#define pin_rear_left_door 43  
#define pin_rear_right_door 44
#define pin_trunk 45
#define pin_marche_a_rierre 46
//#########################################################################################

// WITS CAT 3
#define pin_low_fuel_alarm 47
#define pin_coreoverheat_alarm 48
#define pin_low_corepress_alarm 49
#define pin_vent_engine_alarm 50
#define pin_neural_net_alarm 51
// END DEFINES: DIGITAL INPUT CHANNELS
//#########################################################################################

// smooth()

const int NumReadings = 4096;
int idx = 0;
int lightreadings[NumReadings];
long int lighttotal = 0;  
int lightavg = 0;
int light = 0;
int light_prev = 0;  
// prototipe for wits function
void wits();

// define wits task to run forever at 5 seconds interval
Task t1(5000, TASK_FOREVER, &wits);

// task scheduler
Scheduler runner;

void setup() {
              Serial.begin(115200);
              //analogReadResolution(12);
              gauges_setup();
              Wire.begin();
              pwm.begin();   
              pwm.setPWMFreq(150);
              yield();
              setup_gas();
              setup_bklights();
              setup_input_pins();
              setup_output_pins();
              poweron();
              runner.init();
              runner.addTask(t1);
              t1.enable();
}

void loop() {
              read_gas(true);  
              light_prev = sysctl.index4[sysctl.ambient_light];
              read_light_sensor();
              if (sysctl.index4[sysctl.ambient_light] != light_prev)
                                                                  bklights();
              process_cat2(); 
              process_cat3();
              setgauge(1, sysctl.index1[sysctl.gas_inst]);
              //setgauge(0, sysctl.index4[sysctl.ambient_light]);
              setgauge(0, light);  
              // finaly send everything to serial line
              runner.execute();
}

//#########################################################################################
              
//WITS CAT/IDX 0  powerstates
void setup_output_pins() {   
                           pinMode(pin_relay0, OUTPUT);
                           pinMode(pin_relay1, OUTPUT);
}
//#########################################################################################
              
void poweron() {
                           digitalWrite(pin_relay0, HIGH);
                           digitalWrite(pin_relay1, HIGH);
}
//#########################################################################################
              
/* WITS CAT/IDX1
GAS SENSOR
WITS CAT/IDX 0001
POS:
0000 - level
0008 - litri/min
0009 - instant consum ml/s
*/

byte GasSensorPin       = 2;
float calibrationFactor = 4.5;
volatile byte pulseCount;
float flowRate;
unsigned int flowMilliLitres;
unsigned long totalMilliLitresA;   
unsigned long totalMilliLitresB;
unsigned long oldTime;
 
void setup_gas() {
                           pinMode(GasSensorPin, INPUT);
                           digitalWrite(GasSensorPin, HIGH);
                           pulseCount        = 0;
                           flowRate          = 0.0;
                           flowMilliLitres   = 0;
                           totalMilliLitresA = 0;
                           totalMilliLitresB = 0;
                           oldTime           = 0;
                           attachInterrupt(digitalPinToInterrupt(GasSensorPin), GasPulseCounter, FALLING);
}
void GasPulseCounter() {
                           pulseCount++;
}

void read_gas(bool modif) {
                           if ((millis() - oldTime) > 1000) {   // Only process counters once per second
                             detachInterrupt(digitalPinToInterrupt(GasSensorPin));
                             flowRate = ((1000.0 / (millis() - oldTime)) * pulseCount) / calibrationFactor;
                             oldTime = millis();
                             flowMilliLitres = (flowRate / 60) * 1000;
                             totalMilliLitresA += flowMilliLitres;
                             totalMilliLitresB += flowMilliLitres;
                             unsigned int frac;
                             /*Serial.print(int(flowRate));  // Print the integer part of the variable
                             Serial.print(".");             // Print the decimal point
                             */
                             frac = (flowRate - int(flowRate)) * 10;

                             sysctl.index1[sysctl.gas_lpm] = (int)(flowRate * 10);
                             sysctl.index1_modif[sysctl.gas_lpm] = modif;
                             sysctl.index1[sysctl.gas_inst] = flowMilliLitres;
                             sysctl.index1_modif[sysctl.gas_inst] = modif;

                             /*Serial.print(frac, DEC) ;      // Print the fractional part of the variable
                             Serial.print("L/min ");
                             Serial.print(" ");             // Output separator
                             Serial.print(flowMilliLitres);
                             Serial.print("mL/s");
                             Serial.print("  Total Counter A:  ");
                             Serial.print(totalMilliLitresA);
                             Serial.print("mL ");             // Output separator
                             Serial.print(" Total Counter B: ");
                             Serial.print(totalMilliLitresB);
                             Serial.println(" mL.\n");
                           
                             if (modif == true)
                                           Serial.print("0>");
                                           else Serial.print("1>");
                             Serial.print("0001>");
                             Serial.print("0009>");
                             if ((flowMilliLitres>= 0x00) && (flowMilliLitres <= 0x0F)) Serial.print("000");
                             if ((flowMilliLitres > 0x0F) && (flowMilliLitres <= 0xFF)) Serial.print("00");
                             if (flowMilliLitres > 0xFF) Serial.print("0");
                             Serial.print(flowMilliLitres, HEX);  
                             Serial.println("!!");
                             */

                            // Reset the pulse counter so we can start incrementing again
                             pulseCount = 0;
                             
                             // Enable the interrupt again now that we've finished sending output
                             attachInterrupt(digitalPinToInterrupt(GasSensorPin), GasPulseCounter, FALLING);
  }
}
                             
/* END WITS CAT1 gaz */
//#################################################################################
                             
// WITS CAT/idx 0002
void process_cat2() {
                           sysctl.index2[sysctl.poz_lights] = digitalRead(pin_poz_lights);
                           sysctl.index2[sysctl.short_lights] = digitalRead(pin_short_lights);
                           sysctl.index2[sysctl.long_lights] = digitalRead(pin_long_lights);
                           sysctl.index2[sysctl.rear_fog_lights] = digitalRead(pin_rear_fog_lights);
                           sysctl.index2[sysctl.front_fog_lights] = digitalRead(pin_front_fog_lights);
                           sysctl.index2[sysctl.dir_signal_left] = digitalRead(pin_dir_signal_left);
                           sysctl.index2[sysctl.dir_signal_right] = digitalRead(pin_dir_signal_right);
                           sysctl.index2[sysctl.foot_brake] = digitalRead(pin_foot_brake);
                           sysctl.index2[sysctl.manual_brake] = digitalRead(pin_manual_brake);
                           sysctl.index2[sysctl.belt_driver] = digitalRead(pin_belt_driver);
                           sysctl.index2[sysctl.seat_driver] = digitalRead(pin_seat_driver);
                           sysctl.index2[sysctl.belt_left] = digitalRead(pin_belt_left);
                           sysctl.index2[sysctl.seat_left] = digitalRead(pin_seat_left);
                           sysctl.index2[sysctl.belt_3] = digitalRead(pin_belt_3);
                           sysctl.index2[sysctl.seat_3] = digitalRead(pin_seat_3);
                           sysctl.index2[sysctl.belt_4] = digitalRead(pin_belt_4);
                           sysctl.index2[sysctl.seat_4] = digitalRead(pin_seat_4);
                           sysctl.index2[sysctl.belt_5] = digitalRead(pin_belt_5);
                           sysctl.index2[sysctl.seat_5] = digitalRead(pin_seat_5);
                          sysctl.index2[sysctl.front_left_door] = digitalRead(pin_front_left_door);
                           sysctl.index2[sysctl.front_right_door] = digitalRead(pin_front_right_door);
                           sysctl.index2[sysctl.rear_left_door] = digitalRead(pin_rear_left_door);
                           sysctl.index2[sysctl.rear_right_door] = digitalRead(pin_rear_right_door);
                           sysctl.index2[sysctl.trunk] = digitalRead(pin_trunk);
                           sysctl.index2[sysctl.marche_a_rierre] = digitalRead(pin_marche_a_rierre);
}
 // WITS CAT/IDX 0003
void process_cat3() {  
                           sysctl.index3[sysctl.low_fuel_alarm] = digitalRead(pin_low_fuel_alarm);
                           sysctl.index3[sysctl.overheat_alarm] = digitalRead(pin_coreoverheat_alarm);
                           sysctl.index3[sysctl.low_press_alarm] = digitalRead(pin_low_corepress_alarm);
                           sysctl.index3[sysctl.vent_engine_alarm] = digitalRead(pin_vent_engine_alarm);
                           sysctl.index3[sysctl.neural_net_alarm] = digitalRead(pin_neural_net_alarm);
}
                           
                           
/*   backlights / ambient lights
WITS CAT/IDX 0004
                           
ambient light
WITS CAT/INDEX 0004 POS  0000 - ambient light sensor
*/
                           
void read_light_sensor() {
                        lighttotal = lighttotal - lightreadings[idx];
                        light = analogRead(0);
                        lightreadings[idx] = light;
                        lighttotal = lighttotal + lightreadings[idx];
                        idx = idx + 1;
                        if (idx >=  NumReadings) idx = 0;
                         lightavg = lighttotal / NumReadings;
                        //sysctl.index4[sysctl.ambient_light] = (uint16_t) lightavg;
                        //sysctl.index4[sysctl.ambient_light] = analogRead(0);
                         sysctl.index4[sysctl.ambient_light] = lightavg;
}
                           
void read_light() {
  //sysctl.index4[sysctl.ambient_light] = analogRead(0);
 
}

// dial lights (backlight + "tongue"/"needle" light
                           
void setup_bklights() {
                           tlc.begin();
                           if (oe_lights >= 0) {
                                                 pinMode(oe_lights, OUTPUT);
                                                 digitalWrite(oe_lights, LOW);
                           }
}

// WITS CAT/IDX 0003
void process_cat3() {
                           sysctl.index3[sysctl.low_fuel_alarm] = digitalRead(pin_low_fuel_alarm);
                           sysctl.index3[sysctl.overheat_alarm] = digitalRead(pin_coreoverheat_alarm);
                           sysctl.index3[sysctl.low_press_alarm] = digitalRead(pin_low_corepress_alarm);
                           sysctl.index3[sysctl.vent_engine_alarm] = digitalRead(pin_vent_engine_alarm);
                           sysctl.index3[sysctl.neural_net_alarm] = digitalRead(pin_neural_net_alarm);
}
                            
void bklights() {          
                  uint16_t pwm = 100+sysctl.index4[sysctl.ambient_light] * 10;
                  sysctl.index4[sysctl.bk_gas_gauge] = pwm;
                  sysctl.index4[sysctl.pointer_gas_gauge] = pwm;
                  sysctl.index4[sysctl.bk_press_gauge] = pwm;
                  sysctl.index4[sysctl.pointer_press_gauge] = pwm;
                  sysctl.index4[sysctl.bk_batt_gauge] = pwm;
                  sysctl.index4[sysctl.pointer_batt_gauge] = pwm;
                  sysctl.index4[sysctl.bk_coretemp] = pwm;
                  sysctl.index4[sysctl.pointer_coretemp] = pwm;
                  sysctl.index4[sysctl.bk_speed_0] = pwm;
                  sysctl.index4[sysctl.bk_speed_1] = pwm;
                  sysctl.index4[sysctl.bk_speed_2] = pwm;
                  sysctl.index4[sysctl.bk_speed_3] = pwm;
                  sysctl.index4[sysctl.bk_speed_4] = pwm;
                  sysctl.index4[sysctl.pointer_speed_gauge] = pwm;
                  sysctl.index4[sysctl.bk_rpm_0] = pwm;
                  sysctl.index4[sysctl.bk_rpm_1] = pwm;
                  sysctl.index4[sysctl.bk_rpm_2] = pwm;
                  sysctl.index4[sysctl.bk_rpm_3] = pwm; 
                  sysctl.index4[sysctl.bk_rpm_4] = pwm;
                  sysctl.index4[sysctl.pointer_rpm_gauge] = pwm;
                  sysctl.index4[sysctl.pointer_rad_gauge] = pwm;
                  sysctl.index4[sysctl.pointer_chg_gauge] = pwm;
                           
                  tlc.setPWM(canal_limba_gaz, sysctl.index4[sysctl.pointer_gas_gauge]);
                  tlc.write();
                  tlc.setPWM(canal_cadran_gaz, sysctl.index4[sysctl.bk_gas_gauge]);
                  tlc.write();
                  tlc.setPWM(canal_limba_apa, sysctl.index4[sysctl.pointer_coretemp]);
                  tlc.write();
                  tlc.setPWM(canal_cadran_apa, sysctl.index4[sysctl.bk_coretemp]);
                  tlc.write();
                  tlc.setPWM(canal_limba_bat, sysctl.index4[sysctl.pointer_batt_gauge]);
                  tlc.write();
                  tlc.setPWM(canal_cadran_bat, sysctl.index4[sysctl.bk_batt_gauge]);
                  tlc.write();
                  tlc.setPWM(canal_limba_ulei, sysctl.index4[sysctl.pointer_press_gauge]);
                  tlc.write();
                  tlc.setPWM(canal_cadran_ulei, sysctl.index4[sysctl.bk_press_gauge]);
                  tlc.write();
                  tlc.setPWM(canal_limba_kmh, sysctl.index4[sysctl.pointer_speed_gauge]);
                  tlc.write();
                  tlc.setPWM(canal_limba_rpm, sysctl.index4[sysctl.pointer_rpm_gauge]);
                  tlc.write();

                  tlc.setPWM(canal_limba_rad, sysctl.index4[sysctl.pointer_rad_gauge]);
                  tlc.write();
                  tlc.setPWM(canal_limba_electro, sysctl.index4[sysctl.pointer_chg_gauge]);
                  tlc.write();
                  tlc.setPWM(canal_cadran_kmh_5, sysctl.index4[sysctl.bk_speed_4]);
                  tlc.write();
                  tlc.setPWM(canal_cadran_kmh_4, sysctl.index4[sysctl.bk_speed_3]);
                  tlc.write();
                  tlc.setPWM(canal_cadran_kmh_3, sysctl.index4[sysctl.bk_speed_2]);
                  tlc.write();
                  tlc.setPWM(canal_cadran_kmh_2, sysctl.index4[sysctl.bk_speed_1]);
                  tlc.write();
                  tlc.setPWM(canal_cadran_kmh_1, sysctl.index4[sysctl.bk_speed_0]);
                  tlc.write();
                  tlc.setPWM(canal_cadran_rpm_5, sysctl.index4[sysctl.bk_rpm_4]);
                  tlc.write();
                  tlc.setPWM(canal_cadran_rpm_4, sysctl.index4[sysctl.bk_rpm_3]);
                  tlc.write();
                  tlc.setPWM(canal_cadran_rpm_3, sysctl.index4[sysctl.bk_rpm_2]);
                  tlc.write();
                  tlc.setPWM(canal_cadran_rpm_2, sysctl.index4[sysctl.bk_rpm_1]);
                  tlc.write();
                  tlc.setPWM(canal_cadran_rpm_1, sysctl.index4[sysctl.bk_rpm_0]);
                  
                  /*    for (i=0; i<24; i++) {
                        tlc.setPWM(i,pwm*10);
                        tlc.write();
                                                             }
                  */
}
/* end - ambient lights */
//###################################################################################################
 
/* setup input pins */                  
void setup_input_pins() {
                  
                           // all these are inputs
                  
                           // WITS CAT3 AUTOMATIC INPUT STATES
                           pinMode (pin_low_fuel_alarm, INPUT);
                           pinMode (pin_coreoverheat_alarm, INPUT);
                           pinMode (pin_low_corepress_alarm, INPUT);
                           pinMode (pin_vent_engine_alarm, INPUT);
                           pinMode (pin_neural_net_alarm, INPUT);
                  
                           // internal pull-ups enabled
                           digitalWrite (pin_low_fuel_alarm, HIGH);
                           digitalWrite (pin_coreoverheat_alarm, HIGH);
                           digitalWrite (pin_low_corepress_alarm, HIGH);
                           digitalWrite (pin_vent_engine_alarm, HIGH);
                           digitalWrite (pin_neural_net_alarm, HIGH);
                  
                  
                           // WITS   CAT4   ambient parameters
                           pinMode (pin_poz_lights, INPUT);
                           pinMode (pin_short_lights, INPUT);
                           pinMode (pin_long_lights, INPUT);
                           pinMode (pin_rear_fog_lights, INPUT);
                           pinMode (pin_front_fog_lights, INPUT);
                           pinMode (pin_dir_signal_left, INPUT);
                           pinMode (pin_dir_signal_right, INPUT);
                           pinMode (pin_foot_brake, INPUT);
                           pinMode (pin_manual_brake, INPUT);
                           pinMode (pin_belt_driver, INPUT);
                           pinMode (pin_seat_driver, INPUT);
                           pinMode (pin_belt_left, INPUT);
                           pinMode (pin_seat_left, INPUT);
                           pinMode (pin_belt_3, INPUT);
                           pinMode (pin_seat_3, INPUT);
                           pinMode (pin_belt_4, INPUT);
                           pinMode (pin_seat_4, INPUT);
                           pinMode (pin_belt_5, INPUT);
                           pinMode (pin_seat_5, INPUT);
                           pinMode (pin_front_left_door, INPUT);   
                           pinMode (pin_front_right_door, INPUT);   
                           pinMode (pin_rear_left_door, INPUT);   
                           pinMode (pin_rear_right_door, INPUT); 
                           pinMode (pin_trunk, INPUT);
                           pinMode (pin_marche_a_rierre, INPUT);
                           
                           // with internal pull-up resistors enabled  
                           digitalWrite (pin_poz_lights, HIGH);
                           digitalWrite (pin_short_lights, HIGH);
                           digitalWrite (pin_long_lights, HIGH);
                           digitalWrite (pin_rear_fog_lights, HIGH);
                           digitalWrite (pin_front_fog_lights, HIGH);
                           digitalWrite (pin_dir_signal_left, HIGH);
                           digitalWrite (pin_dir_signal_right, HIGH);
                           digitalWrite (pin_foot_brake, HIGH);
                           digitalWrite (pin_manual_brake, HIGH);
                           digitalWrite (pin_belt_driver, HIGH);
                           digitalWrite (pin_seat_driver, HIGH); 
                           digitalWrite (pin_belt_left, HIGH);  
                           digitalWrite (pin_seat_left, HIGH);   
                           digitalWrite (pin_belt_3, HIGH);
                           digitalWrite (pin_seat_3, HIGH);  
                           digitalWrite (pin_belt_4, HIGH); 
                           digitalWrite (pin_seat_4, HIGH); 
                           digitalWrite (pin_belt_5, HIGH);
                           digitalWrite (pin_seat_5, HIGH);
                           digitalWrite (pin_front_left_door, HIGH);
                           digitalWrite (pin_front_right_door, HIGH);
                           digitalWrite (pin_rear_left_door, HIGH);
                           digitalWrite (pin_rear_right_door, HIGH);
                           digitalWrite (pin_trunk, HIGH);
                           digitalWrite (pin_marche_a_rierre, HIGH);
}
//###################################################################################################
                           
// gauges
   
// scale an array to another array
// useful to convert a 0....4096 measurement into an analog gauge dial split into 0...100%   
float scalare(float max_dial, float min_dial, float max_measured, float min_measured, float instant_measured) {
                           float percentage = 0.0;
                           percentage = ((max_dial - min_dial) / (max_measured - min_measured)) * (instant_measured - min_measured) + min_dial;
                           return percentage;
}
                           
void gauges_setup() {
                           if (oe_gauges >= 0) {
                                                      pinMode(oe_gauges, OUTPUT);
                                                      digitalWrite(oe_gauges, LOW);
                           }
                          #ifdef TWBR
                           // save I2C bitrate
                           uint8_t twbrbackup = TWBR;
                           // must be changed after calling Wire.begin() (inside pwm.begin())
                           TWBR = 12; // upgrade to 400KHz!      
                         #endif
} 
void setgauge(uint8_t gauge, uint16_t param) {
                           float scala = scalare(3600, 100, 850, 0, param);
                           pwm.setPWM(gauge, 0, (int) scala);
}
                           
//###################################################################################################
                           
void wits() {
                           byte cats = 0x00;
                           byte idx = 0x00;
                           int i = 0;
                           Serial.println("&&");
                           Serial.println("WITS");
                           for (cats = 0; cats < sysctl.num_cats; cats++) {
                                                                               // TxD idx0
                                                                               if (cats == 0)
                                                                                 for (idx = 0; idx < sysctl.num_idx0; idx++) {
                                                                                                            // transmisie:  index0_modif[] > cats > idx > valoare
 
                                                                                                            Serial.print(sysctl.index0_modif[idx], HEX);

                                                                                                            Serial.print(">");
                                                      
                                                                                                            if (( cats >= 0x00) && (cats <= 0x0F)) Serial.print("000");
                                                                                                            if ((cats > 0x0F) && (cats <= 0xFF)) Serial.print("00");
                                                                                                            if (cats > 0xFF) Serial.print("0");
                                                                                                            Serial.print(cats, HEX);
                           
                                                                                                            Serial.print(">");
                           
                                                                                                            if (( idx >= 0x00) && (idx <= 0x0F)) Serial.print("000");
                                                                                                            if ((idx > 0x0F) && (idx <= 0xFF)) Serial.print("00");
                                                                                                            if (idx > 0xFF) Serial.print("0");
                                                                                                            Serial.print(idx, HEX);
                          
                                                                                                            Serial.print(">");
 
                                                                                                            if (( sysctl.index0[idx] >= 0x00) && (sysctl.index0[idx] <= 0x0F)) Serial.print("000");
                                                                                                            if ((sysctl.index0[idx] > 0x0F) && (sysctl.index0[idx] <= 0xFF)) Serial.print("00");
                                                                                                            if (sysctl.index0[idx] > 0xFF) Serial.print("0");

                                                                                                            Serial.print(sysctl.index0[idx], HEX);
                                                                                                            Serial.println("!!");
                                                                                 } // TxD idx0
                           
                                                                               if (cats == 1)
                                                                                   for (idx = 0; idx < sysctl.num_idx1; idx++) {
                                                                                                            // transmisie:  index1_modif[] > cats > idx > valoare
                                                                                                            Serial.print(sysctl.index1_modif[idx], HEX);
                                                                                 
                                                                                                            Serial.print(">");
 
                                                                                                            if (( cats >= 0x00) && (cats <= 0x0F)) Serial.print("000");
                                                                                                            if ((cats > 0x0F) && (cats <= 0xFF)) Serial.print("00");
                                                                                                            if (cats > 0xFF) Serial.print("0");
                                                                                                            Serial.print(cats, HEX);
                                                                                                            
                                                                                                            Serial.print(">");
                                                                                                            
                                                                                                            if (( idx >= 0x00) && (idx <= 0x0F)) Serial.print("000");
                                                                                                            if ((idx > 0x0F) && (idx <= 0xFF)) Serial.print("00");
                                                                                                            if (idx > 0xFF) Serial.print("0");
                                                                                                            Serial.print(idx, HEX);
                                                                                                            
                                                                                                            Serial.print(">");
                                                                                                            if (( sysctl.index1[idx] >= 0x00) && (sysctl.index1[idx] <= 0x0F)) Serial.print("000");
                                                                                                            if ((sysctl.index1[idx] > 0x0F) && (sysctl.index1[idx] <= 0xFF)) Serial.print("00");
                                                                                                            if (sysctl.index1[idx] > 0xFF) Serial.print("0");
                                                                                                            Serial.print(sysctl.index1[idx], HEX);
 
                                                                                                            Serial.println("!!");
                                                                                 } // TxD idx1
                                                                               if (cats == 2)
                                                                                 for (idx = 0; idx < sysctl.num_idx2; idx++) {
                                                                                                           // transmisie:  index2_modif[] > cats > idx > valoare
                                                                                                            Serial.print(sysctl.index2_modif[idx], HEX);
                                                                                 
                                                                                                            Serial.print(">");
                                                                                                            if (( cats >= 0x00) && (cats <= 0x0F)) Serial.print("000");
                                                                                                            if ((cats > 0x0F) && (cats <= 0xFF)) Serial.print("00");
                                                                                                            if (cats > 0xFF) Serial.print("0");
                                                                                                            Serial.print(cats, HEX);
                                                                                 
                                                                                                            Serial.print(">");
 
                                                                                                            if (( idx >= 0x00) && (idx <= 0x0F)) Serial.print("000");  
                                                                                                            if ((idx > 0x0F) && (idx <= 0xFF)) Serial.print("00");  
                                                                                                            if (idx > 0xFF) Serial.print("0"); 
                                                                                                            Serial.print(idx, HEX); 
                                                                                                            
                                                                                                            Serial.print(">");
                                                                                                            
                                                                                                            if (( sysctl.index2[idx] >= 0x00) && (sysctl.index2[idx] <= 0x0F)) Serial.print("000");
                                                                                                            if ((sysctl.index2[idx] > 0x0F) && (sysctl.index2[idx] <= 0xFF)) Serial.print("00");
                                                                                                            if (sysctl.index2[idx] > 0xFF) Serial.print("0");
                                                                                                            Serial.print(sysctl.index2[idx], HEX);
                                                                                                            
                                                                                                            Serial.println("!!");
                                                                                 } // TxD idx2
                                                                                 if (cats == 3)
                                                                                         for (idx = 0; idx < sysctl.num_idx3; idx++) {
                                                                                                            // transmisie:  index3_modif[] > cats > idx > valoare
                                                                                                            Serial.print(sysctl.index3_modif[idx], HEX);
                                                                                                            
                                                                                                            Serial.print(">");
                                                                               
                                                                                                            if (( cats >= 0x00) && (cats <= 0x0F)) Serial.print("000");
                                                                                                            if ((cats > 0x0F) && (cats <= 0xFF)) Serial.print("00");
                                                                                                            if (cats > 0xFF) Serial.print("0");
                                                                                                            Serial.print(cats, HEX);
                                                                                                            
                                                                                                            Serial.print(">");
                                                                                                            
                                                                                                            if (( idx >= 0x00) && (idx <= 0x0F)) Serial.print("000");
                                                                                                            if ((idx > 0x0F) && (idx <= 0xFF)) Serial.print("00");
                                                                                                            if (idx > 0xFF) Serial.print("0");
                                                                                                            Serial.print(idx, HEX);
 
                                                                                                            Serial.print(">");
                                                                                                            
                                                                                                            if (( sysctl.index3[idx] >= 0x00) && (sysctl.index3[idx] <= 0x0F)) Serial.print("000");
                                                                                                            if ((sysctl.index3[idx] > 0x0F) && (sysctl.index3[idx] <= 0xFF)) Serial.print("00");
                                                                                                            if (sysctl.index3[idx] > 0xFF) Serial.print("0");
                                                                                                            Serial.print(sysctl.index3[idx], HEX);
                                                                                                            
                                                                                                            Serial.println("!!");
                                                                              } // TxD idx3
                                                                              if (cats == 4)
                                                                                           for (idx = 0; idx < sysctl.num_idx4; idx++) {
                                                                                                          // transmisie:  index4_modif[] > cats > idx > valoare
                                                                                                            Serial.print(!(!(sysctl.index4_modif[idx])));  // double NOT  because the fucker transmits shit instead of bool
                                                                                 
                                                                                                            Serial.print(">");
                                                                                         
                                                                                                            if (( cats >= 0x00) && (cats <= 0x0F)) Serial.print("000");
                                                                                                            if ((cats > 0x0F) && (cats <= 0xFF)) Serial.print("00");
                                                                                                            if (cats > 0xFF) Serial.print("0");
                                                                                                            Serial.print(cats, HEX);
                                                                               
                                                                                                            Serial.print(">");
                                                                                                            
                                                                                                            if (( idx >= 0x00) && (idx <= 0x0F)) Serial.print("000");
                                                                                                            if ((idx > 0x0F) && (idx <= 0xFF)) Serial.print("00");
                                                                                                            if (idx > 0xFF) Serial.print("0");
                                                                                                            Serial.print(idx, HEX);
                                                                                                            
                                                                                                            Serial.print(">");
                                                                                                            
                                                                                                            if (( sysctl.index4[idx] >= 0x00) && (sysctl.index4[idx] <= 0x0F)) Serial.print("000");
                                                                                                            if ((sysctl.index4[idx] > 0x0F) && (sysctl.index4[idx] <= 0xFF)) Serial.print("00");
                                                                                                            if (sysctl.index4[idx] > 0xFF) Serial.print("0");
                                                                                                            Serial.print(sysctl.index4[idx], HEX);
                                                                                                            
                                                                                                            Serial.println("!!");
                                                                                          } // TxD idx4
                          } // cats
                           Serial.println("!!");
                           Serial.println("!!");                                                            
                           Serial.println(" ");
                           //for (i=0; i<100; i++) delayMicroseconds(16383);
}
                                                                                           
//#########################################################################################
                                                                                                            
//EOF                                                                            



______________________________________

kernel panic: improbability coefficient below zero

Discussions