--> http://code.google.com/p/arduino/issues/detail?id=1040&sort=-id

L'argomento è più da sezione Software. 

Ho provato questa soluzione e ha funzionato! . Ringrazio PaoloP.
Sono rimasto molto incerto se mettere l'articolo sotto hardware o software pensando che il driver stia in mezzo ai due.
Se mi dite come lo sposto.

Non cambia nulla tra la versione 32 e 64 per quanto riguarda l'installazione dei driver, ovviamente con la 64 bit devi usare drive idonei.
Arduino non usa driver specifici, usa un driver che fa parte del sistema operativo stesso, ovvero usbser.sys, che in W8 non è presente, almeno così era nella versione beta che ho provato io e a quanto pare anche in quella che sta usando asamlink, senza quel driver Arduino non lo puoi usare.

Purtroppo confermo. Ho provato di tutto per la mia poca esperienza, ma nulla da fare. Credo proprio che con questo S.O. il programma che utilizza il dispositivo su arduino per funzionare dovra' attendere.
Io ho W8 per lo sviluppo di un'applicazione di telecontrollo, quella famosa che parlavo ai tempi (i commerciali sono affaqscinati da Metro o come si chiama!). Un'applicazione che usa la rete. Se mi vedo impacciato dirotto arduino in rete con l'enc per l'applicazione con arduino in usb, motivo in piu' per utilizzarlo seriamente (l'enc).

Se posso: W8 e' molto bello, e l'ho trovato più stabile e veloce di W7, ma è per touch screen. C'e' da impazzire. E secondo me,comunque abbastanza inutile anche per i touch. Non me ne vogliano, ma tutti quei quadrati colorati creano disorientamento. Tant'è che passo subito alla modalità desktop, che è W7 in pratica. Comunque è un pezzo che Microsoft la mena con sta interfaccia, dai primi windows phone per poi passare all'xbox 360, con kinect poi dirottato pure su PC; già immagino un futuro con tablet che per controllarli...basta guardarli!

No, ho gia' verificato che l'amministratore e' attivo (anche perche' effettuo operazioni che senza il suo potere non riesco ad effettuare). Dice che manca la firma dell'inf. Come nell'articolo segnalato.

aspetta..i driver non firmati non si possono installare lo stesso?probabilmente win ti sparerà fuori 100 avvisi,ma penso che ti lasci..o al max devi cambiare qlk impostazione..

Questo e' cio' che pensavo anche io, ma ho ottenuto lo stesso effetto del link piu' sopra. Non lo ha installato, che sia da abilitare l'administrator?

Se il driver non è firmato non penso che lo puoi installare

http://arduino.cc/forum/index.php/topic,94651.0.html

Grazie infinite, appena ho tempo provo (in effetti ho lo stesso messaggio). Ma sara' sempre cosi', o le cose per l'installazione del driver cambieranno?

Quanto sto per dire prendilo con beneficio di inventario, avevo provato una delle prime beta relase di W8, ufficiale Microsoft, e mi sono accorto che mancava il driver usbser.sys, presente sia in XP, Vista e Seven, che è il driver nativo di Windows utilizzato da Arduino, senza questo file Arduino, tutte le versioni, non può dialogare col pc.
Tocca verificare se nella RTM di W8 è stato aggiunto questo driver, intanto prova a cercarlo nella cartella "..\system32\drivers" se non c'è puoi scordarti di usare Arduino con la release di Windows 8 in tuo possesso, se c'è allora il problema è nel file .inf di descrizione del driver che non è compatibile con Windows 8, in questo caso basta modificarlo opportunamente.

Non c'e', mi sa allora che attendo un driver opportuno. Grazie a tutti.

Prova i driver di Win7, non dovresti avere problemi

Ciao,
anzitutto grazie per la risposta.
In Windows 7 sono riuscito a configurarlo, mentre in windows 8 no: potrebbe essere il sistema 64 bit anziche' 32?
Mi sembra assurdo in quanto e' vero non ho un sistema a 64 bit eccetto W8, ma clienti non italiani che stanno usando l'oggetto che hanno windows 7 (credo 64 bit in quanto americani e tedeschi), non hanno avuto problemi.

Salve a tutti,
Ho la fortuna (sfortuna) di usare una Build di Windows 8. Ovviamente ho provato a connettere l'Arduino uno R3 al S.O. e come mi aspettavo, il driver non e' stato installato. So che probabilmente e' impossibile sia disponibile un driver, ma io comunque chiedo se qualcuno sa come baipassare il problema. Comunque immagino che all'uscita ufficiale del S.O., basta solo attendere per avere i driver.

Grazie a tutti, siete fantastici. Il forum e' da Nobel.

Soluzione:
Inviata da PaoloP:  http://code.google.com/p/arduino/issues/detail?id=1040&sort=-id

Ciao,

Volevo segnalarti http://arduino.cc/forum/index.php/topic,108589.0.html.
E' vero che stiamo parlando di cose diverse, ma ad essere onesto, piacerebbe sapere e controllare come ti funziona.
Sperando di arrivare ad una soluzione per il mio caso.

non so aiutarti nel tuo problema, ti volevo chiedere lo schema con cui hai connesso il 488 al mega o 328...

Ciao,
ti posto lo schema fritzing.

Non ho usato le resistenze tra A, B e Y, Z perche' la distanza non e' elevata e comunque ho lo una coppia.
Il tutto gira a 9600 bps (non ho provato a velocita' piu' elevate, in quanto il dispositivo remoto non va oltre e non lo programmo io).

Cosi' a me funziona tutto correttamente, se hai dubbi e posso aiutarti, ben volentieri.

Salve a tutti,

Sto continuando ad effettuare dei test. Ho scoperto che se uso il circuito collegato al PC (su Serial ovviamente) ho dei problemi di ricezione su Serial1.

Ho scollegato la Serial (USB) dal PC e continuato ad eseguire i test, e tutto funziona. Ovviamente ho riscritto il codice per l'eth e ho preparato un programma che comunica su tcp/ip. Lo scketch che sta girando e':

Code:

#include <Arduino.h>
#include <SD.h>
#include <SPI.h>
#include <Ethernet.h>
#include <EEPROM.h>
#include <Wire.h>

/************ ETHERNET STUFF ************/
void setup();
void loop();
byte mac[] = { 0x90, 0xA2, 0xDA, 0x0B, 0x00, 0x88 };
IPAddress ip(192,168,30,177);
IPAddress ipServer(192,168,30,115);
EthernetServer server(1717);
EthernetClient client;
EthernetClient cServer;

byte rcv[100];

void setup()
{
  Ethernet.begin(mac, ip);
  server.begin();
  Serial1.begin(9600);
  //Serial.begin(9600);
}

void loop()
{
 
  cServer = server.available();
  if(cServer.connected() && cServer.available())
  {
    //Ricevo: B0,Bdata -> B0: total data to receive, Bdata data to send serial1
    byte len = cServer.read();
    for(byte c = 0; c<len; c++)
    {
      while(!cServer.available()) delay(10);
     
      rcv[c] = cServer.read();
    }
   
   
   
    for(byte c = 0; c<len; c++)
      Serial1.write(rcv[c]);

//    Serial.println("Receive data:");
//    for(byte c = 0; c<len; c++)
//    {
//      Serial.print(rcv[c],HEX);
//      Serial.print("; ");
//    }
//    Serial.println();
   
  }
 
  delay(25);
 
  if(Serial1.available())
  {
    int oldav,newav;
    do
    {
      oldav = Serial1.available();
     
      delay(100);
     
      newav = Serial1.available();
    }while(oldav!=newav);
   
    if(client.connect(ipServer, 1717))
    {
      for (int c = 0; c< newav;c++)
        client.write(Serial1.read());
       
      client.flush();
      client.stop();
    }

    //Serial1 purged
    while(Serial1.available())
    {
      Serial1.read();
      delay(20);
    }
  }
}

A questo punto posso desumere che ci possa essere qualche conflitto Hardware. Mah!

Salve a tutti,

Recentemente ho avuto un problema nella gestione delle seriali sull'arduino mega 2560 rev.3.
IDE di sviluppo 1.0.1.
Il quadro e' questo: la seriale principale e' collegata al PC. La serial1 e' collegata ad un chip max488, che e' connessa ad un dispositivo.
E' anche collegato uno shield ETH in rev. 3.
Il funzionamento normale, prevede il controllo dissociato tra le seriali. Infatti la serial serve solo come configuratore (alla terminal) del dispositivo. A regime il dispositivo e' collegato su serial1 e scambia le informazioni tra serial/eth (cioe' ho un incapsulamento del protocollo seriale su eth).
Fin qui tutto bene.
Il problema avviene quando, per check up, ho voluto verificare quali fossero le informazioni della Serial1. Per fare questo, on the fly (cioe' velocemente) ho precaricato questo:

Code:

void setup()
{
  Serial.begin(9600);
  Serial1.begin(9600);
}

void loop()
{
  while(Serial1.available())
    Serial.write(Serial1.read());

  while(Serial.available())
    Serial1.write(Serial.read());
}

E sono incomanciati i problemi. Soprattutto sulla ricezione dalla serial1. Cioe' vengono troncate le informazioni. Non contento, ho insistito con un codice poco piu' evoluto:

Code:

void setup()
{
  Serial.begin(9600);
  Serial1.begin(9600);
}

void loop()
{
  if(Serial.available())
  {
    Serial.println();
    Serial.println("---------------------");
    Serial.print("Receive: ");

    byte toRcv = Serial.read();
   
    Serial.print(toRcv,DEC);
    Serial.println("");
   
    while(Serial.available())
    {
      Serial1.write(Serial.read());
      //delay(3);
    }
   
    int av;
    delay(25);
    do
    {
      av = Serial1.available();
      Serial.println(av,DEC);
      delay(1000);
    }while(av<toRcv);
   
    Serial.print("RCV:");
   
    for(int c = 0; c < toRcv; c++)
    {
      Serial.print(Serial1.read(),HEX);
      Serial.print(';');
    }
     
    Serial.println();
    Serial.println("Flushing:");
    while(Serial1.available())
    {
      Serial.print(Serial1.read(),HEX);
      Serial.print(';');
    }
  }
}

In questo, invio l'ammotare atteso di byte su serial1. Ma anche qui ho diversi problemi, a volte non ho nemmeno dati dalla Serial1.
Non riesco proprio a capire. Grazie a tutti.

se hanno gli stessi indirizzi vanno in conflitto e l'i2c non funziona, e devi inventarti un sistema usando transistor/mosfet per alimentare solo un chip alla volta.

Come immaginavo. Se anziche' di un Mosfet, usassi due pin I/O differenti? Per fortuna, i chip non usano una corrente altissima di lavoro, quindi un'out dell'arduino dovrebbe essere sufficiente, giusto?

Ringrazio tutti per le risposte.

Mi ha incuriosito:

visto che la scrittura del EEPROM é molto piú lenta della letura puoi usare il Page Write di 32 Byte alla volta.
Leggi 32 byte del EEprom sorgente e li scrivi sul I2C del destinatario. Nel fratempo che il EEprom destinatario fa la scrittura leggi i prossimi 32 Byte. Non serve tenere niente in memoria EEprom o FLash di Arduino e velocizzi anche la scrittura perché elimini l'attesa della scrittura interna.

Non ho ben capito: avendo prefissati gli indirizzi a livello di hardware: quando leggo dal chip sorgente come posso essere sicuro di farlo dal chip interessato se hanno stessi indirizzi?, o forse intendevi, con l'opzione due, a indirizzi separati?
Probabilmente non ho capito.
Pensavo anche ad una soluzione del tipo: mi salvo una pagina per volta in RAM (32 byte in array), in lettura uso il chip1, in scrittura uso il chip2.

Salve a tutti,

Ho creato un programmatore di memorie per dei computer che leggono dati da chip 24lc64.
E' risultato un bel progetto semplice e funzionale e collaudato. Già in produzione da me sviluppato per poche unità, mi ritrovo ora a dover gestire quantitativi maggiori: fuori dalla semplice portata di una singola persona che utilizza shield prototipi collegati con dei fili rigidi unifilari.
E' stato contattato un esterno per gestire questa produzione, e dopo aver visto il prodotto, ha suggerito diverse migliorie: una mi piace molto e ha posto un dubbio. Le memorie sopracitate in I2C, sono acquistate da un fornitore già preconfigurate ad indirizzo fisso. L'idea sarebbe di gestire una coppia diretta tra 2 memorie senza usare il pc come tramite (un po' come una dock station con due hd). Pensavo di alimentare le memorie tramite due pin diversi dell'arduino, ed eseguire la copia dalla sorgente alla destinazione passando per l'eeprom alimentando di proposito l'opportuna memoria. Questa operazione viene eseguita in più passaggi (a pagine), per la limitatezza dell'eeprom dell'arduino.
E' fattibile oppure posso avere problemi di conflitti indirizzi anche se una memoria non è alimentata?