IMPLEMENTAZIONE DYNAMIC TIME WARPING

No,credo che intenda che da risultati diverso tra arduino e un programma linux compilato su linux con lo stesso sorgente

Ostia, nianche il tempo di rispondere....

Bartolla: Stesso identico codice, usando printf invece che serial.print perchè in arduino uso il monitor seriale. Su linux mi da i valori esatti. Posso postare anche quello se può essere utile..

Su Windows e Linux presumo hai 2 IDE Arduino con versioni diverse. Versioni diverse = toolchain diverse. Ma non saprei come potrebbe influire sui risultati.

No Nid, su Linux gira nativo nell’OS e stampa sulla console, su Win ha l’IDE e lo carica su Arduino …
… almeno così pare di capire da qualto scrive ::slight_smile:

Guglielmo

Ahhh, ora ho capito.
@Bartolla ma con che compilatore ? Il linguaggio è lo stesso ma a seconda del processore su cui gira il programma ci sono considerazioni diverse da fare.
Gli int ad esempio su Arduino (MCU a 8 bits) sono 2 bytes, mentre su Linux, con compilatore a 64 bits potrebbero essere a 4 bytes. Di solito si preferisce usare il tipo int8_t o int16_t per essere sicuri della dimensione del valore. Basta che fai una printf di sizeof(int) su Linux
Inoltre su Arduino hai solo 2Kb di SRAM e se la consumi tutta nessuno ti avvisa e puoi ottenere risultati “strani”

In ogni caso penso che dovrò provarlo su una scheda "migliore".. Grazie mille a tutti davvero! :D :D

Se ci posti cosa dovrebbe uscire, io magari stasera ci guardo....

Così. A titolo di curiosità personale

un vettore da 5 elementi, per la precisione {0, 1, 1, 3, 2} :)

Allora non ci siamo:

primo tu fai una serial.print all'interno di DUE cicli for

quindi devi avere un numero di risultati pari alla dimensione del primo PER la dimensione del secondo ovvero in questo caso 16

ammennocche tu non ti sia dimenticata di chiudere una for, per l'esattezza la penultima

nel caso stamperesti una sola volta e non 4 e questo spiega anche come mai ti mancava una graffa alla fine

adesso provo la modifica

comunque se lo devi eseguire una volta solo lo metti nella setup, e lasci la loop vuota

la ragione per cui non vedi nulla in uscita (almeno a me dopo compilaziojne del tuo codice non stampava) è che fermi il programma con una return (0) e non flussi il bufffer seriale

stay tuned per la prossima prova

Ok, restituisce:

riga: 8 colonna: 0 memoria libera: 1442 risultato: 1 riga: 8 colonna: 1 memoria libera: 1442 risultato: 22511 riga: 8 colonna: 2 memoria libera: 1442 risultato: -4 riga: 8 colonna: 3 memoria libera: 1442 risultato: -5 riga: 8 colonna: 4 memoria libera: 1442 risultato: 0

noterai che ho fatto stampare colonna, riga, memoria libera e risultato

questo ci assicura che la memoria libera è ampiamente sufficiente

peraltro con solo 5 per 8 interi..............

adesso non ti offendere, ma la domanda è d'obbligo:

ma sei sicura che il programma che hai postato sia proprio uguale a quello che hai su linux?

perché abbiamo già trovato qualche discrepanza non da poco.............

per cortesia controlla e posta il SORGENTE del programma in C di linux

che a tradurlo in Arduino ci penso io

A questo punto inizio ad avere un po’ di dubbi che sia giusto…su linux i vettori A e B sono creati diversamente.

#include <stdio.h>

#include <stdlib.h>




#define col 5

#define row 8


/* funzione per calcolare il minimo relativo all'ultima colonna */



int row_val_min(int *vec){

	
  int rowmin=0;
	
  for(int i=1; i<row; i++){
		
		
    if(vec[i]<0)
			
       vec[i] = -vec[i];  //Normalizzazione vettore
	
		
    if( vec[i] < vec[i-1] )
			
       rowmin = i;
	
 }
	
	
 return rowmin;

}

/* funzione per calcolare il velore minimo della colonna successiva, nella riga più prossima a quella della colonna precendente


int row_val_min_next(int *vec_next, int rowmin_prec){

   
int rowmin_next = rowmin_prec-1;
	
		
     for(int i=rowmin_prec; i<rowmin_prec+2; i++){
			
       if(vec_next[i] < vec_next[i-1])
				
         rowmin_next = i;
     }

   
return rowmin_next;

}









int main(int argc, char *argv[]){           //Void Loop su arduino
  
int *A = (int *)calloc(5, sizeof(int));

  int *B = (int *)calloc(8, sizeof(int));


  A[0] = 1;
 A[1] = 2;
 A[2] = 6;
 A[3] = 7;
 A[4] = 9;
 
 
  B[0] = 2;
 B[1] = 3; 
 B[2] = 5; 
 B[3] = 7;
 B[4] = 8;
 B[5] = 9;
 B[6] = 11;
 B[7] = 13;


	
  
int **Dist = (int **)calloc(16, sizeof(int));
	
  for(int i=0; i<row; i++){
		
    Dist[i] = (int *)calloc(10, sizeof(int));
	
  }
	
	

	
  for(int i=0; i<8; i++){
		
    for(int j=0; j<col; j++){
			
			
      Dist[i][j] = B[i] - A[j];
		 	
      printf("\t%d ", Dist[i][j]);
		// stampa la matrice delle distanze
    }
		
  printf("\n");
	
  }

	
	
int *colonna = (int *)calloc(row ,sizeof(int));                                 //Alloco memoria per copiare la colonna di Dist[row][col] 
	
int *riga_ottima = (int *)calloc(1, sizeof(int));                                //Alloco memoria per risultato temporaneo della riga ottima
	
int *percorso_minimo = (int *)calloc(col, sizeof(int));                 //Alloco memoria per vettore contenente righe ottime
	
int *valori_percorso_minimo = (int *)calloc(col, sizeof(int));    //Alloco memoria per vettore contenente valori ottimi
	 
	 
	 

int j = col-1;                                          
		
for(int i=0; i<row; i++){       //Copi ultima colonna
			
  colonna[i] = Dist[i][j];
		
}
		
		

*riga_ottima = row_val_min(colonna);          	//Salvi la riga ottima dell'ultima colonna		
		
percorso_minimo[j] = *riga_ottima;		//Copio questo valore nel vettore		

		
		
		
		
																		
		
for(int j=col-2; j>=0; j--){
			
			
  for(int i=0; i<row; i++){		//Copiamo colonna di Dist[row][j] e analizziamo ogni colonna singolarmente a partire da col-2
				
    colonna[i] = Dist[i][j];						
			
  }
			
  percorso_minimo[j] = *riga_ottima = row_val_min_next(colonna, *riga_ottima);	//Valutiamo la riga ottima di ogni colonna		
		
}								//più vicina al risultato della colonna precedente
	
																	   
for(int column=0; column<col; column++){
		
			
  valori_percorso_minimo[column] = Dist[ percorso_minimo[column] ][column];	//Copiamo i valori del warping path
			
  printf("\n\t Valore minimo alla colonna %d:   %d", column, valori_percorso_minimo[column]);
    // stampa la colonna e il valore minimo corrispondente
}	
printf("\n\n\n");
	


/* libera la memoria */		
	
	
	
free(riga_ottima);   			
free(Dist);			
	
free(percorso_minimo); 
	


return 0;

}

Okei, mettendolo nel setup e togliendo l'exit stampa tutti i valori!! solo che stampa il vettore al contrario, ovvero restituisce {2,3,1,1,0} invece che {0,1,1,3,2} (e stampa anche 2 quadratini all'inizio)

No, son creati uguali

int *A = (int *)calloc(5, sizeof(int));

intero *A è il puntatore a intero assegnato uguale a un'area di memoria di dimensioni tali da contenere 5 interi (castata come puntatore)

poi gli elementi vengono inizializzati.......

comunque è certo che c'è un po' di casino coi puntatori e i loro tipi

se dichiari A (e B) come int A[] i valori resi cambiano, e non dovrebbero c'è un puntatore a intero che viene usato come puntatore a byte o qualcosa di simile

adesso devo uscire, ma quando torno cerco di trovare il tempo di andare avanti

Ci sono riuscita!!! funziona, stampa il vettore correttamente! Grazie mille!! :)

ottimo, posta che imparo anch'io

Eccolo

#define col 5
#define row 8

byte A[col] = { 1, 2, 6, 7, 9};                 // vettore A, sequenza di riferimento
byte B[row] = { 2, 3, 5, 7, 8, 9, 11, 13};      // vettore B, sequenza da comparare a quella di riferimento

/* funzione per calcolare il minimo relativo all'ultima colonna */

int row_val_min(int *vec) {
  int rowmin = 0;
  for (int i = 1; i < row; i++) {
    if (vec[i] < 0)
      vec[i] = -vec[i];  //Normalizzazione vettore
    if ( vec[i] < vec[i - 1] )
      rowmin = i;
  }
  return rowmin;
}

/* funzione per calcolare il velore minimo della colonna successiva, nella riga più prossima
  a quella corrispondente al minimo della colonna precendente */

int row_val_min_next(int *vec_next, int rowmin_prec) {
  int rowmin_next = rowmin_prec - 1;
  for (int i = rowmin_prec; i < rowmin_prec + 2; i++) {
    if (vec_next[i] < vec_next[i - 1])
      rowmin_next = i;
  }
  return rowmin_next;
}

void setup() {
  Serial.begin(19200); // inizializza la comunicazione seriale a 19200 bps
  Serial.flush();     // aspetta che sia completata la trasmissione seriale dei dati
   int **Dist = (int **)calloc(16, sizeof(int));
  for (int i = 0; i < row; i++) {
    Dist[i] = (int *)calloc(10, sizeof(int));
  }

  /* Creazione della matrice delle distanze */
  for (int i = 0; i < 8; i++) {
    for (int j = 0; j < col; j++) {
      Dist[i][j] = B[i] - A[j];
    }
  }

  int *colonna = (int *)calloc(row , sizeof(int));                  //Alloco memoria per copiare la colonna di Dist[row][col]
  int *riga_ottima = (int *)calloc(1, sizeof(int));                 //Alloco memoria per risultato temporaneo della riga ottima
  int *percorso_minimo = (int *)calloc(col, sizeof(int));           //Alloco memoria per vettore contenente righe ottime, warping path
  int *valori_percorso_minimo = (int *)calloc(col, sizeof(int));    //Alloco memoria per vettore contenente valori ottimi


  int j = col - 1;                //considera solo l'ultima colonna
  for (int i = 0; i < row; i++) { //Copia l'ultima colonna nel vettore colonna[i]
    colonna[i] = Dist[i][j];
  }

  *riga_ottima = row_val_min(colonna);            //Salva la riga ottima dell'ultima colonna
  percorso_minimo[j] = *riga_ottima;              //Copia questo valore nel vettore percorso_minimo[j]


  for (int j = col - 2; j >= 0; j--) { // partendo dalla penultima colonna
    for (int i = 0; i < row; i++) { //copia la colonna di Dist nel vettore colonna[i], per poi analizzare ogni colonna singolarmente
      colonna[i] = Dist[i][j];
    }
    *riga_ottima = row_val_min_next(colonna, *riga_ottima);  //Valuta la riga ottima di ogni colonna più vicina al risultato della colonna precedente
    percorso_minimo[j] = *riga_ottima;                       // salva i valori delle righe ottime calcolati dalla funzione row_val_min_next
  }

  for (int column = col - 1 ; column >= 0; column--) {
    valori_percorso_minimo[column] = Dist[percorso_minimo[column]][column];     //Copia i valori del warping path nella variabile valori_percorso_minimo[column]
    Serial.print(valori_percorso_minimo[column]);                               // stampa i valori del warping path, su una stessa riga
  }

}

void loop() {
}

Grazie