non devi modificare nulla. Il secondo arduino si connette, invia un messaggio facendo in modo che la stringa "led=1" o "led=0" sia in 6 posizione, così da essere riconosciuta e accettata dall'indexof().
fine

l'articolo wiki è incompleto, l'elenco degli indirizzi l'ho trovato quì: http://www.noc.garr.it/index.php?option=com_content&view=article&id=115&Itemid=190

there is a big error.
if you do

Code:

if(digitalRead(A8)==HIGH) count[0]++;
  if(digitalRead(A9)==HIGH) count[1]++;
  if(digitalRead(A10)==HIGH) count[2]++;
  if(digitalRead(A11)==HIGH) count[3]++;

inside the ISR you have 2 problem: first of all you are doing another non-nessesary function, as with

Code:

_newbit=PIND;
  _changed=_newbit^_oldbit;

you have in _changed all pin that has changed state (and all in one hit!)

seconds, digitalread is slow, and this is bad for timer.

easy man, mi piace aiutare chi si aiuta so benissimo che macello può essere trovare senza avere idea di cosa cercare

allora in teoria i 2 indirizzi di broadcast sicuri sono 192.168.0.0 e 192.168.0.255, ma non dovrebbero funzionare per il TCP. Sinceramente devo dare una riguardata all'argomento, stasera tiro fuori il libro di sistemi e poi ti dico

se puoi scaricarti i sorgenti, e magari sono pure in C, fai prima a portarli in wired.. Credimi, creare il PPM non è per nulla difficile, si tratta di un segnele lungo 20 millis, ogni canale ha circa 2 millis, in cui all'inizio è alto e poi si abbassa proporzionalmente al valore i output. Di solito il segnale alto dura dai 500 ai 1500 microsecondi, quindi per la precisione è necessario l'uso di interrupt sul timer

niente streamin video per arduino, troppo lento... al massimo una foto ogni manciata di secondi se non erro

il problema del TCP è che non può inviare dati broadcast o multicast.
Secondo me la cosa ideale è che i client in realtà siano server, quando cambia un pin arduino fa un multicast per avvisare del cambiamento, tutti i server rispondono "ok pin cambiato:X"
se arduino non riceve uno di questi messaggi o lo riceve sbagliato procede al reinvio, ma solo a quel server

sorry but in the documentation i don't see a dispose() method.

that should work, because never really close a video, it keep them in a list so it can be reused:

Code:

import processing.serial.*;
import processing.video.*;

Serial myPort;  // The serial port
HashMap <String, Movie> listOfMovie = new HashMap<String, Movie>();//the list of open movie
Movie playingMovie; //the pointer to the actual playing movie, no movie = null

void setup() {
  size(400,400,P3D);
  // Open whatever port is the one you're using.

  myPort = new Serial(this, Serial.list()[1], 2400);
  myPort.buffer(10);//that means don't call serialEvent until 10 carater are recived
  background(0);

  //here load and put all movie in the map.
  listOfMovie.put("3600A9C9F8", new Movie(this, "file1.mov") );
  listOfMovie.put("0000000000", new Movie(this, "file2.mov") );
  ///etc etc
}

void draw() {
  synchronized(playingMovie) {//to be sure we don't change video while it is changed by Serial command
    if (playingMovie != null) { //if video is rendering
      if ( playingMovie.available() ) { //if a new frame is available
        playingMovie.read(); //load it
      }
      image(playingMovie, 0, 0); //show the frame
    }
  }
}

void serialEvent(Serial p) {
  synchronized(myPort) {//to be sure only one thread at time can enter here
    while (myPort.available() >= 10) {
      //Video Code:
      String command = "";
      for (int i=0;i<10;i++) {
        command += myPort.readChar();
      }
      println(command);//here you should have the correct command

        //myMovie.setSize();
      if ( listOfMovie.containsKey(command) ) {//if the command is related to a video
        synchronized(playingMovie) {//to be sure we don't change video while it is drawn
          playingMovie.stop(); //stop old video
          playingMovie = listOfMovie.get(command); //get the command's video
          playingMovie.jump(0); //restart video from beginning
          playingMovie.play(); //play it
        }
      }
    }
  }
}

non sto smettendo la discussione, anzi, visto che era nata come discussione tecnica, vorrei che lo rimanesse.
Magari sfaso un pò, ma mi pare di essere abbstanza in linea con la discussione, sicuramente non mi sto esprimendo bene.
Io sto cercando di far differenza tra vulnerabilità intrinseca(cioè che risiede nel software dove teoricamente non dovresti o vorresti mettere le mani) e vulnerabilità da programmatore inesperto/dimenticanza/etc..
In oltre sto cercando anche di mettere sul piatto della bilancia, non il fatto che le patch siano importanti, ma come si comportino i vari produttori (microsoft, machintosh & co.) di fronte alla produzione e rilascio delle stesse.
Infine vorrei chiarire che perchè il codice criptato venga eseguito nel sistema (individuabile dall'antivirus, quindi già nella macchina), deve prima sfruttare una vulnerabilità, quindi l'errore non sta nel codice malevolo, ma a valle, ovvero nella vulnerabilità.

[ot]
Per quanto riguarda come nasce internet... ci provo
E' un sistema nato per essere P2P, è quindi è normale che non esista un "Produttore".
Ci sono "figure di spicco" come i provider e le dorsali, i DNS(che si avvicinano molto alla tua idea, data la loro struttura ad albero), e ci sono figure che creano e regolarizzano gli standard (RFC, ICANN & altri).

Il BUG del Software è sempre dovuto al programmatore idem per quello del Server/OS, cioè ma te intendi BUG di Programmazione o Elettronici ?

io intendo che l'errore deve essere nel programma che viene largamente utilizzato.. chissene se riesci a bucare un server, ma se con la stessa identica tecnica ne buchi 10.000.000... è quì che casca l'asino!

L'aggiornamento, porterà si beneficio a quella Vulnerabilità ma ne creerà un'altra, COSA DEL TUTTO NORMALE.

io avevo capito che si tenta di raggiungere la perfezione. Non sarà di questo mondo, ma almeno fare in modo che il sistema non si sbucci come una mela e utilizzando bug noti da mesi...

Come avere un PC sicuro ? non attaccarlo ad internet... ma qualcuno ti indurrà a farlo!

se vuoi un metodo più sicuro basta non averlo.

I virus ci sono in tutti Sistemi... chi più chi meno... ma TUTTI ce li hanno. Mi preoccuperei più di un Worm ma anche di una bella Backdoor criptata con massima accuratezza!

Scusami ma se hai installata una backdoor, almeno in linux, vuol dire che il sistema è stato completamente compromesso. Un Worm non compromette tutto il sistema, ma quanto ne basta per fare i suoi porci comodi.

Non tutto il codice è Malevolo... solamente una parte di essa, che può essere nascosta criptandola. Gli antivirus non fanno altro che decifrare questo codice ( Detta alla Larga ) e se il codice fosse impossibile da decifrare ? o meglio te lo fai il più difficile possibile e quando lui starà per riuscirci lo cambi... invece di 1234567( 8 ) cambi in 123( 8 )4567. Questa è una Bozza...

Puoi nascondere finch'è vuoi, ma al momento in cui va al procio deve essere in chiaro, altrimenti non va da nessuna parte
E comunque il fatto che ci sia del codice infetto vuol dire che c'è un errore a valle.

E' inutile stare qua a Dirci, windows ne prende di più Linux meno ecc... si fa una lista dei Pro e dei Contro per ogni sistema senza stare a sottolineare ogni punto.

peccato, pensavo che un'analisi oggettiva facesse il punto della situazione. Ma se preferisci andare di sentimento, beh, nulla di nuovo in pentola.

ah per chi se lo fosse perso, la discussione ha avuto origine in un altro post, è stata "spostata" qua perche era off-topic e confondeva la questione:

Salve a tutti.
Finalmente è arrivato Arduino Uno sono felicissimo, ma la felicità si è un po' morzata perchè ho il primo problema, Linux non mi riconosce l'usb

Ma siete ancora su Linux.....
Un mio vecchio capo disse una volta: ci si può opporre alla corrente, tenendosi forte ad una sponda.
Ti fermi, ma vedrai tutti gli altri passare.
Forse vanno verso una cascata o forse verso il mare.
La ricordo ancora questa frase.
Svegliatevi: il mondo dello Unix, del 1960, è finito.
Sul mio sito web gli accessi Unix/Linux/Ubunto ecc. sono il 3%...
Fermatevi pure, ma rimarrete lì.

One thing to consider is what will happen when the transmitted data is not received, or is received incorrectly. What will your quad-copter do?

If crashing is the result, as it usually is, ask yourself whether saving a few quid/pounds/lira/dollars/yen/euro is worth it.

Most people have decided that the answer is no.

sorry but you have this kind of problem also with the "classical" 4+ Channel RC-Remote. And arduino can check and sanitize the data, the RC no. (like no valid data for X seconds = slowly stop engine or return to home etc..)

I doubt it, toy helicopters usually use IR, and RC cars are usually digital controls only. A quadrotor helicopter absolutely requires high speed high resolution analog controls

IR is used only for indoor. Normally 2.4Ghz is used for almost all "Classic" Remote(because it auto solve the frequency "collision" of the old 33khz and so on) , and use PPM protocol

Data rates and FIFO depth matters a lot in this application

I personally recommend you bite the price bullet and get a true RC system for about $25 (which is actually about 17€) , and then add a full duplex data pipe only when you need it

PPM send form 1 to X channel every 20millis, I doubt this module can do worse.
And they cannot be used full duplex, at least half-duplex (if you don't set the frequency deviation)

it's very hard, because it depends on your loop code for the response.
You can have a little idea creating a skect that wait for a connection, and then reply all data.
On the pc you create a program that connect and send some data, and calculate the time for response.
You can also change the data size and see if arduino like big or short message.

ok, ma si tratta ancora del problema di sanitizzazione dell'input: non è un bug del software/server, ma del programmatore "utilizzatore finale", che l'errore lo fa su linux come su win o mac o altro.

non mi sono spiegato bene nella frase:

Certo, qualche sito, anche se rimane aggiornato al massimo, verrà bucato nel fratempo (se non da altri da chi ha trovato l'exploit), ma è ben diverso che ritrovarsi ad avere a che fare con una bot-net

intendevo che se anche un sistema è sempre aggiornato al 100%, un exploit "di massa" (perchè gli attacchi mirati son ben altra cosa) può funzionare, ma colpirà solo una piccola parte del parco macchine, se subito viene rilascata una patch.
La cosa non avviene per i software a pagamento, dove (a quanto pare) si preferisce fare raccolta di pacth e applicarle tutte insieme vendendole come service patch.
esempio: code-red, prima di essere patchato è trascorso un mese
invece FreeBSD.Scalper.Worm era morto in partenza, perchè addirittura esisteva già la patch in partenza, e le macchine colpite erano quelle obasolete.

e poi altro fatto "strano": nella lista di virus e worm più infettivi, quanti sistemi non windows trovi? ma anche eliminando i virus da desktop e considerando solo i worm da server, visto che quì linux è più usato ci si aspetterebbe, secondo logica, un macello... invece...

Stiamo andando OT, comunque

La gente sà fare tutto ma si sbaglia in particolari ( Parlo in Generale ), per dirne una... ho girato per vedere qualche Codice per il TMP102 il risultato ? Nessuno riesce a estrarre numeri Negativi... e poi si definiscono programmatori. E' bastato fare due calcoli... e l'ho fatto da solo, la soddisfazione è maggiore.
Un sensore che legga solamente Numeri Positivi e non quelli negativi è da Cabaret!

bèh se chiedono aiuto nel forum non è certo perchè le cose le sanno fare da soli.. quindi come errore è più che scusabile.
Sarebbe stato grave se l'errore fosse fatto in qualche libreria o classe rilasciata nel playground.

ah e non ho ancora capito che è sta RFI

si, sono definite in wprogram.h come uint8_t, quindi in teoria stanno bene pure in un byte:

Code:

#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
const static uint8_t A0 = 54;
const static uint8_t A1 = 55;
const static uint8_t A2 = 56;
const static uint8_t A3 = 57;
const static uint8_t A4 = 58;
const static uint8_t A5 = 59;
const static uint8_t A6 = 60;
const static uint8_t A7 = 61;
const static uint8_t A8 = 62;
const static uint8_t A9 = 63;
const static uint8_t A10 = 64;
const static uint8_t A11 = 65;
const static uint8_t A12 = 66;
const static uint8_t A13 = 67;
const static uint8_t A14 = 68;
const static uint8_t A15 = 69;
#else
const static uint8_t A0 = 14;
const static uint8_t A1 = 15;
const static uint8_t A2 = 16;
const static uint8_t A3 = 17;
const static uint8_t A4 = 18;
const static uint8_t A5 = 19;
const static uint8_t A6 = 20;
const static uint8_t A7 = 21;
#endif