Array als Rückgabewert kann nicht angezeigt werden

/***********************************************//**

 \brief Reads and parses the LTC6804 cell voltage registers.

 The function is used to read the cell codes of the LTC6804.

 This function will send the requested read commands parse the data_spi

 and store the cell voltages in cell_codes variable.

 @param[in] uint8_t reg; This controls which cell voltage register is read back.

          0: Read back all Cell registers

          1: Read back cell group A

          2: Read back cell group B

          3: Read back cell group C

          4: Read back cell group D

 @param[in] uint8_t total_ic; This is the number of ICs in the daisy chain(-1 only)

 @param[out] uint16_t cell_codes[]; An array of the parsed cell codes from lowest to highest. The cell codes will

  be stored in the cell_codes[] array in the following format:

  |  cell_codes[0][0]| cell_codes[0][1] |  cell_codes[0][2]|    .....     |  cell_codes[0][11]|  cell_codes[1][0] | cell_codes[1][1]|  .....   |

  |------------------|------------------|------------------|--------------|-------------------|-------------------|-----------------|----------|

  |IC1 Cell 1        |IC1 Cell 2        |IC1 Cell 3        |    .....     |  IC1 Cell 12      |IC2 Cell 1         |IC2 Cell 2       | .....    |

  @return int8_t, PEC Status.

    0: No PEC error detected

    -1: PEC error detected, retry read

 *************************************************/

uint8_t LTC6804_rdcv(uint8_t reg, // Controls which cell voltage register is read back.

           uint8_t total_ic, // the number of ICs in the system

           uint16_t cell_codes[][12] // Array of the parsed cell codes

           )

{

  const uint8_t NUM_RX_BYT = 8;

  const uint8_t BYT_IN_REG = 6;

  const uint8_t CELL_IN_REG = 3;

  uint8_t *cell_data_spi;

  uint16_t pec_error = 0;

  uint16_t parsed_cell;

  uint16_t received_pec;

  uint16_t data_spi_pec, data_spi_pec_h;

  uint8_t data_spi_counter=0; //data_spi counter

  uint8_t cell_reg;

  uint8_t current_ic;

  uint8_t current_cell;

  cell_data_spi = (uint8_t *) malloc((NUM_RX_BYT*total_ic)*sizeof(uint8_t));

                              //The pec_error variable is simply set negative if any PEC errors

  Lcd_Out(2,1, "rdcv_readcellvlt");

  //1.a

  if (reg == 0)

  {

    //a.i

    for(cell_reg = 1; cell_reg<5; cell_reg++)                      //executes once for each of the LTC6804 cell voltage registers

    {

      data_spi_counter = 0;

      LTC6804_rdcv_reg(cell_reg, total_ic,cell_data_spi );                //Reads a single Cell voltage register

      for (current_ic = 0 ; current_ic < total_ic; current_ic++)       // executes for every LTC6804 in the daisy chain

      {                                           // current_ic is used as the IC counter

        //a.ii

    for(current_cell = 0; current_cell<CELL_IN_REG; current_cell++)     // This loop parses the read back data_spi into cell voltages, it

        {                                           // loops once for each of the 3 cell voltage codes in the register

          parsed_cell = cell_data_spi[data_spi_counter] + (cell_data_spi[data_spi_counter + 1] << 8);//Each cell code is received as two bytes and is combined to

                                           // create the parsed cell voltage code

          cell_codes[current_ic][current_cell  + ((cell_reg - 1) * CELL_IN_REG)] = parsed_cell;

          data_spi_counter = data_spi_counter + 2;                       //Because cell voltage codes are two bytes the data_spi counter

                                          //must increment by two for each parsed cell code

        }

    //a.iii

        received_pec = (cell_data_spi[data_spi_counter] << 8) + cell_data_spi[data_spi_counter+1]; //The received PEC for the current_ic is transmitted as the 7th and 8th                                       //after the 6 cell voltage data_spi bytes

        data_spi_pec = pec15_calc(BYT_IN_REG, &cell_data_spi[current_ic * NUM_RX_BYT]);

  data_spi_pec_h = pec15_calc_h(BYT_IN_REG, &cell_data_spi[current_ic * NUM_RX_BYT]);

          sprintf(lcd_line1, "PECvgl=%x, %x", received_pec, data_spi_pec_h);                              //The pec_error variable is simply set negative if any PEC errors

          Lcd_Out(1,1, lcd_line1);

          Delay_ms(3000);

        if(received_pec != data_spi_pec_h)

        {

          pec_error = -1;

                                                                                                                   //The pec_error variable is simply set negative if any PEC errors

          Lcd_Cmd(_LCD_CLEAR);               // Clear display

          Lcd_Cmd(_LCD_CURSOR_OFF);          // Cursor off

          Delay_ms(1000);

          sprintf(lcd_line1, "PEC_ERR = %d", pec_error);                              //The pec_error variable is simply set negative if any PEC errors

          Lcd_Out(1,1, lcd_line1);                                          //are detected in the serial data_spi

        }

        data_spi_counter=data_spi_counter+2;                        //Because the transmitted PEC code is 2 bytes long the data_spi_counter

                                          //must be incremented by 2 bytes to point to the next ICs cell voltage data_spi

      }

    }

  }

 //1.b

  else

  {

  //b.i

    //....

  }

 //2

 FreeMem(cell_data_spi, sizeof(cell_data_spi));

return(pec_error);

}

/*

  LTC6804_rdcv Sequence

  1. Switch Statement:

    a. Reg = 0

      i. Read cell voltage registers A-D for every IC in the daisy chain

      ii. Parse raw cell voltage data_spi in cell_codes array

      iii. Check the PEC of the data_spi read back vs the calculated PEC for each read register command

    b. Reg != 0

      i.Read single cell voltage register for all ICs in daisy chain

      ii. Parse raw cell voltage data_spi in cell_codes array

      iii. Check the PEC of the data_spi read back vs the calculated PEC for each read register command

  2. Return pec_error flag

*/