Car sensor signals

Other Hardware Sensors
1

Hello.
I am new in all about this, but i want to get sensor from a car to Android tablet and i thought to use Arduino with bluetooth for this.

Originally some sensor's wires goes to instrument cluster without external power and all these sensors are in same ground and then ground goes to instrument cluster.

I am quite sure that these does not work, but i try to show in picture what i planned.
I am not so sure yet what voltages these sensors use, but i think some are 0-5v and some 0-14v, so i may need some kind of voltage dividers. What else i need and where?
I do not know how to draw schematics, sorry.

sensorikaavio2
sensorikaavio21276×749 55.4 KB

Then there's sensors which get power from car's battery and ground to body.

2

The car probably has a canbus system unless it is very old. Lots of info on sniffing the signal. An esp32 may be worth looking at

3

Electrics are from Vw Golf 2003.
It has can-bus, but not fully.
There is still several sensors which are not in CAN.

4

A nice idea but since we do not have the same car give us a better schematic that also shows power and ground source, identifies the sensors, etc. Your sensor information leaves a lot to be desired. It would be helpful if you gave us the sensor information or a link to the technical information on each hardware device. So far you have some boxes with lines and a few labels. Also important if you are using voltage regulators show them and the complete circuit.

5

Need to try to make better schematic, but first i wanted to get some information to which way i would go. What are the options convert voltages for Arduino in this case.
I know that that 12v need convert to 5v, but how with many sensors.
I saw plenty of topics of voltage dividers, but if i do it with resistors and zeners etc. In my opinion it goes too complicated and take more space.
The most attractive option for me is LM7805 for now.
Also optocoupler may work? Or is it too overkill?

Reading can-bus should not be that big thing. Of course the best thing would be if all works with it.
It should be possible to handle CAN with newest shields, i did read that it can be fault-tolerant can-bus, but should be possible.

6

You want to know what you need to join A and B. First we need to know what A and B are. Get working on the schematic and put down all the known parts. The bits to connect them can be worked out later

7

If you want to measure automotive voltages using Arduino, resistive dividers are required.

Zener diodes are useless for input voltage protection, especially in an automotive environment.

8

No magic required, but you are going to need to study, pull sensor info, Google lots. A friend has an old Rotax engine for Europa experimental airplane. The sensors were designed to work at 12V - 14V but not acceptable for Arduino (of course.) As friend did not have existing analog dials, the solution was simple: just +5 Volts. Sensors were not linear so a lookup table was used. Code snippet below:

#define WaterTemp_AnalogIn        A0  // Coolant Temperature
#define OilTemp_AnalogIn          A1  // Oil Temperature
#define OilPress_AnalogIn         A2  // Oil Pressure
#define FrontCylTemp_AnalogIn     A3  // Cylinder Head Front Temperature 1
#define RearCylTemp_AnalogIn      A4  // Cylinder Head Rear Temperature 2

int CHTemp_1    =  0;                 // Cylinder Head Temperature 1
int CHTemp_2    =  0;                 // Cylinder Head Temperature 2
int EOTemp_1    =  0;                 // Engine Oil Temperature
int EOPres_1    =  0;                 // Engine Oil Pressure
int ECTemp_1    =  0;                 // Engine Coolant/Water Temperature

// CHT: Cylinder Head Temperature
//const int CHT[] PROGMEM = { 360, 360, 256, 329, 302, 284, 275, 266, 257, 248, 239, 235, 230, 225, 221, 212, 208, 203, 200, 197, 194, 191, 188, 185, 182, 180, 178, 176, 173, 171, 169, 167, 166, 164, 162, 160, 158, 156, 154, 152, 151, 150, 149, 147, 144, 143, 142, 141, 140, 138, 137, 136, 135, 134, 133, 132, 131, 130, 129, 128, 127, 126, 125, 124, 123, 122, 121, 121, 120, 119, 118, 117, 116, 115, 114, 113, 113, 112, 111, 110, 109, 108, 107, 106, 106, 105, 105, 104, 104, 103, 102, 101, 100, 99, 98, 97, 97, 96, 96, 95, 95, 94, 93, 92, 91, 90, 89, 89, 88, 88, 87, 87, 86, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 74, 72, 70, 68, 66, 65, 64, 62, 61, 58, 56, 54, 52, 50, 48, 46, 44, 42, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40 };
const int CHT[] PROGMEM = { 302, 302, 302, 302, 302, 286, 281, 269, 257, 249, 242, 234, 228, 221, 216, 213, 207, 202, 199, 194, 191, 189, 185, 182, 180, 178, 175, 173, 171, 168, 166, 164, 161, 159, 158, 157, 154, 152, 151, 148, 147, 146, 145, 144, 142, 140, 139, 137, 136, 135, 134, 133, 131, 130, 129, 128, 127, 126, 125, 124, 123, 121, 120, 119, 118, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 102, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100 };
//const int CHT[] PROGMEM = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 };

// EOT: Engine Oil Temperature
//const int EOT[] PROGMEM = { 360, 360, 256, 329, 302, 284, 275, 266, 257, 248, 239, 235, 230, 225, 221, 212, 208, 203, 200, 197, 194, 191, 188, 185, 182, 180, 178, 176, 173, 171, 169, 167, 166, 164, 162, 160, 158, 156, 154, 152, 151, 150, 149, 147, 144, 143, 142, 141, 140, 138, 137, 136, 135, 134, 133, 132, 131, 130, 129, 128, 127, 126, 125, 124, 123, 122, 121, 121, 120, 119, 118, 117, 116, 115, 114, 113, 113, 112, 111, 110, 109, 108, 107, 106, 106, 105, 105, 104, 104, 103, 102, 101, 100, 99, 98, 97, 97, 96, 96, 95, 95, 94, 93, 92, 91, 90, 89, 89, 88, 88, 87, 87, 86, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 74, 72, 70, 68, 66, 65, 64, 62, 61, 58, 56, 54, 52, 50, 48, 46, 44, 42, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40 };
const int EOT[] PROGMEM = { 302, 302, 302, 302, 302, 286, 281, 269, 257, 249, 242, 234, 228, 221, 216, 213, 207, 202, 199, 194, 191, 189, 185, 182, 180, 178, 175, 173, 171, 168, 166, 164, 161, 159, 158, 157, 154, 152, 151, 148, 147, 146, 145, 144, 142, 140, 139, 137, 136, 135, 134, 133, 131, 130, 129, 128, 127, 126, 125, 124, 123, 121, 120, 119, 118, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 102, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100 };
//const int EOT[] PROGMEM = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 };

// ECT: Engine Coolant Temperature
const int ECT[] PROGMEM = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 };
//const int ECT[] PROGMEM = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 };

// EOP: Engine Oil Pressure
//const int EOP[] PROGMEM = { 0, 0, 3, 6, 9, 12, 13, 15, 17, 20, 23, 25, 27, 29, 44, 48, 53, 58, 62, 73, 80, 87, 94, 102, 110, 116, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 };
const int EOP[] PROGMEM = { 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 10, 11, 12, 13, 14, 14, 15, 15, 16, 17, 18, 19, 20, 21, 22, 22, 23, 24, 25, 26, 27, 28, 29, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 44, 45, 46, 47, 48, 49, 50, 54, 55, 56, 57, 58, 58, 59, 61, 63, 65, 67, 69, 70, 71, 73, 74, 75, 77, 78, 80, 82, 83, 85, 87, 90, 93, 96, 97, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 123, 125, 127, 131, 133, 135, 139, 143, 145, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 };
//const int EOP[] PROGMEM = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 };

// ________________________________________________________________________(read analog pin previously defined)
    // Cylinder Head sensor #1
int CylHeadFront()
{                                                        
    /* int therm = analogRead(FrontCylTemp_AnalogIn) / 4;    // 10-bits with a VCC 5V+ reference */
    // int therm = (analogRead(FrontCylTemp_AnalogIn) >> 2);    // divide by 4 to remap 10-bit analog to 8-bit analog
    int ROW = 3;
    int therm = ( analogAverage ( ROW, FrontCylTemp_AnalogIn ) >> 2);
    int CHTemp_1 = pgm_read_word(&CHT[therm]); 
    return (CHTemp_1) ;
}
// ________________________________________________________________________(read analog pin previously defined)
    // Cylinder Head sensor #2
int CylHeadRear()
{
    // CHT Rear: OLED positions 8, 9, 10 LINE2

   /* int therm = analogRead(RearCylTemp_AnalogIn) / 4;       // 10-bit == 0 - 1023 */
   // int therm = (analogRead(RearCylTemp_AnalogIn) >> 2);    // divide by 4 to remap 10-bit analog to 8-bit analog
    int ROW = 4;
    int therm = ( analogAverage ( ROW, RearCylTemp_AnalogIn ) >> 2);
    int CHTemp_2 = pgm_read_word(&CHT[therm]);
    return (CHTemp_2) ;
}

// ________________________________________________________________________(read analog pin previously defined)
// Water Temperature int ECTemp_1    =  0    // Engine Coolant (Water) Temperature    
// OLED Display positions: 0, 1, 2 LINE2
 int EngineCoolantTemp()
{
   /* int therm = analogRead(WaterTemp_AnalogIn) / 4;   //10-bit == 0-1023 */
   // int therm = (analogRead(WaterTemp_AnalogIn) >> 2);
    int ROW = 0;
    int therm = ( analogAverage ( ROW, WaterTemp_AnalogIn ) >> 2);
   // Water Coolant Temperature
   int ECTemp_1 = pgm_read_word(&ECT[therm]);
    return (ECTemp_1) ;
}

// ________________________________________________________________________(read analog pin previously defined)
//  Oil Temperature int EOTemp_1    =  0;     // Engine Oil Temperature                
//  OLED Display positions: 4, 5, 6 LINE1
int EngOilTemp()
{
    /* int therm = analogRead(OilTemp_AnalogIn) / 4; // 10-bit, 0-1023 */
    // int therm = (analogRead(OilTemp_AnalogIn) >> 2);
    int ROW = 1;
    int therm = ( analogAverage ( ROW, OilTemp_AnalogIn ) >> 2);
    /* Engine Oil Temperature */
    int EOTemp_1 = pgm_read_word(&EOT[therm]);
    return (EOTemp_1) ;
}

// ________________________________________________________________________(read analog pin previously defined)
// Oil Pressure int EOPres_1    =  0;        // Engine Oil Pressure
// OLED Display positions 4, 5, 6 LINE2
int EngineOilPres()
{
    /* int therm = analogRead(OilPress_AnalogIn) / 4;      // 10-bit == 0-1023 */
    // int therm = (analogRead(OilPress_AnalogIn) >> 2);
    int ROW = 2;
    int therm = ( analogAverage ( ROW, OilPress_AnalogIn ) >> 2);
    EOPres_1 = pgm_read_word(&EOP[therm]);
    return (EOPres_1) ;
}

The average routine is basic:

#include <Streaming.h>                       // library can be found here: http://arduiniana.org/libraries/streaming/
#define DIAG false // or true

const int Average_Depth = 5 ;                // can be changed at expense of loop{} total time
int AnalogAverageMatrix [9][Average_Depth];  // 9 is based on A0, A1, A2, A3, A4, A10, A12, A13, A15

int analogAverage ( int ROW, int ApinNo )
{
    int ReadVal = 0;
    // Rollup ... small matrix, just assign for testing, could be a for() if desired
    // Oldest value is [0], newest value [4]
    AnalogAverageMatrix [ROW][0] = AnalogAverageMatrix [ROW][1];
    AnalogAverageMatrix [ROW][1] = AnalogAverageMatrix [ROW][2];
    AnalogAverageMatrix [ROW][2] = AnalogAverageMatrix [ROW][3];
    AnalogAverageMatrix [ROW][3] = AnalogAverageMatrix [ROW][4];
    // do two reads ... as a test, but one should really be enough IMO
    ReadVal = analogRead( ApinNo ); // delayMicroseconds( 10 );
    AnalogAverageMatrix [ROW][4] = analogRead( ApinNo );
    if ( DIAG) Serial << ROW  << ": " << AnalogAverageMatrix [ROW][0] << ", " <<  AnalogAverageMatrix [ROW][1] << ", " << AnalogAverageMatrix [ROW][2] << ", " << AnalogAverageMatrix [ROW][3] << ", " << AnalogAverageMatrix [ROW][4] << endl ;
    // now perform an average [0] -> [4]
    /*ReadVal = 0;
    for (int x = 0; x < 5; x++) {
      ReadVal += AnalogAverageMatrix[ROW][x];
    } */
    // Yes, a bit more flexible solution would be to loop
    ReadVal = AnalogAverageMatrix [ROW][0] + 
              AnalogAverageMatrix [ROW][1] + 
              AnalogAverageMatrix [ROW][2] + 
              AnalogAverageMatrix [ROW][3] + 
              AnalogAverageMatrix [ROW][4] ;
    ReadVal = ReadVal / Average_Depth;
    if (DIAG) Serial << "Average for " << ROW << ": " << "is " << ReadVal << endl;
    return ReadVal;     // The average is returned to calling function
}

/*  These notes need to be moved to _Notes after debugging and testing
    The test matrix is 45 integer values, arranged in 9 rows of 5 columns.
    [ROW] represents the function + specific analog input pin #
    Example:
    A0 is allocated to water temperature.  WaterTemp_AnalogIn is the pin-name variable representing A0
    Functions simply "set" ROW variable, call the analogAverage function with the analog pin name.
    ROW must be specified because the pins are not contiguous... A0, A1, A2, A3, A4, A10, A12, A13, A15 == 9 pins alias names == [0 - 8]
    The averaging matrix is hard-coded at the moment (easily expanded) to maintain 4 old values and the current analog input.
    The loop() cycle time is still under 1000mS, so the OLED displays should come to read average values in under 5 seconds.

Modified 20190712
  Base code provided by Bill as edited (arrays) version of Europa9_Mega2560 ----> Europa10_Mega2560
  
  Mofified all analogRead statements to average across Average_Depth as AReadAvg[Y][Average_Depth] where
    Y == [0] = WaterTemp_AnalogIn     X = [0], [1], [2], [3], [4]
         [1] = OilTemp_AnalogIn       X = [0], [1], [2], [3], [4]
         [2] = OilPres_AnallgIn       X = [0], [1], [2], [3], [4]
         [3] = FrontCylTemp_AnalogIn  X = [0], [1], [2], [3], [4]
         [4] = RearCylTemp_AnalogIn   X = [0], [1], [2], [3], [4]
         [5] = Ampres_AnalogIn        X = [0], [1], [2], [3], [4]
         [6] = Voltage_AnalogIn       X = [0], [1], [2], [3], [4]
         [7] = FuelQty_AnalogIn       X = [0], [1], [2], [3], [4]
         [8] = FuelPres_AnalogIn      X = [0], [1], [2], [3], [4]
 */
9

To start with your car can operate from about 6V through 18V and sometimes may see 24V, very seldom is it exactly 12V. Then there is the reverse battery protection say when jumped with a 24V battery. Load dump transients, and lots of electrical noise. The 7805 sounds great but it is probably one of the worse choices you can make. Use an automotive regulator that will support load dump, reverse battery etc it will save you lots of problems. They are not that expensive. Then be sure to follow the manufacturer's data sheet for decoupling etc, not all parts have the same decoupling requirements and can vary from manufacturer to manufacturer. Where are you going to place this and what are the max and min temperatures fingering worse case year round.

You state: "CAN with newest shields, i did read that it can be fault-tolerant can-bus, but should be possible." By definition CAN bus is fault tolerant. It is also multiple access, with non destructive arbitration.

You will have to switch from having a solution looking for a problem to problems looking for a solution. First and foremost you need to completely define the problems such as voltage etc.

10

Late thanks for the code and information.

Now i try to start with CAN-Bus. Just to read and send frames to RealDash with Bluetooth.
I have CAN-Bus shield and Bluetooth shield on Arduino.
I managed to read can-messages in serial monitor with manufacturer's example sketch.
I looked sketches and i tried to compine these.
I made a sketch and i wonder would it work at all.
Originally it is supposed to take data from OBD2, but i think it should work in my case, CAN-wires took from instrument cluster, same wires are goes to OBD from same connection.
I do not understand how i can get CAN to RealDash with Bluetooth.
I do not see anything what would do that in code, but this is what i have now.
I wanted to start only with rpm first, then add more when/if this will work some day.

/**
 * ============================================================================
 * FileName        : RealDashCan_V2_MCP2515.ino
 * modified by Yudi Patriot
 * ypatriot@gmail.com
 * last update 04-9-2021
 * 
 *  Part of     : RealDash
 *  Author      : Jani Immonen
 *  Created     : 15.10.2017
 * Arduino example sketch of how to use RealDash CAN protocol.
 * 
 * This example code is free for any use.
 * www.realdash.net
 *---------------------------------------
 *
 * combined with obd2-mcp2515
 * as published on : https://forum.arduino.cc/t/reading-ecu-data-via-can-bus-and-mcp2515/597914
 * library :  https://github.com/coryjfowler/MCP_CAN_lib
 * Thanks to : sherzaad@forum.arduino.cc
 * Last update: 19-june-2019
 * ============================================================================
**/
#include <mcp_can.h>
#include <SPI.h>
//------------------------------------------------
// Arduino digital and analog pins
// Realdash CAN variables
unsigned int digitalPins = 0;
int analogPins[7] = {0};
unsigned int textCounter = 0;
int AI0;
int AI1;
int AI2;
bool BitVal;
int RPM;

// end of Realdash CAN variables
//------------------------------
//MCP2515 variables
#define PID_ENGINE_RPM  0x0C
#define CAN_ID_PID 0x7DF //OBD-II CAN frame ID
#define CAN0_INT 2       // Set INT to pin 2  <--------- CHANGE if using different pin number
MCP_CAN CAN0(9);        // Set CS to pin 10 <--------- CHANGE if using different pin number
long unsigned int rxId;
unsigned char len = 0;
unsigned char rxBuf[8];
char msgString[128];       
uint16_t rpm;
// end of  MCP2515 variables
void sendPID(unsigned char __pid)
{
  unsigned char tmp[8] = {0x02, 0x01, __pid, 0, 0, 0, 0, 0};

  byte sndStat = CAN0.sendMsgBuf(CAN_ID_PID, 0, 8, tmp);

  if (sndStat == CAN_OK) {
//    Serial.print("PID sent: 0x");
//   Serial.println(__pid, HEX);
  }
  else {
    Serial.println("Error Sending Message...");
  }
}

void receivePID(unsigned char __pid)
{
    if (!digitalRead(CAN0_INT)) {                      // If CAN0_INT pin is low, read receive buffer
    CAN0.readMsgBuf(&rxId, &len, rxBuf);      // Read data: len = data length, buf = data byte(s)

    sprintf(msgString, "Standard ID: 0x%.3lX, DLC: %1d, Data: ", rxId, len);
//    Serial.print(msgString);

    for (byte i = 0; i < len; i++) {
      sprintf(msgString, " 0x%.2X", rxBuf[i]);
//      Serial.print(msgString);
    }
//    Serial.println("");
    switch (__pid) {
      case PID_ENGINE_RPM:
        if(rxBuf[2] == PID_ENGINE_RPM){
          
          rpm = ((256 * rxBuf[3]) + rxBuf[4]) / 4;
          RPM = rpm;
//         Serial.print("Engine Speed (rpm): ");
//         Serial.println(rpm, DEC);
        }
      break;
    }
  }
}

void setup()
{
  
  Serial.begin(9600);
  setupBlueToothConnection();
  // Initialize MCP2515 running at 8MHz with a baudrate of 500kb/s and the masks and filters disabled.
  if (CAN0.begin(MCP_STDEXT, CAN_500KBPS, MCP_16MHZ) == CAN_OK) { //< -------- - CHANGE if using different board
    Serial.println("MCP2515 Initialized Successfully!");
  }
  else {
    Serial.println("Error Initializing MCP2515...");
    while (1);
  }
  
  CAN0.setMode(MCP_NORMAL);   // Set operation mode to normal so the MCP2515 sends acks to received data.

  pinMode(CAN0_INT, INPUT);   // Configuring pin for /INT input

//  Serial.println("Sending and Receiving OBD-II_PIDs Example...");
}

//------------------------------
void loop()
{
  
  sendPID (PID_ENGINE_RPM);
  delay(10); //to allow time for ECU to reply
  receivePID(PID_ENGINE_RPM);
//abitrary loop delay
  delay(10);
  ReadDigitalStatuses();
  ReadAnalogStatuses();
  SendCANFramesToSerial();
  delay(10);   
}

void setupBlueToothConnection()
{
  Serial1.begin(38400); //Set BluetoothBee BaudRate to default baud rate 38400
  Serial1.print("\r\n+STWMOD=0\r\n"); //set the bluetooth work in slave mode
  Serial1.print("\r\n+STNA=SeeedBTSlave\r\n"); //set the bluetooth name as "SeeedBTSlave"
  Serial1.print("\r\n+STOAUT=1\r\n"); // Permit Paired device to connect me
  Serial1.print("\r\n+STAUTO=0\r\n"); // Auto-connection should be forbidden here
  delay(2000); // This delay is required.
  Serial1.print("\r\n+INQ=1\r\n"); //make the slave bluetooth inquirable 
  Serial.println("The slave bluetooth is inquirable!");
  delay(2000); // This delay is required.
  Serial1.flush();
}

//------------------------------ 

void ReadDigitalStatuses()
{
  // read status of digital pins (1-13)
  digitalPins = 0;

  int bitposition = 0;
    for (int i=0; i<13; i++)
  {
    if ( i==7 || i==8 || i==9) 
    {
      BitVal = !digitalRead(i); 
    } else 
    {
    BitVal = digitalRead(i);
    }
    if (BitVal == HIGH) digitalPins |= (1 << bitposition);
    bitposition++;
  }
}
//------------------------------
void ReadAnalogStatuses()
{
  // read analog pins (0-7)
  for (int i=0; i<7; i++)
  {
    analogPins[i] = analogRead(i);
  }
}
//------------------------------
void SendCANFramesToSerial()
{
  byte buf[8];
  // build 1st CAN frame, RPM, SPD, throtle, maf
  //KPL = SPD/3600/MAF*(14.7*710);
  memcpy(buf, &rpm, 2);

  // write first CAN frame to serial
  SendCANFrameToSerial(3200, buf);

  // build 2nd CAN frame, Arduino digital pins and 2 analog values
 AI0 = (analogPins[0] - 595)*(-1)/1.17;
// AI1 = 28 + ((788-analogPins[1])/53); 
AI1 = 85 -((analogPins[1]-267)/(78/10));     
  AI2 = (analogPins[2]*0.1274);
  memcpy(buf, &digitalPins, 2);
  memcpy(buf + 2, &AI0, 2); 
  memcpy(buf + 4, &AI1, 2);
  memcpy(buf + 6, &AI2, 2);

  // write 2nd CAN frame to serial
  SendCANFrameToSerial(3201, buf);

  // build 3rd CAN frame, rest of Arduino analog values
  memcpy(buf, &analogPins[3], 2);
  memcpy(buf + 2, &analogPins[4], 2);
  memcpy(buf + 4, &analogPins[5], 2);
  memcpy(buf + 6, &analogPins[6], 2);

  // write 3rd CAN frame to serial
  SendCANFrameToSerial(3202, buf);

}
//------------------------------
void SendCANFrameToSerial(unsigned long canFrameId, const byte* frameData)
{
  // the 4 byte identifier at the beginning of each CAN frame
  // this is required for RealDash to 'catch-up' on ongoing stream of CAN frames
  const byte serialBlockTag[4] = { 0x44, 0x33, 0x22, 0x11 };
  Serial.write(serialBlockTag, 4);

  // the CAN frame id number (as 32bit little endian value)
  Serial.write((const byte*)&canFrameId, 4);

  // CAN frame payload
  Serial.write(frameData, 8);
}