per quel che ho visto io (i primi risultati di google cercando "pvc espanso") per una lastra da 3mm di spessore siamo sui 10€ al m^2, e 7€ per quella da 2mm...

quindi siamo sui 3.84€ al 1m*1m*1mm (3840€ al m^3... bhe mi aspetto che sulle grosse quantità facciano FORTI sconti)

ahh, Come? ma sta scherzando spero! se a te serve costruire un cubo da 1m^3 ti servono 6 piastre da 1m^2 ovvero 6 m^2 !! al massimo 60 euro!! o ti serve creare un cubo pieno? anche così a 3840 euro ce ne vuole!

L'idea della batteria tampone piace anche a me, facilita il compito, ma ho qualche dubbio, e se ci fossere sbalzi di tensione che provocassero il reset del micro?  io ho fatto in passato qualche applicazione a microprocessore su autovetture, e in uno riscontrai un problema che ad oggi, non sono sicuro di aver risolto (l'auto in questione ora è ferma da 2 anni), mi si cancellava la flash del micro (Picaxe 18x) eppure avevo un regolatore di tensione L7805 con i canonici 4 condensatori (2 elettrolitici e 2 ceramici) messi come raccomandato da schemi elettrici), quindi considerando che nel mio caso fu un'avviamento difficoltoso a far accadere il problema, (ma si sa, le auto sono piene di Noise EMI) quindi il mio dubbio è, lavorare con l'alimentazione di rete opportunamente ridotta alla tensione di lavoro dell' Arduino mediante trasformatore o altro, la presenza della batteria tampone garantirà che in presenza di interferenze EMI o di alte frequenze in tensione in ingresso si resetti il micro? e se ciò accadesse, i dati in RAM andrebbero perduti?  Quindi come suggerisce Leo, vi dovrà comunque salvare in EEPROM i dati, magari si potrebbe fare a fine giornata lavorativa o dopo un certo periodo di inattività? così anche in eventuale reset, i dati persi sarebbero di qualche 1/2 giornata al massimo.
Hai ragione Lesto, avevo dimenticato l'indirizzamento, magari lo si potrebbe mettere sempre alle prime locazioni, quelle necessarie per indirizzare da 0000 a 1024 (quindi 2 byte no?) voi siete più bravi in questo, a voi la parola!!

Si hai ragione, forse per lavori più sbrigativi, il PVC è più conveniente, quelli consigliati da me sono un'alternativa, ma richiedono lavoro extra per garantire le caratteristiche meccaniche minime per un funzionamento affidabile.  Giusto per sapere, ma quanto costano queste lastre di PVC?  sono facili da tagliare o richiedono attrezzi particolari?  in che spessori si trovano? ed infine, sono leggere?

Dico forse una fesseria, correggetemi se sbaglio, i cicli di scrittura per cui le EEPROM sono garantiti dai vari fabricanti sono circa 100000 e se dopo questi si pianta, è possibile solo la lettura (che è a quanto sembra, quasi eterna o almeno, per 20 o più anni), ma se non ricordo male, i 100000 cicli sono per singolo byte dell' EEPROM, quindi se ne avessimo una da 1024 bytes (come quella interna) ed il nostro blocco dati fosse di 4 byte, salveremo => 1024/4=256 blocchi dati per ogni ciclo di riempimento dell' EEPROM,  quindi i 100000 cicli per byte dell' EEPROM ci garantirebbero 25600000 (25 milioni 600 mila) blocchi registrati, ad una cadenza di 1 sec a blocco, per un'ipotetico 176 ore lavorative al mese (5gg x 8 h e 1 x 4 h a settimana = 24 gg lavorativi) finirebbe... la macchina, prima dell' EEPROM!!    circa 404 mesi = 36,7 anni lavorando 11 mesi l'anno (un po di ferie se le meriterà o no? )  quindi ad 1 sec. sono d'accordo che sarebbe più che sufficiente come capienza, ma visto che deve portare un conteggio pezzi, non sarebbe meglio che registrasse ad operazione avvenuta?  se faccio 2500 pezzi al giorno, farà 2500 salvataggi di blocchi e non 8 h x 3600 sec = 28800 salvataggi, no? anche prevedendo che di quei 100K cicli siano effettivamente la metà (eh si, avvolte capita che vanno in errore, mi è capitato con quelle dei codici delle ECU stradali, e le devi buttare) comunque la durata sarebbe ben oltre le aspettative della vita produttiva sella macchina in questione!
L'idea della batteria tampone o del condensatore per garantire un backup momentaneo e ottima per questo tipo di applicazione secondo me, aggiunge pochissimi costi in cambio di un'aumentata sicurezza in caso di problemi di tensione.

Avevo dimenticato scrivere anche il compensato, e vero quello che dice Astrobeed  la balsa è delicata, ma tottu dipende dalle caratteristiche finali di resistenza del pezzo, usare un listello da 1mm e una cosa, usarne da 5mm e un'altra e si arriva fino a 9-10mm, ma se incolliamo 10 strati da 1mm con della colla epoxy, il risultato finale è superiore a quello del listello da 10mm ! e questo è un concetto molto comune in tutti i materiali compositi, che siano fibra di vetro, carbonio, kevlar ecc...   Per quanto la lavorabilità di elementi piatti come immagino sia il vostro caso, si potrebbe fare con un minimo di attrezzature, la pompa si vuoto sarebbe consigliabili ma non indispensabile, basterebbero due piano perfettamente lisci, che diventerebbero stampo e controstampo, ben lubrificate con della cera (quella per lucidare le auto) diciamo da 3 a 4 mani per sicurezza, o se si preferisce, stendere per bene delle pellicole di nylon, rayon, o teflon sui due stampi, le resine epossidiche non attaccano bene su queste superfici.
Adesso devo andare, stasera vedo di farvi un tutorial base e qualche link. 

che grado di resistenza vi serve? dimensioni? magari faccio qualche prova, ho un po di materiale (sia balsa che un po di compensato che di resine e fiberglass varie, oltre che ovviamente a del carbonio! in varie trame e grammatura!. 

Grazie Leo72!  la risposta più chiara e concisa che ho visto in giro per spiegare il concetto!

Quindi la function freeRam() non mi da la RAM libera di tutta quella disponibile ma solo quella compresa tra il Heap e lo STACK giusto? mi sai dire quanto è grande lo spazio .data e .bss per favore sull'arduino? dal datasheet Atmel, non mi è chiaro:

Figure 8-3. Data Memory Map
32 Registers                      0x0000 - 0x001F
64 I/O Registers                 0x0020 - 0x005F
160 Ext I/O Reg.                0x0060 - 0x00FF
Internal SRAM                    0x0100(inizio)
(512/1024/1024/2048 x   0x02FF/0x04FF/0x4FF/0x08FF (fine in base alla capacità della SRAM, l'ultimo è il 328P dell'arduino uno)

non mi è chiaro chi sia chi,  ma da come vedo, i 2048 bytes sono separati dagli altri registri, vero?  o sto mi sto confondendo, forse le aree .data, .bss heap e stack sono all'interno di quei 2048 bytes ed i registri sono un'altra cosa?  a me sembra più logico così.  Con i picaxe sapevo solo che avevo a disposizione un determinato numero di byte per dichiarare variabili e le dovevo amministrare sapientemente per far funzionare il tutto, spesso creavo forme di riciclarle (copiandole in una zona di RAM libera apposita e leggendola quando mi servivano) ma qui è più complicato.  Scusate la mia ignoranza e/o confusione!!

PaoloP, grazie dello schema, molto interessante, sapevo che le MCU non hanno la RAM esterna (forse solo le CPU dei computer?) ma capisco poco, o almeno, non mi è chiaro del tutto, potresti spiegare per favore?  a quanto ho visto, la prima zona è per le variabili static e global, la seconda per quelle local ecc e poi non ci ho capito quasi nulla!   la function freeRam() l'ho trovata se non ricordo male, sul Reference/Playground ufficiale, e spiegava che serve ad avere un'idea della RAM libera, ma vedendo questo schema ed analizzando la function (per quel poco che ci capisco), la zona "misurata" non è sul totale della RAM, ma su una porzione di essa, ho capito bene o sto solo farneticando?

grazie

ok, la funzione freeRam() l'ho trovata in giro, serve per conoscere grossolanamente, la quantità di RAM libera, ma va invocata in diverse parti dello sketch, tipo alla fine di un loop() o magari dentro delle functions che gestiscono molti dati locali per esempio, così ti possono dare un'idea della RAM libera durante tutta l'esecuzione dello sketch, così se in qualche parte si blocca, e sospetti sia la RAM esaurita, potresti verificare se e così o no.  Mi e stata molto utile per capire che devo ottimizzare un pò, riducendo l'uso di variabili globali in favore di quelle locali (ed imparare a passarle per valore o riferimento, ma ancora non so farlo bene) o usando variabili byte invece di int se i valori da memorizzare non superano il range 0-255, infatti, spesso, mi capita di lavorare con valori che non superano 255 e non sono negativi, quindi in quel caso, le dichiaro byte, occupano meno RAM anche se global.  Quelle che occupano in assoluto più bytes di RAM e FLASH sono le variabili string!.

ho apportato qualche modifica al codice e tentato di fare come sul mio programma, attualmente ha due chiamate a function, leggi() e leggi2(), la prima riceve 4 numeri ASCII e li converte in un numero (senza il controllo errore, non è garantito il range 0000 a 9999 se si ricevesse dei "garbages" ), la seconda function, leggi2() invece è pensata per il comando b che da come so, usa un'unico numero e quindi aspetta solo questo.  Basterà prevedere a priori la struttura di comandi in RX e creare le function necessarie, poi si aggiunge nel ciclo if...else if (o in un switch case) cosa fare al ricevere tale carattere comando.

Code:

void loop(){
 
if (Serial.available() )
  { ser=Serial.read();
    if(ser=='a')
    {
      leggi();
    }
 
    else if (ser== 'b')
    {
      leggi_b();
     
    }
    else if (ser== 'c')            //aggiungere qui altri comandi e chiamare le function corrispondenti, in questo caso, ho aggiunto un'utile chiamata a freeRam()
    {
      Serial.println(freeRam());
    }
  }
 
}

//*****************************************************
  void leggi(){  //legge 3 caratteri numerici ASCII sulla seriale, li converte a integer
   
    //Serial.println("OK, a premuto");
     
     delay(50);   ////<------------------questo delay è indispensabile!!
     if (Serial.available()) {
     
      a = Serial.read()-48;                       //viene sottratto 48 per rientrare nel range dei caratteri numerici ASCII (0=49,1=50....9=58)
      b = Serial.read()-48;                       //senza un sistema di check errore, se il sistema ricevesse una "a" per esempio, 
      c = Serial.read()-48;                       //verrebbe calcolato come "65"... x1000 o x100 o x10 o x1, quindi errato.
      d = Serial.read()-48;
      delayTime = (a*1000)+(b*100)+(c*10)+(d*1);  //se si deve ricevere 1, dalla seriale dovrà arrivare 0 0 0 1
      Serial.println(a);                          //debug
      Serial.println(b);                          //debug
      Serial.println(c);                          //debug
      Serial.println(d);                          //debug
      Serial.println(delayTime);                  //debug
    }

}
  //******************************************************
  void leggi_b(){  //questa function riceve un singolo carattere numerico, per esempio: 0=stop, 1=Forrard, 2=Reverse...
   
    //Serial.println("OK, b premuto");
    delay(5);
    if (Serial.available()) {
      x = Serial.read()-48;
     
      Serial.println(x);}
 
  }
 
  //*******************************************************
  int freeRam () {
  extern int __heap_start, *__brkval;
  int v;
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);

}

Ho aggiunto il comando "c" per un'utile chiamata a freeRam(), ovviamente è solo un'esempio. in questo caso, vi sono liberi 1823 bytes su 2048 bytes.  Se si ottimizza occupa sicuramente meno (nel mio sketch le variabili sono tutte global).

Spero sia di aiuto a qualcuno.

Interessante, ma effettivamente, chiamare se stesso troppe volte potrebbe riempire la RAM disponobile se il numero di chiamate è elevato o se si sta già a corto di RAM, nei picaxe vi era un limite al numero di gosub utilizzabili altrimenti si bloccavano, immagino sia quasi la stessa cosa.

io invece lo avevo risolto creando una function ->Rx_Data() che ha una struttura pensata in base alla ricezione di di 3 cifre (char numerico ASCII) ogn' una, questa function assegna alla variabile ->Value il valore ricevuto, il programma da cui ti ho mandato degli spezzoni,  consta (per ora) di 15 comandi diversi, alcuni ricevono solo 1 numero compreso tra 000 e 999, altri ne hanno 4 numeri da 000 a 999, altri ne hanno 8 numeri da 000 a 999 ed altri ne avranno fino a 256 (una matrice di 16x16) sempre da 000 a 999 (quest'ultima parte no l'ho ancora realizzata).   E per questo che ho quel grado di complessità, come detto nei post precedenti, magari un programmatore esperto lo farebbe molto meglio di me (io sto imparando!), per me sta bene così (per ora), magari non è perfetto, ma funziona e ci capisco tutto, così in caso di ampliamenti o modifiche future, ci capirò.  

ciao.

PS. attualmente questo mio programma (non completo) occupa 700 linee di codice, compilato occupa 9700 bytes (tanti, devo "tagliare" o rischio che il resto non mi entra) e mi tiene liberi 900 bytes di RAM (troppi pochi considerando tutto quello che ci manca!) ma tieni presente che uso solo variabili global e qualche local, e un totale di 400 bytes in arrays varie, tra cui, una da 16x16.  Man mano imparerò di più, il prodotto finito sarà più efficiente e compatto.

Io in passato, per altri progetti, non di tipo robotistico ma automobilistico, ho usato la balsa in vari spessori (fino a 10mm), per carichi non esagerati credo abbia buone probabilità, certo, il fatto di trovarle solo in listoni da 100mm di larghezza per circa 80-100cm di lunghezza limita la loro applicazione. una volta ho fatto un'esperimento, avevo creato un parallelepipedo di circa 100x60x30mm di lunghezza circa in balsa da 1-1,5mm e l'ho rivestito con un solo strato di vetroresina in tela (da 180gr/m2 quindi molto sottile), il risultato è stato spettacolare in quanto a resistenza, infatti, con questi spessori, con una singola mano (nemmeno tanto forte), è facilissimo schiacciare il modellino in questione, dopo il rivestimenti e stato impossibile romperlo o deformarlo permanentemente con una sola mano!  quindi credo che in certi casi, non necessariamente questo, si possa sperimentare qualcosa del genere, più la forma è scatolata, più acquisterà rigidità.  Per i più esigenti, avrei proposto la fibra di carbonio, infatti è ancora più resistente ma costa troppo rispetto alla fibra di vetro (consiglio in tela non la stuoia) ne so qualcosa, ci sto facendo dei pezzi davvero complessi (delle trombette d'aspirazione per corpi farfallati singoli per auto da corsa) che mi stanno dando alcuni grattacapi per ora, realizzarli in singolo pezzo è un vero incubo, dopo averne sfornato 3 "quasi" perfetti, prossimamente spero di realizzare finalmente il pezzo perfetto.  Ma in quanto a resistenza e leggerezza, è impressionante! rispetto alla sua controparte in alluminio realizzato in cnc fanno un figurone e pesano la 1/4 parte!!

Con un'amico, anni fa, abbiamo realizzato il cruscotto della sua macchina da corsa, con una tecnica alquanto insolita, abbiamo realizzato le misure in vettura con del semplice cartone corrugato, che opportunamente sagomato ed incollato in modo solido abbastanza da fargli rimanere la forma anche fuori dalla vettura, poi, lo abbiamo rivestito completamente di vetroresina, nello strato esterno, con la tela, nella parte interna con la stuoia (la tela era finita), il risultato è stato un pezzo che pesava circa 1-1,5 kg ma che ci si poteva quasi salire con i piedi su senza spezzarlo!!  Pensate alle scocche delle vetture da corsa!  magari, invece di una base piatta, ne fate una con qualche superficie concava-convessa a mo di barca per intenderci e rivestirla di uno strato di vetroresina in tela ed avrete un telaio a prova di buche!

Interessanti le realizzazioni in PVC, non ne avevo viste, nella lavorazione dei compositi, viene usato anche come agente di spessore irrigidendo la struttura senza aggiungere peso in spessori da 3 a 9mm .

stavo per consigliarti propio quella strada, o inviare i dati e poi arduino li esegue in autonomo o gli invii solo i dati base, poi, con dei calcoli interni si incaricherebbe del pilotaggio dei motori.  intuisco come potrei fare ma non so ancora come lo farei se fossi al tuo posto. 
Beh, non credo che andare a vedere il codice di uno sketch sia una cosa grave, dopotutto lo spirito dell'open source è proprio questo, condividere le proprie conoscenze e/o lavori per puro divertimento o spirito di partecipazione o aiuto al prossimo.  Ovviamente se ti senti meglio facendo tutto da te, sei libero di fare come credi meglio, avvolte anche io preferisco la strada più lunga e laboriosa, perche alla fine, qualsiasi risultato ottengo, buono o meno che sia, sarà stato frutto del mio impegno ed ingegno.  Questo però non toglie che vedere come qualcun'altro ha affrontato una cosa simile, sia sbagliato, ovviamente a me non piace copiarlo con taglia ed incolla e via, voglio metterci del mio, adattarlo alle mie necessità o meglio, alle mie capacità.  Per esempio, esistono un sacco di librerie, farebbero la felicità di chiunque, ma essendo che ancora non domino bene la programmazione e preferisco andare per gradi, mi sembra più complicato tentare di far funzionare una libreria fatta da un professionista e che per tanto, difficilmente io comprenderò a fondo in ogni sfumatura e quindi preferisco di creare una mia versione, a modo mio, magari poi, dopo un po, la rivedo e la miglioro.
Comunque buona fortuna, fai tante prove pratiche.

 Ciao

ok, adesso mi è più chiaro.  darti una risposta univoca non posso, non ho mai "giocato" abbastanza con i passo-passo, ma se richiedi un'aggiornamento ogni 1 ms, credo che farlo in real time da seriale sarà un problema secondo me, magari qualcuno esperto ti potrà essere più d'aiuto, tieni presente la velocità di trasmissione della seriale, per esempio, la più veloce che potresti usare è 115200 bit per secondo ovvero 115.2 bit per ms.  il delay(50) potresti provare a ridurlo o eliminarlo e vedere come va, a me, andava bene fin quando non mandavo catene di comandi e dati lunghe, per quelle da singolo comando anche senza ricordo che mi funzionava (da premettere che ho fatto prove solo a 9600 bps quindi molto al di sotto del massimo possibile).  Quindi prova a vedere se non ti perde comandi/passi togliendo del tutto i delay(50), se invece succede, prova ad aumentare gradualmente, del tipo delay(5)...10, 15, 20...

ho testato un po il tuo codice a 115200 bps inviando una catena casuale di almeno 40 numeri e sembra ok ma senza un sistema di controllo errori non so se davvero è ok.

ho testato il mio codice a 115200, senza delay o con delay fino a 5ms, se provavo a trasmettere molti dati, ottenevo errore, solo se inviavo un singolo carattere "a" anche in una catena di 60 contemporaneamente, ottengo 60 risposte positive da arduino. quindi come vedi, qui dovrai lavorarci un po su e provare diverse soluzioni.

Dovresti studiare qualche sketch di quelli che si sono creati una CNC con arduino e capire come hanno fatto.

il delay(50), l'ho aggiunto alla fine del blocco, infatti, se riceviamo una stringa molto lunga dal pc, si rischia di perdere bytes, adesso, puoi inviare ad arduino anche un serie di comandi del tipo:

a1200ba1250ba1400b.... ovvero, puoi concatenare una serie di comandi, ma per quello che devi fare, con b, se fatto così come da esempio, dovrai usare un contatore per poter mettere arduino in uno dei 3 stati previsti, giusto? o invierai il comando: b0, b1, b2? forse la soluzione migliore o a tutt' al  più, potresti fare 3 comandi, s=stop, f=forward, r=reverse.  non sarebbe anch'esso utilizzabile? da una parte complica ma dall'altra rende il protocollo più immune ad eventuali errori di ricezione perchè dovrebbe passare attraverso il filtro del comandi singoli.  E per questo che nel mio shetch ho previsto il controllo degli errori, per ora è del tutto grossolano, se non sono numeri non fa nulla, ma nella versione definitiva dovrà contenere un sistema di checksum, le operazioni da eseguire sono alquanto critiche e devo essere sicuro che i dati ricevuti o trasmessi siano integri, altrimenti, succedono casini, anche gravi.  Nel tuo caso, se devi fargli fare solo questo senza che il motore faccia muovere nulla che possa fare danni se sbaglia comando, allora procedi come pianificato, perchè come dicono spesso gli americani ed gli informatici, K.I.S.S. (Keep It Simple, Stupid)http://it.wikipedia.org/wiki/KISS_(informatica)

ok, ho giocato un po con il tuo codice (bravo per la compattazione!) ed ho trovato il problema:

Code:

if (Serial.available() )
  { ser=Serial.read();
    if(ser=='a')
    {
      delay(50);
      a = Serial.read()-48;
      b = Serial.read()-48;
      c = Serial.read()-48;
      d = Serial.read()-48;
      delayTime = (a*1000)+(b*100)+(c*10)+(d*1);
      Serial.println(a);
      Serial.println(b);
      Serial.println(c);
      Serial.println(d);
      Serial.println(delayTime);
      delay(50);
    }
  
    else if (ser== 'b')
    {
      x = 1;
      Serial.println(x);
    }
    
  }

semplicemente, ho inserito una variabile "var" la quale viene assegnato il valore in entrata su Serial.read(), semplicemente, dovevi eliminare la seconda chiamata a Serial.read perché già all'interno del ciclo if Serial.available() l'ho collaudata e funziona. spero che ti sia d'aiuto.
ciao.