Error_handling.c

Go to the documentation of this file.

/*----------------------------------------------------------------------------
 * Name:    Error_handling.c
 * Purpose: Funzioni e variabili per la gestione degli errori
 * Version: V1.00
 * Note(s):
 *----------------------------------------------------------------------------
 * History:
 *          
 *----------------------------------------------------------------------------*/
 /// \file
 
/*! \page ErrorCross_ ErrorCross
 *\brief  <span style="color:red;"> <b> Errors Managing  </b> </span>
 *\tableofcontents
 
 *\section error_summary Page Summary
 <hr width="50%" size="10" align="left">
 Here you can find informations about the follwoing topics:
 - \ref indirizzi_flag
        - \ref indirizzi
        - \ref flags
 - \ref error_managing_functions
 - \ref error_anatomy
 
 *\section indirizzi_flag Error registers and flags 
<hr width="90%" size="10" align="left">
 *\subsection indirizzi Error registers 
 <hr width="90%" size="10" align="left">
 A large number of flags are available to take account of the presence of errors or not adequate performances
 of both the hw and fw. 
 The errors are in a vector of \b unsigned \b int. Every element of the vector cotains 32 flags of information. 
 A flag in true state means that the corresponding error has been verified. 
 The vector with the errors is #Post_frontend_errors:
\snippet Error_handling.c vec_Post_frontend_errors
 its registers are addressed according to the enum #ERROR_CROSS_address_ 
 whose list follows. Note that the length of the half vector is #error_number_of_errors_registers, the last element of the list for board down.
 A similar number of elements with the same name offset by #error_offset_for_board_up account for board up.
 The number on left of the list is the register address whithin #Post_frontend_errors:
 
<ol start="0">
  <li> #error_address_reg_ADC0 flags list at \ref flags_error_ADC
  <li> #error_address_reg_ADC1 flags list at \ref flags_error_ADC
  <li> #error_address_Power_Supply_in_General  flags list at \ref flags_error_PowerSupply
  <li> #error_address_I2C0  Error register for I2C0 flags list at \ref flags_error_I2C
    <li> #error_address_I2C1  Error register for I2C1 flags list at \ref flags_error_I2C
    <li> #error_address_SPI     Error register for SPI flags list at \ref flags_error_SPI
    <li> #error_preamplifier_down flags list at \ref flags_error_preamplifier
    <li> #error_preamplifier_up flags list at \ref flags_error_preamplifier
  <li> #error_address_CAN flags list at \ref flags_error_CAN
  <li> #error_address_PGA_DetectorTrimmer_down flags list at \ref flags_error_PGA_DetectorTrimmer
  <li> #error_address_PGA_DetectorTrimmer_up    flags list at \ref flags_error_PGA_DetectorTrimmer
  <li> #error_address_Bias_adjustment flags list at \ref flags_error_Bias_Adj
  <li> #error_number_of_errors_registers (this is not an address, it is the lenght of the vector)
    <li> #error_offset_for_board_up registers for board up start from this addres and replica the firsts above
</ol>
 
\n The first regsiters, from address 0 to #error_number_of_errors_registers, are for the lower board. 
The registers whose address starts from #error_offset_for_board_up registers, 
are for board up and are a replica in meaning of the first ones. So, for instance, a fail in reading 
power supply for board down is found at address #error_address_Power_Supply_in_General, or 2, 
while the same fail on board up
is found at address #error_offset_for_board_up registers + #error_address_Power_Supply_in_General.
 
 *\subsection flags  Flags 
<hr width="90%" size="10" align="left">
\n Every register of the #Post_frontend_errors vector is a set of 32 homogenous flags, that summmmarize the behaviour 
of some subjects, ADC, I2, SPI, etc. The signature of an error is the value of 1 of a flag and every flag. 
 As an instance, to consult the error during I2C0 communication one has to look at the register #Post_frontend_errors[#error_address_I2C0].
 Each flag of that registers that is 1 marks the verification of any not expected bahaviour.
 \n Now, to manage the flags a few function are available, described below. 
 \n Let's start to interpet the flags. To each register an enum is built that lists the flags. They are all listed below. The number on the left 
 of the lists are the position of the flag in the register. As an instance, if the error #Vbol_neg_large_for_switching happens, than a 1
 is stored at 1 << #Vbol_neg_large_for_switching  in the #error_address_Power_Supply_in_General register.
 \n Here is the list:
 
<!-- -------------------  Definizioni per i contatori  --------------------------- -->
\htmlonly
<head>
<style>
ul {
  list-style-type: none;
}
body {
  counter-reset: ADC -1 PowSup -1 I2C -1 I2C_B -1 CAN -1 Trimmer -1 Bias -1 preamplifier -1 PGA_DetectorTrimmer -1 SPI -1;
}
li.ADC::before {
  counter-increment: ADC;
  content: counter(ADC) ". " ;
}
li.PowSup::before {
  counter-increment: PowSup;
  content: counter(PowSup) ". " ;
}
li.I2C::before {
  counter-increment: I2C;
  content: counter(I2C) ". " ;
}
li.I2C_B::before {
  counter-increment: I2C_B;
  content: counter(I2C_B) ". " ;
}
li.CAN::before {
  counter-increment: CAN;
  content: counter(CAN) ". " ;
}
li.Trimmer::before {
  counter-increment: Trimmer;
  content: counter(Trimmer) ". " ;
}
li.Bias::before {
  counter-increment: Bias;
  content: counter(Bias) ". " ;
}
li.preamplifier::before {
  counter-increment: preamplifier;
  content: counter(preamplifier) ". " ;
}
li.PGA_DetectorTrimmer::before {
  counter-increment: PGA_DetectorTrimmer;
  content: counter(PGA_DetectorTrimmer) ". " ;
}
li.SPI::before {
  counter-increment: SPI;
  content: counter(SPI) ". " ;
}
 
table, th, td {
  border: 1px solid;
  border-collapse: collapse;
}
 
</style>
</head>
 
 
\endhtmlonly
<!-- -------------------  FIne Definizioni per i contatori  --------------------------- -->
 
<table style="width: 90%" >
<tr><td colspan="2"><span style="color:red;"> Register name:</span> #error_address_reg_ADC0 and #error_address_reg_ADC1 (ADC's errors)</td></tr> \anchor flags_error_ADC
<tr><td style="width: 15%">ADC errors flags </td>
<td style="width:75%">
<span style="color:red;"> Da implementare</span>
<ul>
        <li class="ADC"> #ADC_internal_General_fails   ADC general fault
        <li class="ADC"> #ADC_SPI_fault (its value is 0) for SPI Communication fault
        <li class="ADC"> #ADC_RDY_pin_fault for ADC ready signal not received
        <li class="ADC"> #ADC_RDY_pin_fault_during_calibration for ADC ready not during calibration
        <li class="ADC"> #VREF_ADC_too_small    for ADC VREF measured out of its tolerance, too small
        <li class="ADC"> #VREF_ADC_too_large for ADC VREF measured out of its tolerance, too large
        <li class="ADC"> #ADC_external_fails measurement form an external ADC went wrong
</ul>
</td>
</tr>
</table>
 
\n
 
<!-- -------------------  error_address_Power_Supply_in_General  --------------------------- -->
<table style="width: 90%" >
<tr><td colspan="2"><span style="color:red;"> Register name:</span> #error_address_Power_Supply_in_General (eorrors with any Power Supply)</td></tr> \anchor flags_error_PowerSupply
<tr><td style="width: 15%">Errors flags for Vbol for switching </td>
<td style="width:75%">
<span style="color:red;"> Da implementare</span>
<ul>
        <li class="PowSup"> #Vbol_pos_small_for_switching (its value is 0) for  Positive Vbol too small for switching from internal to external power or vice-versa</li>
        <li class="PowSup"> #Vbol_pos_large_for_switching for Positive Vbol too large for switching from internal to external power or vice-versa</li>
        <li class="PowSup"> #Vbol_neg_small_for_switching for Negative Vbol too small for switching from internal to external power or vice-versa</li>
        <li class="PowSup"> #Vbol_neg_large_for_switching for Negative Vbol too large for switching from internal to external power or vice-versa</li>
        <li class="PowSup"> #ADC_RDY_pin_fault_during_calibration for ADC ready not during calibration
        <li class="PowSup"> #VREF_ADC_too_small for ADC VREF measured out of its tolerance, too small
        <li class="PowSup"> #VREF_ADC_too_large for ADC VREF measured out of its tolerance, too large
</ul>
</td>
</tr>
<tr><td>Errors flags for Vbol limiting values </td>
<td>
<span style="color:red;"> Da implementare</span>
    <ul>
        <li class="PowSup"> #Vbol_pos_too_large for Positive Vbol exceeds the maximum</li>
        <li class="PowSup"> #Vbol_pos_too_small for Positive Vbol is below the lower limit</li>
        <li class="PowSup"> #Vbol_neg_too_large for Negative Vbol exceeds the maximum
        <li class="PowSup"> #Vbol_neg_too_small for Negative Vbol is below the lower limit
    </ul>
</td>
</tr>
<tr><td>Errors flags for VREF_POS_PRE</td>
<td>
<span style="color:red;"> Da implementare</span>
  <ul>
        <li class="PowSup"> #Vref_pos_too_large for Positive Vref too large
        <li class="PowSup"> #Vref_pos_too_small for Positive Vref too small
    </ul>   
</td>
</tr>
<tr><td>Errors flags for VREF_NEG_PRE</td>
<td>
<span style="color:red;"> Da implementare</span>
  <ul>
    <li class="PowSup"> #Vref_neg_absolute_val_too_large for Negative Vref too large
        <li class="PowSup"> #Vref_neg_absolute_val_too_small for  Negative Vref too small
 </ul>
</td>
</tr>
<tr><td>Errors flags for VCC_PRE   </td>
<td>
<span style="color:red;"> Da implementare</span>
  <ul>
        <li class="PowSup"> #VCC_PRE_pos_too_large for Positive supply for preamplifier too large
        <li class="PowSup"> #VCC_PRE_pos_too_small for Positive supply for preamplifier too small
 </ul>
</td>
</tr>
<tr><td>Errors flags for VEE_PRE   </td>
<td>
<span style="color:red;"> Da implementare</span>
  <ul>
        <li class="PowSup"> #VEE_PRE_absolute_val_too_large for Negative supply for preamplifier too large
        <li class="PowSup"> #VEE_PRE_absolute_val_too_small for Negative supply for preamplifier too small
 </ul>
</td>
</tr>
<tr><td>Errors flags rotation for VCC_PGA   </td>
<td>
<span style="color:red;"> Da implementare</span>
  <ul>
        <li class="PowSup"> #VCC_PGA_pos_too_large Positive supply for PGA too large
        <li class="PowSup"> #VCC_PGA_pos_too_small for Positive supply for PGA too small
    </ul>
</td>
</tr>
<tr><td> Errors flags rotation for VEE_PGA  </td>
<td>
<span style="color:red;"> Da implementare</span>
  <ul>
        <li class="PowSup"> #VEE_PGA_absolute_val_too_large for Negative supply for PGA too large
        <li class="PowSup"> #VEE_PGA_absolute_val_too_small for Negative supply for PGA too small
    </ul>   
</td>
</tr>
<tr><td>  Errors flags for V__dig_5V </td>
<td>
<span style="color:red;"> Da implementare</span>
<ul>
        <li class="PowSup"> #V__dig_5V_val_too_large for Digital 5 V supply too large
        <li class="PowSup"> #V__dig_5V_val_too_small for Digital 5 V supply too small
    </ul>
</td>
</tr>
<tr><td> Errors flags for V__dig_3e3V   </td>
<td>
<span style="color:red;"> Da implementare</span>
  <ul>
        <li class="PowSup"> #V__dig_3e3V_val_too_large for Digital 3.3 V supply too large
        <li class="PowSup"> #V__dig_3e3V_val_too_small for Digital 3.3 V supply too small
    </ul>
</td>
</tr>
</table>
 
\n
<!-- -------------------  error_address_I2C0/1 A --------------------------- -->
<table style="width: 90%" >
<tr><td colspan="2"><span style="color:red;"> Register name:</span> #error_address_I2C0
and #error_address_I2C1 (errors with any I2C) </td></tr> \anchor flags_error_I2C
<tr><td style="width: 15%">Trouble with I2C communication </td>
<td style="width: 75%">
<span style="color:red;"> parziale</span>
  <ul>
        <li class="I2C"> #I2C_Error_NONE it would be EVENT_TRANSFER_DONE. The definition from CMSIS is "ARM_I2C_" + "EVENT_TRANSFER_DONE"
        <li class="I2C"> #I2C_Error_EVENT_TRANSFER_INCOMPLETE this and the following follows the rule above
        <li class="I2C"> #I2C_Error_EVENT_SLAVE_TRANSMIT 
        <li class="I2C"> #I2C_Error_EVENT_SLAVE_RECEIVE 
        <li class="I2C"> #I2C_Error_EVENT_ADDRESS_NACK 
        <li class="I2C"> #I2C_Error_NONE this would be "ARM_I2C_" + "EVENT_GENERAL_CALL"
        <li class="I2C"> #I2C_Error_EVENT_ARBITRATION_LOST 
        <li class="I2C"> #I2C_Error_EVENT_BUS_ERROR 
        <li class="I2C"> #I2C_Error_EVENT_BUS_CLEAR 
    </ul>
</td>
</tr>
<tr><td> I2C Mux0 settings  </td>
<td>
<span style="color:red;"> parziale</span>
  <ul>
        <li class="I2C"> #I2C_Error_I2C_mux I2C mux distribution error
    </ul>
</td>
</tr>
<tr><td> I2C to parallel conversion PCA9554  </td>
<td>
  <ul>
        <li class="I2C"> #I2C_Error_I2C_to_parallel_PCA9554_0,      I2C to parallel conversion ch0
        <li class="I2C"> #I2C_Error_I2C_to_parallel_PCA9554_1,      I2C to parallel conversion ch1
        <li class="I2C"> #I2C_Error_I2C_to_parallel_PCA9554_2,      I2C to parallel conversion ch2
        <li class="I2C"> #I2C_Error_I2C_to_parallel_PCA9554_3,      I2C to parallel conversion ch3  
    </ul>
</td>
</tr>
<tr><td> Preamplifier trimmer  </td>
<td>
  <ul>
 <li class="I2C"> #I2C_Error_trimmer_0,     trimmer ch0
 <li class="I2C"> #I2C_Error_trimmer_1,     trimmer ch1
 <li class="I2C"> #I2C_Error_trimmer_2,     trimmer ch2
 <li class="I2C"> #I2C_Error_trimmer_3,     trimmer ch3
 <li class="I2C"> #I2C_Error_trimmer_4,     trimmer ch4
 <li class="I2C"> #I2C_Error_trimmer_5,     trimmer ch5 
    </ul>
</td> 
 
</tr>
<tr><td> EPROM  </td>
<td>
  <ul>
  <li class="I2C"> #I2C_error_EPROM_0,       EPROM ch0
  <li class="I2C"> #I2C_error_EPROM_1,       EPROM ch1
  <li class="I2C"> #I2C_error_EPROM_2,       EPROM ch2
  <li class="I2C"> #I2C_error_EPROM_3,       EPROM ch3
  <li class="I2C"> #I2C_error_EPROM_4,       EPROM ch4
  <li class="I2C"> #I2C_error_EPROM_5,       EPROM ch5  
    </ul>
</td>
 
</table>
 
\n
<!-- -------------------  error_address_I2C0/1 B --------------------------- -->
<table style="width: 90%" >
<tr><td colspan="2"><span style="color:red;"> Register name:</span> #error_address_I2C0_B
and #error_address_I2C1_B (errors with any I2C) </td></tr> \anchor flags_error_I2C_B
<tr><td style="width: 15%">Trouble with preamplifier thermometer </td>
<td style="width: 75%">
<span style="color:red;"> parziale</span>
  <ul>
   <li class="I2C_B"> #I2C_error_termometro_0,       termometro ch0
   <li class="I2C_B"> #I2C_error_termometro_1,       termometro ch1
   <li class="I2C_B"> #I2C_error_termometro_2,       termometro ch2
   <li class="I2C_B"> #I2C_error_termometro_3,       termometro ch3
   <li class="I2C_B"> #I2C_error_termometro_4,       termometro ch4
   <li class="I2C_B"> #I2C_error_termometro_5,       termometro ch5  
    </ul>
</td>
</tr>
 
</tr>
<tr><td> Bias trimmer  </td>
<td>
  <ul>
   <li class="I2C_B"> #I2C_error_trimmer_bias_0,     trimmer_bias ch0
   <li class="I2C_B"> #I2C_error_trimmer_bias_1,     trimmer_bias ch1
   <li class="I2C_B"> #I2C_error_trimmer_bias_2,     trimmer_bias ch2
   <li class="I2C_B"> #I2C_error_trimmer_bias_3,     trimmer_bias ch3
   <li class="I2C_B"> #I2C_error_trimmer_bias_4,     trimmer_bias ch4
   <li class="I2C_B"> #I2C_error_trimmer_bias_5      trimmer_bias ch5   
    </ul>
</td>
 
</table>
 
 
\n
<!-- -------------------  error_SPI  --------------------------- -->
<table style="width: 90%" >
<tr><td colspan="2"><span style="color:red;"> Register name:</span> #error_address_SPI  </td></tr> \anchor flags_error_SPI
<tr><td style="width: 15%">Trouble with SPI communication </td>
<td style="width: 75%">
<span style="color:red;"> parziale</span>
  <ul>
        <li class="SPI"> #SPI_error_NONE,           this should be ARM_SPI_EVENT_TRANSFER_COMPLETE
        <li class="SPI"> #SPI_error_EVENT_DATA_LOST, this is ARM_SPI_EVENT_DATA_LOST
        <li class="SPI"> #SPI_error_EVENT_MODE_FAULT this is ARM_SPI_EVENT_MODE_FAULT
    </ul>
</td>
</tr>
</table>
 
\n
<!-- -------------------  error_address_CAN  --------------------------- -->
<table style="width: 90%" >
<tr><td colspan="2"><span style="color:red;"> Register name:</span> #error_address_CAN (errors with CAN bus communication) </td></tr> \anchor flags_error_CAN
<tr><td style="width: 15%">  Trouble with CAN communication   </td>
<td style="width: 75%">
<span style="color:red;"> Da implementare</span>
  <ul>
        <li class="CAN"> #CAN_error_comunichiamo_qualche_dato_timeout_on_transmission (its value is 0) for Transmission CAN error
    </ul>
</td>
</tr>
</table>
 
\n
<!-- -------------------  error_preamplifier_down/up  --------------------------- -->
<table style="width: 90%" >
<tr><td colspan="2"><span style="color:red;"> Register name:</span> #error_preamplifier_down and #error_preamplifier_up </td></tr> \anchor flags_error_preamplifier
 
<tr><td style="width: 15%"> Trouble in temperature reading    </td>
<td style="width: 75%">
<span style="color:red;"> Da implementare</span>
  <ul>
        <li class="preamplifier"> #preamplifier_Error_in_reading_temperature_0 for Preaamplifier temperature missed of CH0
        <li class="preamplifier"> #preamplifier_Error_in_reading_temperature_1  for Preaamplifier temperature missed of CH1
        <li class="preamplifier"> #preamplifier_Error_in_reading_temperature_2  for Preaamplifier temperature missed of CH2
        <li class="preamplifier"> #preamplifier_Error_in_reading_temperature_3  for Preaamplifier temperature missed of CH3
        <li class="preamplifier"> #preamplifier_Error_in_reading_temperature_4  for Preaamplifier temperature missed of CH4
        <li class="preamplifier"> #preamplifier_Error_in_reading_temperature_5  for Preaamplifier temperature missed of CH5     
    </ul>
</td>
</tr>
<tr><td> Troubles with reading preamplifier trimmer    </td>
<td>
<span style="color:red;"> Da implementare</span>
  <ul>
        <li class="preamplifier"> #preamplifier_Error_offset_not_accurate_0 for Preaamplifier trimmer reading error CH0
        <li class="preamplifier"> #preamplifier_Error_offset_not_accurate_1 for Preaamplifier trimmer reading error CH1
        <li class="preamplifier"> #preamplifier_Error_offset_not_accurate_2 for Preaamplifier trimmer reading error CH2
        <li class="preamplifier"> #preamplifier_Error_offset_not_accurate_3 for Preaamplifier trimmer reading error CH3
        <li class="preamplifier"> #preamplifier_Error_offset_not_accurate_4 for Preaamplifier trimmer reading error CH4
        <li class="preamplifier"> #preamplifier_Error_offset_not_accurate_5 for Preaamplifier trimmer reading error CH5
    </ul>
</td>
</tr>
<tr><td> Troubles with writing preamplifier trimmer    </td>
<td>
<span style="color:red;"> Da implementare</span>
  <ul>
        <li class="preamplifier"> #preamplifier_Error_with_its_trimmer_0 for Preaamplifier trimmer writing error CH0
        <li class="preamplifier"> #preamplifier_Error_with_its_trimmer_1 for Preaamplifier trimmer writing error CH1
        <li class="preamplifier"> #preamplifier_Error_with_its_trimmer_2 for Preaamplifier trimmer writing error CH2
        <li class="preamplifier"> #preamplifier_Error_with_its_trimmer_3 for Preaamplifier trimmer writing error CH3
        <li class="preamplifier"> #preamplifier_Error_with_its_trimmer_4 for Preaamplifier trimmer writing error CH4
        <li class="preamplifier"> #preamplifier_Error_with_its_trimmer_5 for Preaamplifier trimmer writing error CH5
    </ul>
</td>
</tr>
<tr><td> Troubles in writing the preamplifier EEPROMs    </td>
<td>
<span style="color:red;"> parziale</span>
  <ul>
        <li class="preamplifier"> #preamplifier_Error_with_its_EEPROM_0 for Preamplifier EEPROM writing error CH0
        <li class="preamplifier"> #preamplifier_Error_with_its_EEPROM_1 for Preamplifier EEPROM writing error CH1
        <li class="preamplifier"> #preamplifier_Error_with_its_EEPROM_2 for Preamplifier EEPROM writing error CH2
        <li class="preamplifier"> #preamplifier_Error_with_its_EEPROM_3 for Preamplifier EEPROM writing error CH3
        <li class="preamplifier"> #preamplifier_Error_with_its_EEPROM_4 for Preamplifier EEPROM writing error CH4
        <li class="preamplifier"> #preamplifier_Error_with_its_EEPROM_5 for Preamplifier EEPROM writing error CH5
    </ul>       
</td>
</tr>
</table>
 
\n
<!-- -------------------  error_address_CAN  --------------------------- -->
<table style="width: 90%" >
<tr><td colspan="2"><span style="color:red;"> Register name:</span> #error_address_CAN (errors with CAN bus communication) </td></tr>
<tr><td style="width: 15%">  Trouble with CAN communication   </td>
<td style="width: 75%">
<span style="color:red;"> Da implementare</span>
  <ul>
        <li class="CAN"> #CAN_error_comunichiamo_qualche_dato_timeout_on_transmission (its value is 0) for Transmission CAN error
    </ul>
</td>
</tr>
</table>
 
\n
<!-- -------------------  #error_PGA_DetectorTrimmer  --------------------------- -->
<table style="width: 90%" >
<tr><td colspan="2"><span style="color:red;"> Register name:</span> #error_address_PGA_DetectorTrimmer_down and #error_address_PGA_DetectorTrimmer_up </td></tr> \anchor flags_error_PGA_DetectorTrimmer
<tr><td style="width: 15%"> Troubles with detector trimmer ommunication    </td>
<td style="width: 75%">
<span style="color:red;"> Da implementare</span>
  <ul>
        <li class="PGA_DetectorTrimmer"> #DetectorTrimmer_error_0 for onboard trimmer error communication CH0
        <li class="PGA_DetectorTrimmer"> #DetectorTrimmer_error_1 for onboard trimmer error communication CH1
        <li class="PGA_DetectorTrimmer"> #DetectorTrimmer_error_2 for onboard trimmer error communication CH2
        <li class="PGA_DetectorTrimmer"> #DetectorTrimmer_error_3 for onboard trimmer error communication CH3
        <li class="PGA_DetectorTrimmer"> #DetectorTrimmer_error_4 for onboard trimmer error communication CH4
        <li class="PGA_DetectorTrimmer"> #DetectorTrimmer_error_5 for onboard trimmer error communication CH5
    </ul>
</td>
</tr>
<tr><td style="width: 15%"> Troubles with PGA settings    </td>
<td style="width: 75%">
<span style="color:red;"> Da implementare</span>
  <ul>
        <li class="PGA_DetectorTrimmer"> #PGA_error_0 for onboard trimmer error communication CH0
        <li class="PGA_DetectorTrimmer"> #PGA_error_1 for onboard trimmer error communication CH1
        <li class="PGA_DetectorTrimmer"> #PGA_error_2 for onboard trimmer error communication CH2
        <li class="PGA_DetectorTrimmer"> #PGA_error_3 for onboard trimmer error communication CH3
        <li class="PGA_DetectorTrimmer"> #PGA_error_4 for onboard trimmer error communication CH4
        <li class="PGA_DetectorTrimmer"> #PGA_error_5 for onboard trimmer error communication CH5
    </ul>
</td>
</tr>
</table>
 
\n
<!-- -------------------  error_address_Bias_adjustment  --------------------------- -->
<table style="width: 90%" >
<tr><td colspan="2"><span style="color:red;"> Register name:</span> #error_address_Bias_adjustment (detector bias errors) </td></tr> \anchor flags_error_Bias_Adj
<tr><td style="width: 15%"> Final differential bias out of tolerance    </td>
<td style="width: 75%">
<span style="color:red;"> Da implementare</span>
  <ul>
      <li class="Bias"> #Error_detector_realy_setting    Error in setting any the relay
        <li class="Bias"> #Final_bias_diff_not_accurate_0 (its value is 0) for detector bias setting out of tolerance CH0
        <li class="Bias"> #Final_bias_diff_not_accurate_1 for detector bias setting out of tolerance CH1
        <li class="Bias"> #Final_bias_diff_not_accurate_2 for detector bias setting out of tolerance CH2
        <li class="Bias"> #Final_bias_diff_not_accurate_3 for detector bias setting out of tolerance CH3
        <li class="Bias"> #Final_bias_diff_not_accurate_4 for detector bias setting out of tolerance CH4
        <li class="Bias"> #Final_bias_diff_not_accurate_5 for detector bias setting out of tolerance CH5
    </ul>
</td>
</tr>
<tr><td> Final positive bias out of tolerance    </td>
<td>
<span style="color:red;"> Da implementare</span>
  <ul>
        <li class="Bias"> #Final_bias_pos_not_accurate_0 for positive detector bias setting out of tolerance CH0
        <li class="Bias"> #Final_bias_pos_not_accurate_1 for positive detector bias setting out of tolerance CH1
        <li class="Bias"> #Final_bias_pos_not_accurate_2 for positive detector bias setting out of tolerance CH2
        <li class="Bias"> #Final_bias_pos_not_accurate_3 for positive detector bias setting out of tolerance CH3
        <li class="Bias"> #Final_bias_pos_not_accurate_4 for positive detector bias setting out of tolerance CH4
        <li class="Bias"> #Final_bias_pos_not_accurate_5 for positive detector bias setting out of tolerance CH5
    </ul>
</td>
</tr>
<tr><td> Final negative bias out of tolerance    </td>
<td>
<span style="color:red;"> Da implementare</span> 
  <ul>
        <li class="Bias"> #Final_bias_neg_not_accurate_0 for negative detector bias setting out of tolerance CH0
        <li class="Bias"> #Final_bias_neg_not_accurate_1 for negative detector bias setting out of tolerance CH1
        <li class="Bias"> #Final_bias_neg_not_accurate_2 for negative detector bias setting out of tolerance CH2
        <li class="Bias"> #Final_bias_neg_not_accurate_3 for negative detector bias setting out of tolerance CH3
        <li class="Bias"> #Final_bias_neg_not_accurate_4 for negative detector bias setting out of tolerance CH4
        <li class="Bias"> #Final_bias_neg_not_accurate_5 for negative detector bias setting out of tolerance CH5
        <li class="Bias"> #Detector_bias_slopes_not_available       since one or more channels have not the slope set
    </ul>
</td>
</tr>
<tr><td> Slopes not available    </td>
<td>
  <ul>
        <li class="Bias"> #Detector_bias_slopes_not_available       since one or more channels have not the slope set
    </ul>
</td>
</tr>
</table>
 
\n
 
*\section error_managing_functions  Error managing functions
<hr width="90%" size="10" align="left">
The user makes use of the function instr_ERROR_inspection_function() which is passed a parameter, via \b Byte6
of the CAN instruction, tha can take one of the following 4 values:
 
-# : this case the returned parameter is the address of the register where the last error has been detected;
-# : the content of the register queried in the instruction is sent back;
-# : the errors are all reset;
-# : the state of the immidieate echos of errors, when verified. Note that the echos can be set ON or OFF by 
instr_ERROR_echo_on_off_function() via CAN bus.
 
 
As an example, to verify the presence of negative bias adjustment error for CH2 we test true:
\code{.c}
Post_frontend_errors[error_address_Bias_adjustment] & ( 1 << Final_bias_pos_not_accurate_2)
\endcode 
 
 
*\section error_anatomy  Anatomy of errors
<hr width="90%" size="10" align="left">
 
There are 4 functions that are used in the fw to manage the errors:
-# The first allows to set the error in the register; it is  ERROR_codifica_errore() 
with input parameters: <i> uint8_t scheda_su_scheda_giu, unsigned char error_addres, 
unsigned char code_to_shift, uint8_t reset_count_se_0</i>
in which <b><i> error_addres </i></b> is the address of the register, see sub-section \ref indirizzi, while <b><i> code_to_shift </i></b> is the position of the 
flag to set whitihn the register, 
see for this case the sub-section \ref flags. Here an axample of its use:
\snippet I2C_mux.c error_example
Note that ERROR_codifica_errore() set the flag whithin the register, but does not veirfy if the error has been
generated. In the above example the presence of error is marked by #Error_bad_operation when different from zero.
\n #Error_bad_operation is located whithin I2C_0_SignalEvent_t(), I2C_1_SignalEvent_t(), SPI_callback() 
to mark communication errors.
\n #Error_bad_operation is not the only parameter to test for errors. As an instance, with CAN bus this
other way is used:
\snippet Preamplifier_Offset_Drift_Correcttion.c  CAN error marker
-# The second function is store_errors() that serves to push the whole registers. 
-# Then, the function restore_errors() pop's the whole regsiters.
-# The function Error_imposta_la_istruzione() has to be located at the end of every instruction function to mark the error at Byte5, if present. If there is an error it 
sets the value 0xff at Byte5, if Byte5 is different from 0xff, otherwise it sets 0xfa.
 
 
<hr width="90%" size="10" align="left">
\sa The instructions to manage errors via CAN bus are \ref instr_ERROR_inspection_option "instr_ERROR_inspection" and
\ref instr_ERROR_echo_on_off_option "instr_ERROR_echo_on_off".
 
 */
 
#include "tutti_gli_header.h"
 
volatile unsigned int flag_error_verified=0;                        //! Alla verifica di un qualsiasi errore questo flag viene incrementato, 0 implica nessun errore
volatile unsigned int flag_error_verified_at_startup=0;     //! Alla verifica di un qualsiasi errore allo startup questo flag viene posto ad 1, 0 altrimenti
volatile unsigned char  flag_error_acknowledged=0 ;             //! Il flag di errore veirifcato e tutti gli errori vengono resettati perch\'e acquisiti
volatile unsigned char last_error_address=0;                        //! The address of the last verified error
volatile unsigned char last_code_to_shift=0;                        //! The shift bit of the last error
volatile unsigned char last_error_address_at_startup=0;  //! The address of the last verified error
volatile unsigned char last_code_to_shift_at_startup=0;  //! The shift bit of the last error
volatile unsigned char can_send_error=0;                                //! Error are notified via can if =1; not notified if =0
 
 
 // Post_frontend_errors is a vector that account of all the possible errors that can take place. 
 //Every element of this vector referes to a subject. Every bit of the element individuates the error.
 // The subjects, the indexes, are liste below.
 //! \snippet Error_handling.c vec_Post_frontend_errors
//! <!-- [vec_Post_frontend_errors] -->
 unsigned int Post_frontend_errors[error_number_of_errors_registers+error_offset_for_board_up];  ///< Vector that lists the flag registers. 
                                                            //First half for board down, second half for board up
//! <!-- [vec_Post_frontend_errors] -->                                                 ///
 unsigned int Post_frontend_errors_copy[error_number_of_errors_registers+error_offset_for_board_up]; ///< Copy of #Post_frontend_errors, the vector that lists the flag registers
                                                                                                    ///
volatile uint32_t Error_good_operation;
volatile uint32_t Error_bad_operation;  //!< this is a global variable present in all the communication interrupt functions, I2C, SPI,...
                                                                                //!< exploited to mark the errors
 
 char flag_error_verified_vecchio;
 unsigned char  last_error_address_vecchio;
 
#define usa_la_struttura
//      #undef  usa_la_struttura
 
 #ifdef usa_la_struttura
 
//error_definition_def      error_register_per_flag_ADC[5]={"ADC not responding to SPI",                                                                //0
//                                                                                                          "ADC RDY pin not responding to measure",                                         //1
//                                                                                                          "VREF out of tolerance",                                                                        //2
//                                                                                                          "errore 4",
//                                                                                                          "errore 5"
//                                                                                                      }; 
 
//all_errors_def  all_errors[]={
//                                                          "errore 1",
//                                                          "errore 2",
//                                                          "errore 3",
//                                                          "errore 4",
//                                                          "errore 5"
//};
    
/*! \brief If an error is found its flag is codified here. 
 
The errors are 32 bit flag regsiters. The bits that are 1 indicates that the corresponding error was verified.
*\param[in] scheda_su_scheda_giu :  0 if down board, 1 if up board
*\param[in] error_addres         : is the address of the register where the flag is found. The address to be passed is that of the down board. 
                                                                 The actual address is dependent on the scheda_su_scheda_giu value;
*\param[in] code_to_shift        : is the posistion of the error flag within the register;
*\param[in] reset_count_se_0     : if 0 a rest of all errors is done and the registration of errors starts from now
 
*\return No params
 
*\snippet Error_handling.c fun_ERROR_codifica_errore
*/
//! <!-- [fun_ERROR_codifica_errore] -->
void ERROR_codifica_errore(uint8_t scheda_su_scheda_giu, unsigned char error_addres, unsigned char   code_to_shift, uint8_t reset_count_se_0 ){
    //if error_addres is >= error_number_of_errors_registers nothing is done, but the reset, if reset_count_se_0 is =0
    uint8_t iii, buffer_instruction[8],actual_error_address=error_addres;
    if(scheda_su_scheda_giu) actual_error_address=error_addres + error_offset_for_board_up;
//  if (scheda_su_scheda_giu) scheda_su_scheda_giu=1;
//  error_addres += scheda_su_scheda_giu;
 
        if( reset_count_se_0 ==0){ // Verifichiamo solo gli errori che capitano da ora.
            store_errors();
            Error_bad_operation=0;
            Error_good_operation=0;
            flag_error_verified=0;
            last_error_address=0;
            Post_frontend_errors[actual_error_address]=0;
        }
        if (( code_to_shift ==0) && ( (error_address_I2C0 == error_addres) | (error_addres == error_address_I2C1) | (error_addres == error_address_SPI) )){
            __NOP();
        }else {
        if( reset_count_se_0 > 0 ){     //if error_addres is >= error_number_of_errors_registers nothing is 
                                    //done, but the reset, if reset_count_se_0 is =0
                if (~( Post_frontend_errors[actual_error_address] & (1 << code_to_shift))) //Error is set only if it happens for the first time
                {       
                    Post_frontend_errors[actual_error_address] |= (1 << code_to_shift);
                    flag_error_verified++;
                    last_error_address= actual_error_address ;
                    last_code_to_shift=code_to_shift;
                }
                if (can_send_error) {
                        for( iii=0;iii<8;iii++){
                            buffer_instruction[iii]=tx_data[iii];
                        }
                        tx_data[5]=  actual_error_address; //The register where the error is confined
                        tx_data[6]= 1; //This must be "1" and says that the node voltage read must be returned here
                        tx_data[7]=  instr_ERROR_echo_on_off ;  //instr code
                        tx_msg_info.id = ARM_CAN_EXTENDED_ID(indirizzo_CAN_della_scheda);
                        CANdrv->MessageSend(tx_obj_idx, &tx_msg_info, tx_data, 8U);//msg to CAN back to the control room
                        Aspetta_tanti_ms(100); //From here we wait the answer or generate an error
                        for( iii=0;iii<8;iii++){
                            tx_data[iii]=buffer_instruction[iii];
                        }
                    }
            }
        }
}
//! <!-- [fun_ERROR_codifica_errore] -->
 
/*! \brief The state of the errors can be verified/reset
*\param[in] what_to_answer 
\n 1: the answer is error present/not present, 
\n 2: the error regsister indicated in data[0] of CANbus message is sent, 
\n 3: reset all errors, 
\n 4: the state of echo of errors, ON/OFF.
*\return is according to the requested action: last_error_address, error_register, can_send_error, the echo state ON/OFF
 
*\snippet Error_handling.c fun_instr_ERROR_inspection_function
*/
//! <!-- [fun_instr_ERROR_inspection_function] -->
void instr_ERROR_inspection_function ( void){
    char ii;
    volatile uint8_t  istruzione = vettore_istruzioni[6];
    #define check_for_presence_of_erros ( uint8_t) 1
    #define send_back_the_register ( uint8_t) 2
    #define reste_all_errors ( uint8_t) 3
    #define quering_echo_on_or_off ( uint8_t) 4
    
    switch (istruzione & 0x7F){
        case check_for_presence_of_erros:
            tx_data[0]= last_error_address  ;
            tx_data[1]=  flag_error_verified;
        break;
        case send_back_the_register:
            tx_data[5]= rx_data[0];
            tx_data[0]= (Post_frontend_errors[tx_data[5]]>>0) & 0xff;
            tx_data[1]= (Post_frontend_errors[tx_data[5]]>>8) & 0xff;
            tx_data[2]= (Post_frontend_errors[tx_data[5]]>>16) & 0xff;
            tx_data[3]= (Post_frontend_errors[tx_data[5]]>>24) & 0xff;
        break;
        case reste_all_errors:
            flag_error_verified=0;
            flag_error_verified_at_startup=0;
            last_error_address=0;
            for (ii=0; ii<error_number_of_errors_registers+error_offset_for_board_up; ii++)
            {
                Post_frontend_errors[ii] = 0;
            }       
        break;
        case  quering_echo_on_or_off:
            tx_data[0]= can_send_error;
        break;      
    }
}
//! <!-- [fun_instr_ERROR_inspection_function] -->
 
 
 
/*! \brief Copy all errors in a buffer
*\No_par
 
*\snippet Error_handling.c fun_store_errors
*/
//! <!-- [fun_store_errors] -->
void store_errors (void){
    uint8_t i;
    flag_error_verified_vecchio += flag_error_verified;
    last_error_address_vecchio = last_error_address;
    flag_error_verified = 0;
    for (i=0; i<error_number_of_errors_registers; i++)
    {
        Post_frontend_errors_copy[i] |= Post_frontend_errors[i];
    }
}
//! <!-- [fun_store_errors] -->
 
/*! \brief Re-store all errors from the buffer
*\No_par
*\snippet Error_handling.c fun_restore_errors
*/
//! <!-- [fun_restore_errors] -->
void restore_errors (void){
    uint8_t ii;
    
    for (ii=0; ii<error_number_of_errors_registers; ii++)
    {
        Post_frontend_errors[ii] = Post_frontend_errors_copy[ii];
    }
    flag_error_verified = flag_error_verified_vecchio;
    last_error_address = last_error_address_vecchio;
}
//! <!-- [fun_restore_errors] -->
 
 
/*! \brief Immediate echos of a verified error activated/disattivated.
*\param[in] channel_input 
\n 0: errors are not notified on the CAN when they happen; 
\n 1: errors are notified immidiately by a can message when they happen
*\retval can_send_error the replica of the inp
 
*\snippet Error_handling.c fun_instr_ERROR_echo_on_off_function
*/
//! <!-- [fun_instr_ERROR_echo_on_off_function] -->
void instr_ERROR_echo_on_off_function (void)
{
if ( vettore_istruzioni[0]){
        can_send_error =1;
}else{
        can_send_error=0;
}   
 
}
//! <!-- [fun_instr_ERROR_echo_on_off_function] -->
 
/*! \brief Function to be located at the end of every instruction to mark the error, if any
*\retval marking of byte5 of the CAN replica
 
*\snippet Error_handling.c fun_Error_imposta_la_isturzione
*/
//! <!-- [fun_Error_imposta_la_isturzione] -->
void Error_imposta_la_istruzione(void){
            if(flag_error_verified){
            if( tx_data[5]==255){
                tx_data[5]=250;
            }else{
                tx_data[5]= 255;
            }
        }
}
//! <!-- [fun_Error_imposta_la_isturzione] --> 
 
#endif