ElectroYou - la comunità dei professionisti del mondo elettrico

da **lelerelele** » 12 dic 2015, 20:32

HattoriHanzo ha scritto:Di solito, invece di riprogettare tutto, si passa ad un micro identico con taglio di FLASH superiore.
Se non vado errato il PIC18F25K50 è identico al PIC18F24K50 ma con il doppio di FLASH.
Sarebbe la soluzione migliore e più conveniente.

Perfettamente d'accordo con te. :ok:

Il motivo per cui avrei pensato di passare ad un micro a 16bit è puramente per scopi didattici, infatti le mie realizzazioni "da hobbista" servono solo a me per imparare, e le uso nel piccolo della mia casa. Non avendo ancora preso in mano un micro a 18bit sono curioso, e prendevo la palla al balzo per farmi un po' di esperienza in merito.

Comunque ti ringrazio per la dritta. Ci penserò su.

saluti

da **TardoFreak** » 12 dic 2015, 20:37

Se è per scopo didattico potresti passare direttamente ai 32bit. I PIC32 sono un'ottima scelta perché sono meno complicati degli ARM.
Inoltre la Microchip mette a disposizione parecchio firmware che può essere utilizzato come base di partenza.
I 16bit sono una passo intermedio che si può tranquillamente "saltare".

da **PietroBaima** » 13 dic 2015, 3:45

Quanto vale l'errore massimo che sei disposto a tollerare e quanto vale il range di misura di p/po?
Te lo chiedo perche' si potrebbe trovare facilmente una approssimazione polinomiale a quella formula. Cosi' a naso un terzo o quarto ordine dovrebbero bastare (ne hai da vendere), ma dipende appunto dall'errore massimo che sei disposto ad accettare (tieni conto che anche la tua formula e' piuttosto approssimata e la misura barometrica dell'altezza non e' molto precisa).

Comunque, se mi dai questi dati posso trovarti un polinomio interpolatore che puoi implementare sul micro col metodo di Orchard (se non lo conosci te lo spiego o ti scrivo uno snippet di codice).

Questo metodo permette di valutare un polinomio di ordine n facendo n moltiplicazioni e n somme e si presta bene a essere implementato in virgola fissa.

Se ti bastasse un polinomio, per esempio, di quarto ordine te la caveresti con 4 moltiplicazioni e 4 somme in virgola fissa.

Ciao,
Pietro.

da **lelerelele** » 13 dic 2015, 11:13

HattoriHanzo ha scritto:Se è per scopo didattico potresti passare direttamente ai 32bit.

Grazie mille, lo terrò sicuramente presente nei miei prossimi acquisti, passando ad i pic32.

PietroBaima ha scritto:Quanto vale l'errore massimo che sei disposto a tollerare e quanto vale il range di misura di p/po?
Te lo chiedo perche' si potrebbe trovare facilmente una approssimazione polinomiale a quella formula.

Quanto chiedi è ovviamente molto fuori alla mia portarta, il valore p0=1013.25, il valore di p<80000, p>101320; valori con i quali ottengo circa da ~0 a ~2000mt sul livello del mare.
La precisione non mi interessa un gran che, essendo solo un circuito ad uso personale, mi serve più che altro a fare esperienza in merito.

PietroBaima ha scritto:Comunque, se mi dai questi dati posso trovarti un polinomio interpolatore che puoi implementare sul micro col metodo di Orchard (se non lo conosci te lo spiego o ti scrivo uno snippet di codice).

Questo metodo permette di valutare un polinomio di ordine n facendo n moltiplicazioni e n somme e si presta bene a essere implementato in virgola fissa.

Ovviamente non ho idea di cosa sia, (tanto di cappello per le tue conoscenze, in qualche caso mi rendo conto di essere nessuno).
Il circuito l'ho gia realizzato e funzionante, se hai tempo, senza fretta e senza impegno, riesci a darmi due righe di codice in C che realizzi il calcolo te ne sono grato, mi permette di capire qualcosa in più di matematica e di programmazione in merito, se devo farti perdere tempo non credo ne valga la pena.

Comunque ti ringrazio per la disponibilità.
saluti.

da **paofanello** » 13 dic 2015, 12:10

Scusate l'intrusione O_/

, spero di non disturbare troppo ma l'argomento si fa interessante e vorrei porre alcune domande a

PietroBaima.
Prima di tutto scusami se risulterò confuso o dirò orrori.

PietroBaima ha scritto:Comunque, se mi dai questi dati posso trovarti un polinomio interpolatore che puoi implementare sul micro col metodo di Orchard

Essendo questo nome la traduzione di "frutteto" su internet è possibile farsi una gran cultura in termini di agricoltura e di mele, ma non sono riuscito a trovare nulla di ciò che ci riguarda.
Mi piacerebbe molto quindi se tu potessi un poco illuminarci O:)

Per la ricerca del polinomio mi è capitato sempre e solo di utilizzare lo sviluppo in serie di Taylor, ed ho sempre dato per scontato che si utilizzasse sempre questo al di là di casi particolari, è corretto?
Avendo una pressoché nulla conoscenza di programmazione e microcontrollori (ma che dico? io so usare Arduino °#^

) mi chiedo:
perché consigli l'utilizzo di questo metodo di Orchard? Che problema ha la diretta implementazione di un polinomio di Taylor nel micro? Non porterebbe vantaggi in termini di memoria delle variabili?

da **PietroBaima** » 14 dic 2015, 4:14

Scusate ma posso dedicare un po' di tempo al forum solo ora.

Dunque, cerchiamo di rispondere ad entrambi in un colpo solo.

paofanello ha scritto:Scusate l'intrusione , spero di non disturbare troppo ma l'argomento si fa interessante e vorrei porre alcune domande a PietroBaima.
Prima di tutto scusami se risulterò confuso o dirò orrori.

Non scusarti.
Lo scopo del forum e' proprio quello di porre delle domande e di ricevere delle risposte.
Non preoccuparti della qualita' della domanda, qualunque essa sia sta a me trovare il modo di dire qualcosa di interessante (o almeno, insomma, provarci

)

Ci mancherebbe che una persona che ha una curiosita' debba scusarsi...
Dovrebbero scusarsi coloro che si divertono a fare perdere tempo al forum facendo i troll o semplicemente i somari, come dice

Candy, perche' il tempo che i moderatori perdono nel star loro dietro potrebbero usarlo per rispondere a domande o comunque a fare qualcosa di piu' gradevole.
Anyway, lasciamo perdere, non voglio fare polemiche.

paofanello ha scritto:Mi piacerebbe molto quindi se tu potessi un poco illuminarci

lelerelele ha scritto:Il circuito l'ho gia realizzato e funzionante, se hai tempo, senza fretta e senza impegno, riesci a darmi due righe di codice in C che realizzi il calcolo te ne sono grato, mi permette di capire qualcosa in più di matematica e di programmazione

Va bene, dato che interessa ad entrambi vediamo come funziona il metodo di Orchard (e anche cos'e'

)

paofanello ha scritto:Per la ricerca del polinomio mi è capitato sempre e solo di utilizzare lo sviluppo in serie di Taylor, ed ho sempre dato per scontato che si utilizzasse sempre questo al di là di casi particolari, è corretto?

Mi sa che qui c'e' un poco di confusione.
Allora, Taylor si usa per trovare una approssimazione polinomiale di una certa funzione in un punto stabilito.
Non e' l'unico metodo esistente per approssimare delle funzioni (vedi i vari Bessel, Chebishev, Butterworth e molti altri). Il suo limite piu' grande e' che l'approssimazione e' locale (bisogna trovare un punto dal quale non ci si puo' discostare molto).
In generale, volendo approssimare una funzione, di una certa complessita', in un certo intervallo, con un certo errore massimo, trovare il punto intorno al quale approssimare con Taylor e' molto complicato.
L'idea e' quella di trovare un punto, nell'intervallo, in cui centrare lo sviluppo, per poi allargarlo ad un intorno senza commettere un errore superiore a quello prefissato.

Comunque, nel nostro caso della pressione atmosferica, Taylor va benissimo.

Il metodo di Orchard si utilizza quando si e' gia' trovato il polinomio con un metodo qualunque e serve per valutare quel polinomio in un punto, in modo computazionalmente efficiente.

Supponiamo di avere il polinomio x^2+2x+3

e di doverlo valutare in x=5.
Il primo metodo che ci viene in mente e' quello di elevare al quadrato 5, sommarlo a 5 moltiplicato 2 e infine sommare 3.
Se il polinomio e' di grado elevato bisogna fare elevamenti a potenza con esponenti grandi e questo e' computazionalmente molto gravoso.
Orchard ha inventato un metodo per risolvere questo problema in modo molto efficiente.

Quindi il metodo di Orchard non c'entra col metodo utilizzato per trovare il polinomio.

paofanello ha scritto:perché consigli l'utilizzo di questo metodo di Orchard?

Perche' e' un metodo efficiente.

paofanello ha scritto:Che problema ha la diretta implementazione di un polinomio di Taylor nel micro?

Il polinomio di Taylor in se nessuna, la sua valutazione in un punto e' fonte di guai di complessita' computazionale e, come vedremo anche di guai dal punto di vista del condizionamento del problema.

paofanello ha scritto:Non porterebbe vantaggi in termini di memoria delle variabili?

No, al contrario.

Metodo di Orchard
Supponiamo di voler calcolare il valore di un polinomio P(x) per un certo x assegnato.
Il problema e' quindi calcolare $s=P(\overline{x})$

In generale il polinomio e':

$P(x)=a_n\ x^n+a_{n-1}\ x^{n-1}+a_{n-2}\ x^{n-2}+...+a_2\ x^2+a_1\ x+a_0$

E' possibile scrivere il polinomio in questa forma:

$P(x)=(...((((((a_n\ x+a_{n-1})\ x+a_{n-2})\ x+a_{n-3})\ x+...)\ x+a_1)\ x+a_0$

Per verificarne l'uguaglianza basta notare che il termine a_n

viene moltiplicato per x n volte, mentre $a_{n-1}$ e' moltiplicato per x una volta in meno e cosi' via.

A questo punto e' possibile notare che questo modo di scrivere il polinomio nasconde un metodo iterativo, che posso utilizzare per valutare il polinomio stesso in un punto, assegnando x :

$\left\{\begin{matrix} s_0=a_n\\ s_i=s_{i-1}x+a_{n-i} \end{matrix}\right.$

vediamo cosa succede, "srotolando il ciclo" per un po':

s_0=a_n

$s_1=s_0\ x+a_{n-1}=a_n\ x+a_{n-1}$

$s_2=s_1\ x+a_{n-2}=a_n\ x^2+a_{n-1}\ x+a_{n-2}$

...

alla fine, dopo n passaggi, il polinomio sara' valutato per l'x assegnato, senza fare alcun elevamento a potenza, ma solo n moltiplicazioni !

Esempio:

P(x)=x^5+4x^4-3x^2+8x-3

Codice: Seleziona tutto: unsigned long int Polinom(unsigned long int x) { const int a[]={1,4,0,-3,8,-3}; const char loa=6; unsigned long int s=0; int k=0; for(k=0;k<loa;s=s*x+a[k++]); return (s); }

C'e' ancora un problema, pero'. Il condizionamento numerico.

Quando si approssima una funzione usando un polinomio succede che il termine del grado piu' alto e' piccolo rispetto a quello del grado immediatamente precedente, il quale e' piu' piccolo del termine ancora precedente, e cosi' via...
Questo succede perche' i termini di grado piu' alto del polinomio fungono da "rifiniture" per la funzione, mentre i termini di grado piu' basso ne definiscono la struttura.
Per fare un esempio di vettore a[], potrei per esempio scrivere:
a[]={0.00001,2,89,234}
Fra il primo e l'ultimo termine ci sono diversi ordini di grandezza e questo fa si' che la macchina potrebbe non riuscire a mantenere la precisione durante le moltiplicazioni, generando un ulteriore rumore numerico che potrebbe peggiorare il risultato.
Tenere un vettore bilanciato fa si' che la precisione aumenti.
Questi problemi si chiamano problemi di condizionamento.
Sono problemi che non esisterebbero se si potesse avere una macchina in grado di fare calcoli con una precisione infinita, quindi non si incontrano mai durante il calcolo teorico.

Per risolvere questo problema e' sufficiente correggere il metodo iterativo in questo modo:

$\left\{\begin{matrix} s_0=a_n\\ s_i=s_{i-1}x\ 10^p+a_{n-i} \end{matrix}\right.$

Orchard penso' di introdurre una costante nota 10^p ad ogni iterazione.
Vediamo cosa succede all'algoritmo:

s_0=a_n

$s_1=s_0\ x\ 10^p+a_{n-1}=a_n\ x \ 10^p+a_{n-1}$

$s_2=s_1\ x\ 10^p+a_{n-2}=a_n\ x^2\ 10^{2p}+a_{n-1}\ x 10^p+a_{n-2}$

...

$s_n=a_n\ x^n\ 10^{np}+a_{n-1}\ x^{n-1} 10^{(n-1)p}+...+a_{2}x^2\ 10^{2p}+a_{1}x\ 10^{p}+a_0$

In pratica ogni termine viene moltiplicato per una potenza pari al grado del termine moltiplicata per il p preassegnato.
Se poniamo p=0 torniamo ad avere l'algoritmo precedente, quindi questo ne e' una estensione.

Nell'esempio in cui il vettore a era a[]={0.00001,2,89,234}, se poniamo p=-2, abbiamo il termine di ordine 3 diviso per un milione, quello di ordine 2 diviso per diecimila, quello di ordine 1 diviso per cento. (il termine noto non viene diviso, o meglio, viene diviso per uno).
Per conservare l'uguaglianza il vettore a[] va scritto quindi cosi':
a[]={10,20000,8900,234}

Prima fra termine piu' piccolo e piu' grande c'era un divario di 7 ordini di grandezza, ora di 3.
Il condizionamento del problema e' migliorato, inoltre, usando bene questo trucco, possiamo moltiplicare il vettore per delle potenze di dieci e quindi utilizzare la virgola fissa invece della virgola mobile.

In campo professionale si usa sempre questo metodo per fare le valutazioni rapide di modelli polinomiali.
Questo e' il metodo di Orchard, domani vediamo come applicarlo al caso specifico!

Ciao,
Pietro.

PS: "esercizio per il volenteroso lettore": se invece di avere

$\left\{\begin{matrix} s_0=a_n\\ s_i=s_{i-1}x\ 10^p+a_{n-i} \end{matrix}\right.$

avessi

$\left\{\begin{matrix} s_0=a_n\\ s_i=s_{i-1}x\ 10^{(p(i-1))}+a_{n-i} \end{matrix}\right.$

quale sarebbe il polinomio risultante?

da **lelerelele** » 14 dic 2015, 20:37

Gia capire qualcosa è un'impresa :oops:

.

dopo un letta , riletta.....mi pare di avere intuito che si possa eliminare il calcolo esponenziale usando la moltiplicazione del valore X per il suo esponente sommato all'esponente stesso ridotto del numero di iterazioni, sommato il risultato per il numero di iterazioni

-------------------non so neanche io cosa ho scritto.------------------------

--------------------- Scusate tutti va oltre alle mie capacità.------------------------

tornando al codice, ho provato ad implementarlo, sperando così di capirci qualcosa, ma mi ritorna sempre zero, ritengo sia dovuto ad S=0 che moltiplicato ritorna sempre zero.

Codice: Seleziona tutto: unsigned long int s=0; for(k=0;k<loa;s=s*x+a[k++]);

non capisco da dove escono questi valori costanti.

Codice: Seleziona tutto: const int a[]={1,4,0,-3,8,-3};

la vedo molto dura.

Saluti e grazie per l'impegno.

da **Candy** » 15 dic 2015, 21:31

Caro

PietroBaima, mi chiami in causa a torto. Il somaro semmai sono io.

da **PietroBaima** » 16 dic 2015, 5:19

Candy ha scritto:Il somaro semmai sono io.

Ma non scherzare, mi riferivo a tutt'altri utenti somari, che poi, credo, sono in realta' solo uno.

lelerelele, mi dispiace non essere riuscito a spiegarmi bene.
Provero' a farti, quale esempio, il tuo caso specifico, magari ci capiamo meglio.
Magari risulta utile anche a

paofanello (spero).

lelerelele ha scritto:non capisco da dove escono questi valori costanti.

Sono i coefficienti del polinomio, ordinati dal grado 5 al grado 0, scritti senza saltare alcun grado.

In questa trattazione non discutero' della misura della altezza indirettamente rispetto alla pressione atmosferica, sebbene ci sarebbe molto da dire.
Mi limito a dire che la precisione non sara' alta e la approssimazione numerica che ricaveremo e' sovradimensionata rispetto alla precisione attesa da una misura di questo tipo.
Spero almeno che venga effettuata una compensazione rispetto alle condizioni meteo.

Comunque, da qui in poi, la formula e' una semplice funzione, senza significato fisico.
Proviamo a ricavare un polinomio approssimante, nell'intervallo pari a 800<p<1013.25

Come prima cosa proviamo a disegnare la funzione nell'intervallo assegnato.

Io uso Mathematica, definisco una funzione f e moltiplico il valore di p0 per 100, in modo che i valori di x da assegnare siano compresi fra 80000 e 101325.
In questo modo tolgo la virgola, lavorando in virgola fissa.

Codice: Seleziona tutto: f[x_] := 44300*(1 - (x/101325)^(1/5.255))

Disegno quindi un grafico che rappresenti la funzione (in rosso) e un grafico, sovrapposto, che rappresenti una retta che tocchi la funzione in rosso nel punto di inizio e nel punto di fine, per valutarne la deviazione dalla linearita', seppure a vista.

Codice: Seleziona tutto: Plot[{f[x], f[80000] + (x - 80000)*(f[101325] - f[80000])/(101325 - 80000)}, {x,80000, 101325}, PlotStyle -> {Red, {Blue, Dashed}}]

Ho lasciato i valori espressi in modo implicito per facilitare la lettura della funzione.

Ottengo

: feapprox.jpg (7.83 KiB) Osservato 3529 volte

Osservo che la non linearita' della funzione f(x) e' moderata.
Posso provare a svilupparla con Taylor, scegliendo come centro dello sviluppo il punto medio della funzione lineare, visto che non sono molto diverse fra loro.

Scelgo di arrestarmi all'ordine 3, a naso mi sembri assomigli piu' ad una cubica che a una parabola.

Scrivo quindi il comando

Codice: Seleziona tutto: Simplify[g[x_] = Normal[Series[f[x], {x, (101325 + 80000)/2, 3}]]]

che mi restituisce questo polinomio:

$P(x)=-2.70484377\text{E}-12 x^3+1.14220502\text{E}-6 x^2-0.231448 x+14538.2$

e lo assegna alla funzione g(x).

Disegno quindi un grafico di f e di g per avere un riscontro, seppur visivo, della loro appprossimazione.

Codice: Seleziona tutto: Plot[{f[x], g[x]}, {x, 80000, 101325}]

: feg.jpg (6.98 KiB) Osservato 3529 volte

Dovremmo esserci.
Per essere pero' un poco piu' precisi facciamo disegnare un grafico rappresentativo dell'errore.

Codice: Seleziona tutto: Plot[1 - g[x]/f[x], {x, 80000, 101325}]

: error.jpg (7.74 KiB) Osservato 3529 volte

Dovrebbe essere ampiamente accettabile, rispetto alla precisione voluta.

A questo punto non resta che estrarre il vettore a[] dei coefficienti del polinomio

$P(x)=-2.70484377\text{E}-12 x^3+1.14220502\text{E}-6 x^2-0.231448 x+14538.2$

che e':
$a[]=\{ -2.70484377\text{E}-12 ,1.14220502\text{E}-6 ,-0.231448 ,14538.2 \}$

Come dicevo nella spiegazione precedente, il termine noto e il coefficiente di grado piu' alto differiscono di parecchi ordini di grandezza (16 !!!)

Il vettore a va ribilanciato.
Possiamo prendere p=-5 (cosi' il coefficiente del termine di grado 3 verra' moltiplicato per $10^{-15}$ , voglio infatti considerare 3 cifre significative oltre all'unita', per essere piu' preciso. Il termine di grado 2 verra' moltiplicato per $10^{-10}$ e il termine lineare per $10^{-5}$ )

Ottengo, per avere uguaglianza:

$a[]=\{-2705,11422,-23145,14538\}$
(vettore bilanciato con p=-5.)

A questo punto l'algoritmo e' semplicemente questo:

Codice: Seleziona tutto: long int Polinom(long int x) { const long int a[]={-2705,11422,-23145,14538}; const char loa=4; const long int p=100000; int k=0; long int s=0; for(k=0;k<loa;s=s*x/p+a[k++]); return (s); }

Implementiamo il codice in Mathematica e facciamo un grafico che confronti l'algoritmo cosi' ottenuto (pallini marroncino) rispetto alla funzione f(x) di partenza. Viene riportata anche in blu la funzione lineare.

: doublechk.jpg (8.01 KiB) Osservato 3529 volte

Se hai dei problemi di compilazione, prova a buttare il codice seguente in questa pagina.
Si tratta di un compilatore online.
Nella finestra in alto a destra butta il codice, cancellando l'esempio, poi premi compile, poi execute.
Il programmino ti stampa il valore assunto della funzione, richiamata dal main.

Codice: Seleziona tutto: #include <stdio.h> long int Polinom(long int x) { const long int a[]={-2705,11422,-23145,14538}; const char loa=4; const long int p=100000; int k=0; long int s=0; for(k=0;k<loa;s=s*x/p+a[k++]); return (s); } int main() { int i; for (i=0;i<11;i++) printf("%d -> %ld\n",80000+i*2000,Polinom(80000+i*2000)); printf("101325 -> %ld\n",Polinom(101325)); return 0; }

Che restituisce la tabella:

Codice: Seleziona tutto: 80000 -> 1947 82000 -> 1748 84000 -> 1553 86000 -> 1361 88000 -> 1172 90000 -> 988 92000 -> 807 94000 -> 628 96000 -> 452 98000 -> 280 100000 -> 110 101325 -> 0

Notare che non e' stato usato nemmeno un floating point.
Voi direte: " non e' che ci stai fregando perche' usi valori multipli di 1000?"

91243 -> 874

La stesssa tabella, calcolata con Mathematica, in floating point e direttamente con la funzione f, senza polinomi approssimati, restituisce:

Codice: Seleziona tutto: Table[Print[x , "->", f[x]], {x, 80000, 100000, 2000}] 80000->1947.95 82000->1748.48 84000->1552.9 86000->1361.06 88000->1172.8 90000->987.978 92000->806.447 94000->628.084 96000->452.767 98000->280.384 100000->110.826

e il valore a caso preso prima, non multiplo di 1000:

91243 -> 874.777

Spero di essere stato un po' piu' comprensibile.

Ciao,
Pietro.

da **lelerelele** » 16 dic 2015, 10:05

Intanto ti ringrazio

PietroBaima per il lavoro svolto, appena vado a casa mi metto a provare il codice, e cercherò anche di studiarmi i polinomi, chissà che ci capisca qualcosa, (non sono abituato a fare cose ad occhi chiusi, che non conosco, devo sapere cio che sto facendo sennò è tutto inutile).

Però mi chiedo, avendo gia provato a reliazzare il codice precedente, e la variabile S rimaneva sempre zero, come fa questa riga a diventare diversa da zero?

Codice: Seleziona tutto: for(k=0;k<loa;s=s*x/p+a[k++]);

visto che moltiplico sempre S che vale zero?

mi sto annegando in un bicchiere d'acqua?
saluti.

ElectroYou - la comunità dei professionisti del mondo elettrico

Dimensione firmware compilato per 8 bit oppure per 16 bit

[11] Re: Dimensione firmware compilato per 8 bit oppure per 16 bi

[12] Re: Dimensione firmware compilato per 8 bit oppure per 16 bi

[13] Re: Dimensione firmware compilato per 8 bit oppure per 16 bi

[14] Re: Dimensione firmware compilato per 8 bit oppure per 16 bi

[15] Re: Dimensione firmware compilato per 8 bit oppure per 16 bi

[16] Re: Dimensione firmware compilato per 8 bit oppure per 16 bi

[17] Re: Dimensione firmware compilato per 8 bit oppure per 16 bi

[18] Re: Dimensione firmware compilato per 8 bit oppure per 16 bi

[19] Re: Dimensione firmware compilato per 8 bit oppure per 16 bi

[20] Re: Dimensione firmware compilato per 8 bit oppure per 16 bi

Chi c’è in linea

Informazioni

Seguici

Pubblicità

Credits