microcontrollore non riesce a malloc

Question

Sto scrivendo una funzione su un microcontrollore a corteccia m4 a 32 bit. La funzione deve essere in grado di moltiplicare matrici di dimensioni diverse, che non posso prevedere. Quindi devo usare una malloc ...

Ma io non capisco perché il mio mc va sempre in interrupt gestore predefinito quando si esegue seguente riga:

double *output2=NULL; 
output2 = malloc(3 *1* sizeof(double *)); 

Non è questo mc grado di gestire questo tipo di operazioni? Mentre funziona perfettamente sul mio portatile!

** EDIT *

Qui da qualche altro codice (che deve ancora essere modificato ...): Bene tutti malocs ovunque fallire. Non posso assegnare alcun valore a una matrice "malloced".

int main (void) 
{ 

    /*some stuff*/ 

    float transFRotMatrix[3][3]={0}; //array gets modified by other functions 
    float sunMeasurements[3][1] = {{1},{2},{3}}; //test values 

     multiplyMatrices(&transFRotMatrix[0][0],3, 3, &sunMeasurements[0][0], 3, 1, *orbitalSunVector); 

    /*some stuff*/ 
} 

void multiplyMatrices(float *transposedMatrix, int height1, int width1, float *iSunVector,int height2, int width2, float *orbitalSunVector) 
{ 

    int y=0; 
    int x = 0; 
    int row=0; 
    int column =0; 
    int k=0; 
    int k2 = 0; 
    float result = 0; 

    int i=0; 
    int j=0; 
    int t=0; 

    float rotationMatrix[3][3]={0}; 

    i=0; 
    k=0; 
    k2 = 0; 


    if(width1 != height2) 
    { 
     printf("unmatching matrices, error.\n\n"); 
     return; 
    } 

    float *output2; 

    output2 = malloc(3 *1* sizeof(float *)); //<-----ERROR 


    while(k<width1) //aantal rijen 1ste matrix 
    { 
     for(j=0;j<height2;j++) //aantal rijen 2de matrix 
     { 
      result += (*((transposedMatrix+k*width1)+j)) * (*((iSunVector+j*width2)+k2)); //1ste var:aantal kolommen 2de matrix --2de variabele na de plus = aantal kolommen 2de matrix 
      //printf("%f * %f\t + ", (*((transposedMatrix+k*width1)+j)), (*((iSunVector+j*width2)+k2))); 
     } 

     output2[k*3 +k2] = result; //<-----FAILS HERE 


     k2++; 
     x++; 
     column++; 

     if(x==width2) 
     { 
      k2=0; 
      x=0; 
      column=0; 
      row++; 
      y++; 
      k++; 

     } 
     result = 0; 

    } 

    for(i=0;i<height1;i++) 
    { 
     for(j=0;j<width2;j++) 
     { 
      orbitalSunVector[j * height1 + i] = output2[i*3 +j]; 
     } 
    } 
    free(output2); 
} 

Answer 1

Il malloc() funziona correttamente nell'altra parte di questo codice? Durante la programmazione di un dispositivo incorporato, l'heap potrebbe non essere stato inizializzato correttamente oppure è stato inizializzato per un'altra funzione personalizzata di tipo malloc() -like.

Answer 2

Ci sono due tipi validi di implementazioni in C: ospitato e freestanding. I programmi scritti per le implementazioni ospitate possono utilizzare qualsiasi intestazione di libreria standard. Tuttavia, le implementazioni indipendenti sono richiesti solo per supportare <float.h>, <iso646.h>, <limits.h>, <stdalign.h>, <stdarg.h>, <stdbool.h>, <stddef.h>, <stdint.h> e <stdnoreturn.h>.

Non è raro che i microcontrollori abbiano un supporto minimo, quindi forse il compilatore C (o meglio la libreria standard) non ha il pieno supporto per <stdlib.h> (e quindi malloc). Tuttavia, senza sapere quale compilatore e libreria standard hai scelto di utilizzare, è solo un'ipotesi.

È anche possibile che, come suggeriscono i commenti per la tua domanda, qualcosa di prima (e/o successivo) di questo pezzo di codice sia da biasimare. Forse potresti produrre un mcve?

Non esitate a commentare sotto questa risposta quando avete aggiornato per dare ulteriori informazioni, e sarò felice di elaborare per fornire ulteriori informazioni.

Answer 3

Quello che hai ricevuto era un'eccezione del processore, non un interrupt. Sono tutti mappati allo stesso gestore che è una pratica comune. Suppongo che tu abbia un guasto all'hardware. È possibile controllare i registri per vedere cosa ha causato l'eccezione. Utilizzare this code come riferimento per esaminarli. Potrebbe essere correlato all'implementazione della libc se l'eccezione si verifica all'interno di malloc.