potenziometro digitale interface SPI come si colle

Ciao a tutti . Volevo sapere se il potenziometro http://it.rs-online.com/web/search/searchBrowseAction.html?method=getProduct&R=0403676 va bene per essere interfacciato ad arduino ? Leggevo sul forum di questa libreria creata da Federico http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1266875130/4.

E' possibile e lo puoi controllare con questa libreria: http://www.arduino.cc/playground/Code/Spi

Sai dove posso trovare qualche esempio su come si collega ad arduino e qualche esempio di codice. A me servirebbe cambiare la resistenza alla pressione di un tasto. grazie /me

http://it.wikipedia.org/wiki/Serial_Peripheral_Interface

Ora gli do una bella lettura su questo protocollo, anche se un bel esempio rende sempre più l'idea.

Di quale esempio hai bisogno? Dal momento in cui hai una libreria a disposizione, la devi solo utilizzare nel tuo codice... Se guardi nella pagina della libreria, la prima cosa che ti viene indicata è proprio come deve essere collegata fisicamente. Poi non devi far altro che scrivere il codice per dare i comandi e/o ricevere i dati al dispositivo che avrai collegato. ;) Cosa non ti è chiaro?

P.S: non ti aspetterai che qualcuno scriva il codice per il tuo progetto?? Allora non sarebbe più il "tuo" progetto... :P

Perdonami è da poco che uso Arduino e i microcontrollori in generale. Chiedevo degli esempi per capire non per copiare! Io il mio primo programmino l'ho scritto proprio dagli esempi sul sito arduino.cc e da li si cerca di migliorare e fare cose piu "belle".

ciaoo ragazzi scusatemi avevate ragione con un po di pazienza e tanto mal di testa sono riuscito a comnicare con un potenziometro digitale , precisamente con questo http://ww1.microchip.com/downloads/en/DeviceDoc/11195c.pdf
ho realizzato un piccolo programma che da seriale fa cambiare l aresistenza da 0 a 100% e lo voglio condividere!! :wink: :wink: :wink:
ringrazio tutti in particolare kokiua,brainbooster

  #define DATAOUT 11//MOSI
  #define DATAIN 12//MISO - not used, but part of builtin SPI
  #define SPICLOCK  13//sck
  #define SLAVESELECT 10//ss
  
  const int dim =2 ;
  
  char valore[dim]; //array che memorizza i dati da tastiera 
  char* p;  //puntatore
  char inByte;  // singolo dato immesso 
  int LED = 1;
  int duty=0; // duty da tastiera
  int dutyprovvisorio=0; // variabile che mi sono creato per verificare se quello che digito è un dato possibile
  
  int i; //indice dell'array
  
  byte address = B00010001;
  byte pot=0;
  byte resistance=0;
  int serIn1;
  
  char spi_transfer(char data)
{
  SPDR = data;                    // Start the transmission
  while (!(SPSR & (1<<SPIF)))     // Wait the end of the transmission
  {
  };
  return SPDR;                    // return the received byte
}
  
void setup() {
  TCCR0B = TCCR0B & 0b11111000 | 0x03;
   Serial.begin(9600); 
   pinMode(LED, OUTPUT);
   analogWrite(LED,0 );  //faccio in modo che il mio led sia inizialmente spento
    
   
   
    byte clr;
  pinMode(DATAOUT, OUTPUT);
  pinMode(DATAIN, INPUT);
  pinMode(SPICLOCK,OUTPUT);
  pinMode(SLAVESELECT,OUTPUT);
  digitalWrite(SLAVESELECT,HIGH); //disable device
  // SPCR = 01010000
  //interrupt disabled,spi enabled,msb 1st,master,clk low when idle,
  //sample on leading edge of clk,system clock/4 (fastest)
  
/*
SPCR bits:
7: SPIEE - enables SPI interrupt when high
6: SPE - enable SPI bus when high
5: DORD - LSB first when high, MSB first when low
4: MSTR - arduino is in master mode when high, slave when low
3: CPOL - data clock idle when high if 1, idle when low if 0
2: CPHA - data on falling edge of clock when high, rising edge when low
1: SPR1 - set speed of SPI bus
0: SPR0 - set speed of SPI bus (00 is fastest @ 4MHz, 11 is slowest @ 250KHz)
*/


  SPCR = (1<<SPE)|(1<<MSTR);
  clr=SPSR;
  clr=SPDR;
 
  delay(10);
    write_pot(0);
}

void write_pot(byte value)
{
  digitalWrite(SLAVESELECT,LOW);  //2 byte opcode
  spi_transfer(address);
  spi_transfer(value);
  digitalWrite(SLAVESELECT,HIGH); //release chip, signal end transfer
}



void loop() {
          if( Serial.available() > 0){
             inByte = Serial.read();
           if (inByte!='*'){
              dutyf();
           }
            
          else{
             Serial.print("Arresto");
             analogWrite(LED, 0);}
             
             
          } 

}

void dutyf(){
//            if (Serial.available() > 0) { 
//                        
//                       inByte =  Serial.read();
                       if (inByte != '#') {
                                            valore[i] = inByte;
                                            int dutyprovvisorio = atof(valore); // dutyprovvisorio mi dice dopo che l'ho impostato da tastiera se è un valore possibile
                           
                                            if(dutyprovvisorio <=100  & i<= 2  & dutyprovvisorio >= 0) { 
                                                  
                                          
                                                                Serial.print("dutyprovvisorio = ");
                                                                Serial.println(dutyprovvisorio);
                                                                Serial.print("Valore digitato=");
                                                                Serial.println(valore[i]);
                                                                Serial.print("indice=");
                                                                Serial.println(i);
                                                                }
                                                               else{
                                                      
                                                               Serial.println("Error");
                                                               Serial.println("Ridigita duty 2");
                                                               for (p=valore, i=0; i<dim; i++,  p++){  //inializzza il mio array 
                                                               *p = 0;}
                                                                i= 0-1 ;
              
                                                }
                                            
                                  
                                              i= i+1;
                                             } 
                                              else{
                                                   int duty = atof(valore);
                                                   int dutyled=map(duty, 0, 100, 0, 255);  //analogWrite acceta valori da 0 a 255 quindi gli traslo vedi arduino-->reference
                                                   analogWrite(LED, dutyled);
                                                   Serial.print("duty= "); //valore che digito sulla tastiera
                                                   Serial.println(duty);
                                                    write_pot(dutyled);
                                                   
                                                   
                                                   Serial.print("dutyled= ");
                                                   Serial.println(dutyled);
                                                   
                                                   Serial.print("invio= ");  //mi dice ho premuto ul tasto # 
                                                   Serial.println(inByte);
                                                   
                                                   
                                                   for (p=valore, i=0; i<dim; i++,  p++){
                                                   *p = 0;}
                                                   
                                                   
                                                   
                                                   i= 0;
                                                   }
                      //  }
       delay(10);



}