Pages: [1] 2   Go Down
Author Topic: Arduino, Attiny85 et SD player d'ELM Chan via I2C  (Read 5148 times)
0 Members and 1 Guest are viewing this topic.
Strasbourg
Offline Offline
Jr. Member
**
Karma: 0
Posts: 79
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Bonjour à tous, j'aimerais juste avoir quelques précision sur la programation d'un Attiny85 avec le .hex d' ELM chan via la carte Arduino.
Mes connaissances en Anglais et mon niveau de codage n'étant pas au top, je préfére avoir un retour dans la langue de Moliére, ....

Je pense que vous connaissez le Simple SD Player, je voudrais donc faire le montage Mono, d'aprés ce qui est dit je peut programmer le Attiny85 via ISP autant de fois que je le souhaite, contrairement aux deux autres montages qui avec un prog ISP ne permette que de programmer une seule et unique fois, sans laisser trop de marge d'erreur....(EDIT >> puisque le pin reset du Attiny85 est pris par le montage stéréo, ce qui ne permet pas de reprogrammer le Attiny)

Donc si j'ai bien compris pour passer l'arduino Uno en programmeur ISP je dois prendre le sketch se trouvant dans le dossier de l'arduino dans exemple, ArduinoISP, puis le balancer dans l'Atmega, aprés je cable mon arduino comme ça :


une fois ceci fait je DL le AVRdude que je lance par éxécuter>CMD, je vais dans le dossier ou le Hex du SD player se trouve, puis je tape :
Code:
avrdude -P com3 -b 19200 -c avrisp -p attiny85 -v -e -U flash:w:sd8p_mo.hex

Aprés ça l'Attiny85 devrait étre programmé comme il faut pour le cabler ?? ou j'ai loupé un truc?

Et  quand il dit : "When connect the audio outputs to the amplifier, the high frequency component must be filtered out with LPF. Do not input the PWM signals directly to the amplifier or the amplifier and speakers can be damaged."
Cela veut dire qu'on doit passer par un petit Ampli avec un LM386 par exemple, et qu'on ne peut pas brancher le HP directement sur le pin de sortie audio de l'Attiny? , et que veut dire LPF?

Et derniére question, c'est quoi le petit composant avec trois Z connecté au HP et marqué 100µ ?



Vala merci à vous de vos futur réponse ^^

[EDIT] Y'a t'il une différence entre les Attiny85 PI et PU ?
« Last Edit: January 18, 2012, 04:38:30 pm by Arioch » Logged

Offline Offline
Full Member
***
Karma: 0
Posts: 106
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hello, ce projet m'intéresse !
Pour ma part j’aimerais bien me faire un lecteur piloté en HF.
LPF signifie low pass filter, autrement dit un filtre passe bas.
Attention je crois que tu as fait un contresens... Il est plutôt dit qu'on peu brancher directement des petites enceintes de bureau mais que si on veux le connecter à un ampli il faut filtrer la sortie avec un filtre passe bas, sous peine d’endommager l'ampli et les enceintes.
A +
Jacques.
Logged

Forum Moderator
Toulouse / France
Offline Offline
Full Member
*****
Karma: 2
Posts: 214
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

(...)
Et derniére question, c'est quoi le petit composant avec trois Z connecté au HP et marqué 100µ ?
Bonjour,



c'est un condensateur chimique polarisé de valeur 100 microFarad.

Lionel
Logged

- Distributeur officiel Arduino - Conception de shields qui défrisent

Strasbourg
Offline Offline
Jr. Member
**
Karma: 0
Posts: 79
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Re, ok merci bouault pour la signification du LPF, et merci pour la mauvaise trad que j'avais faite...donc pas besoin de LPF pour mon montage...

Snootlab, ok merci j'avais pas encore vu de condensateur dessiné comme ça, pour moi le dessin sur un schéma d'un condo c'est comme ça :

polarisé ou non....

Et euh pour le reste ??? vous avez une idée ?, pas spécialement envie de commander des Attiniy85 et de ne pas pouvoir les programmer faute de matos ^^
« Last Edit: December 04, 2011, 01:23:41 pm by Jean-François » Logged

Strasbourg
Offline Offline
Jr. Member
**
Karma: 0
Posts: 79
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Salut à vous, bon ben aprés avoir pas mal galéré pendant toute la journée j'y suis enfin arrivé, ben vouai Noob inside quoi ^^

Donc en fait j'ai galéré à chercher/vérifier/recabler je ne sais pas combien de fois le montage du SD Audio player pensant que ça devait venir que de là puisque la programmation avec Avrdude se déroulé comme il fallait avec cette ligne de commande:
Code:
avrdude -P com3 -b 19200 -c avrisp -p attiny85 -v -e -U flash:w:sd8p_mo.hex

Ben j'aurais gagné du temps si j'avais lu un peu plus en détail la façon de programmer via une board arduino en ISP (Merci Skyduino ^^), Donc ben en fait je m'étais trompé dans l'appel au programmateur dans la ligne de commande, j'aurais du mettre -c arduino et non pas -c avrisp.....
Code:
avrdude -P com3 -b 19200 -c arduino -p t85 -v -e -U flash:w:sd8p_mo.hex

Et à cela j'avais aussi oublié de régler les Fuses, car l'arduino n'aime pas le réglage des fuses via le firmware d'ELM ( on doit supprimer les trois derniéres lignes de son hex), ce qui fait qu'ils étaient tous avec les valeurs d'origine....
J'ai donc réglé les fuses avec cette ligne de commande:
Code:
avrdude -P com3 -b 19200 -c arduino -p t85 -v -e -U lfuse:w:0xE1:m -U hfuse:w:0xDD:m -U efuse:w:0xFF:m

et ça marche nickel chrome, me reste juste à faire un ampli parce que le son n'est vraiment pas fort, et je vais peut étre passer pour un boulet mais je ne trouve pas de convertisseur de mp3 vers du ""RIFF-WAVE format files in LPCM, 8/16-bit, mono/stereo and upto 48kHz sampling rate"" si quelqu'un peut m'aiguiller sur un logiciel, parce que je n'arrive qu'a lire les échantillons trouve de ci de là sur des site de personnes qui avait déja réalisé ce montage, mais aucun des fichiers que j'ai tenté de convertir ne marchent..

Voila c'est juste un retour de noob qui espére aider d'autres noob avec son retour smiley

A+

PS: Voila le montage amplificateur que je veux faire : Simple Wav Player LPF
« Last Edit: December 13, 2011, 02:33:39 am by Arioch » Logged

Strasbourg
Offline Offline
Jr. Member
**
Karma: 0
Posts: 79
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Bonjour à vous, c'est encore moi ^^

J'ai une petite question sur la modification du code d'ELM, pour le controler via I2C, le main qu'il faut compiler est celui ci Ici

lien trouvé dans la section allemande ICI

Code:
/* 8-pin SD audio player R0.04 (C)ChaN, 2010 */
/*-------------------------------------------------*/

// modified by using I2C interface, waiting for song number, then
// play selected song


#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <avr/wdt.h>
#include <string.h>
#include "diskio.h"
#include "pff.h"

#ifndef MODE
#error Wrong make file.
#endif
#define FCC(c1,c2,c3,c4) (((DWORD)c4<<24)+((DWORD)c3<<16)+((WORD)c2<<8)+(BYTE)c1) /* FourCC */


/*---------------------------------------------------------*/
/* Work Area                                               */
/*---------------------------------------------------------*/

volatile BYTE FifoRi, FifoWi, FifoCt; /* FIFO controls */

BYTE Buff[256]; /* Wave output FIFO */

FATFS Fs; /* File system object */
DIR Dir; /* Directory object */
FILINFO Fno; /* File information */

WORD rb; /* Return value. Put this here to avoid bugs of avr-gcc */



EMPTY_INTERRUPT(WDT_vect);


/*---------------------------------------------------------*/

static
DWORD load_header (void) /* 0:Invalid format, 1:I/O error, >1:Number of samples */
{
DWORD sz;


if (pf_read(Buff, 12, &rb)) return 1; /* Load file header (12 bytes) */

if (rb != 12 || LD_DWORD(Buff+8) != FCC('W','A','V','E')) return 0;

for (;;) {
pf_read(Buff, 8, &rb); /* Get Chunk ID and size */
if (rb != 8) return 0;
sz = LD_DWORD(&Buff[4]); /* Chunk size */

switch (LD_DWORD(&Buff[0])) { /* FCC */
case FCC('f','m','t',' ') : /* 'fmt ' chunk */
if (sz > 100 || sz < 16) return 0; /* Check chunk size */
pf_read(Buff, sz, &rb); /* Get content */
if (rb != sz) return 0;
if (Buff[0] != 1) return 0; /* Check coding type (1) */
if (Buff[2] != 1 && Buff[2] != 2) /* Check channels (1/2) */
return 0;
GPIOR0 = Buff[2]; /* Get channel flag */
if (Buff[14] != 8 && Buff[14] != 16) /* Check resolution (8/16) */
return 0;
GPIOR0 |= Buff[14]; /* Resolution flag */
OCR0A = (BYTE)(F_CPU/8/LD_WORD(&Buff[4]))-1; /* Sampling freq */
break;

case FCC('d','a','t','a') : /* 'data' chunk (start to play) */
return sz;

case FCC('L','I','S','T') : /* 'LIST' chunk (skip) */
case FCC('f','a','c','t') : /* 'fact' chunk (skip) */
pf_lseek(Fs.fptr + sz);
break;

default : /* Unknown chunk (error) */
return 0;
}
}

return 0;
}



static
UINT play (
const char *fn
)
{
DWORD sz;
FRESULT res;
BYTE sw;
WORD btr;


if ((res = pf_open(fn)) == FR_OK) {
sz = load_header(); /* Load file header */
if (sz < 256) return (UINT)sz;

if (!TCCR1) { /* Enable audio out if not enabled */
PLLCSR = 0b00000110; /* Select PLL clock for TC1.ck */
GTCCR =  0b01100000; /* Enable TC1.OCB as PWM out (L-ch) */
OCR1B = 128; OCR1A = 128;
TCCR1 = MODE ? 0b01100001 : 0b00000001; /* Start TC1 with TC1.OCA is enabled as PWM out (R-ch) */
TCCR0A = 0b00000010; /* Enable TC0.ck = 2MHz as interval timer */
TCCR0B = 0b00000010;
TIMSK = _BV(OCIE0A);
}

FifoCt = 0; FifoRi = 0; FifoWi = 0; /* Reset FIFO */
pf_read(0, 512 - (Fs.fptr % 512), &rb); /* Snip sector unaligned part */
sz -= rb;

sw = 1; /* Button status flag */
do {
/* Forward audio data */
btr = (sz > 1024) ? 1024 : (WORD)sz;
res = pf_read(0, btr, &rb);
if (res != FR_OK || btr != rb) break;
sz -= rb;
/* Check button down and break on button down */
sw <<= 1;
if (bit_is_clear(PINB, 0) && ++sw == 1) break;
wdt_reset();
} while (rb == 1024); /* Repeat until all data read */
}

while (FifoCt) ; /* Wait for FIFO empty */
OCR1A = 128; OCR1B = 128;

return res;
}



static
void delay500 (void)
{
TCCR1 = 0; GTCCR = 0; /* Stop TC1 */
TCCR0B = 0; TCCR0A = 0; /* Stop TC0 */

wdt_reset();
WDTCR = _BV(WDE) | _BV(WDIE) | 0b101; /* Enable WDT interrupt in timeout of 0.5s */
set_sleep_mode(SLEEP_MODE_PWR_DOWN); /* Enter power down mode */
sleep_mode();

WDTCR = _BV(WDE) | 0b110; /* Enable WDT reset in timeout of 1s */
}


//--------------------------------------------------------------------------
// USI functions for I2C slave
// copied from Axel Gartner, http://www.mikrocontroller.net/topic/38917

#define USI_DATA         USIDR
#define USI_STATUS      USISR
#define USI_CONTROL     USICR
#define USI_ADDRESS      0x55

#define NONE          0
#define ACK_PR_RX      1
#define BYTE_RX        2
#define ACK_PR_TX      3
#define PR_ACK_TX      4
#define BYTE_TX        5

    #define DDR_USI             DDRB
    #define PORT_USI            PORTB
    #define PIN_USI             PINB
    #define PORT_USI_SDA        PORTB0
    #define PORT_USI_SCL        PORTB2


volatile uint8_t COMM_STATUS = NONE;

void USI_init(void) {
  // 2-wire mode; Hold SCL on start and overflow; ext. clock
  USI_CONTROL |= (1<<USIWM1) | (1<<USICS1);
  USI_STATUS = 0xf0;  // write 1 to clear flags, clear counter
  DDR_USI  &= ~(1<<PORT_USI_SDA);
  PORT_USI &= ~(1<<PORT_USI_SDA);
  DDR_USI  |=  (1<<PORT_USI_SCL);
  PORT_USI |=  (1<<PORT_USI_SCL);
  // startcondition interrupt enable
  USI_CONTROL |= (1<<USISIE);
}



SIGNAL(SIG_USI_START) {
  uint8_t tmpUSI_STATUS;
  tmpUSI_STATUS = USI_STATUS;
  COMM_STATUS = NONE;
  // Wait for SCL to go low to ensure the "Start Condition" has completed.
  // otherwise the counter will count the transition
  while ( (PIN_USI & (1<<PORT_USI_SCL)) );
  USI_STATUS = 0xf0; // write 1 to clear flags; clear counter
  // enable USI interrupt on overflow; SCL goes low on overflow
  USI_CONTROL |= (1<<USIOIE) | (1<<USIWM0);
}


volatile unsigned char usi_rx_data = 0;


SIGNAL(SIG_USI_OVERFLOW) {
  uint8_t BUF_USI_DATA = USI_DATA;
  switch(COMM_STATUS) {
  case NONE:
    if (((BUF_USI_DATA & 0xfe) >> 1) != USI_ADDRESS) {  // if not receiving my address
      // disable USI interrupt on overflow; disable SCL low on overflow
      USI_CONTROL &= ~((1<<USIOIE) | (1<<USIWM0));
    }
    else { // else address is mine
      DDR_USI  |=  (1<<PORT_USI_SDA);
      USI_STATUS = 0x0e;  // reload counter for ACK, (SCL) high and back low
      if (BUF_USI_DATA & 0x01) COMM_STATUS = ACK_PR_TX; else COMM_STATUS = ACK_PR_RX;
    }
    break;
  case ACK_PR_RX:
    DDR_USI  &= ~(1<<PORT_USI_SDA);
    COMM_STATUS = BYTE_RX;
    break;
  case BYTE_RX:
    /* Save received byte here! ... = USI_DATA*/
    usi_rx_data = USI_DATA;
    DDR_USI  |=  (1<<PORT_USI_SDA);
    USI_STATUS = 0x0e;  // reload counter for ACK, (SCL) high and back low
    COMM_STATUS = ACK_PR_RX;
    break;
  case ACK_PR_TX:
    /* Put first byte to transmit in buffer here! USI_DATA = ... */
    PORT_USI |=  (1<<PORT_USI_SDA); // transparent for shifting data out
    COMM_STATUS = BYTE_TX;
    break;
  case PR_ACK_TX:
    if(BUF_USI_DATA & 0x01) {
      COMM_STATUS = NONE; // no ACK from master --> no more bytes to send
    }
    else {
      /* Put next byte to transmit in buffer here! USI_DATA = ... */
      PORT_USI |=  (1<<PORT_USI_SDA); // transparent for shifting data out
      DDR_USI  |=  (1<<PORT_USI_SDA);
      COMM_STATUS = BYTE_TX;
    }
    break;
  case BYTE_TX:
    DDR_USI  &= ~(1<<PORT_USI_SDA);
    PORT_USI &= ~(1<<PORT_USI_SDA);
    USI_STATUS = 0x0e;  // reload counter for ACK, (SCL) high and back low
    COMM_STATUS = PR_ACK_TX;
    break;
  }
  USI_STATUS |= (1<<USIOIF); // clear overflowinterruptflag, this also releases SCL
}


void USI_disable(void) {
  USI_CONTROL =0;
}



/*-----------------------------------------------------------------------*/
/* Main                                                                  */


int main (void)
{
   unsigned char count;


MCUSR = 0;  /* Clear WDRF in MCUSR */

   /* Write logical one to WDCE and WDE */
   WDTCR |= (1<<WDCE) | (1<<WDE);
   /* Turn off WDT */
   WDTCR = 0x00;


   PORTB = 0b111011; /* Initialize port: - - H H H I H P */
   DDRB  = 0b111010;

   USI_init();

   sei();

   while(usi_rx_data == 0);     // wait until songnumber received (1-255)

   USI_disable();

   PORTB = 0b111011; /* Initialize port: - - H H H L H P */
   DDRB  = 0b111110;

   pf_mount(&Fs);
   pf_opendir(&Dir, "");
   count = 0;
   WDTCR = _BV(WDE) | 0b110; /* Enable WDT reset in timeout of 1s */

   for(;;)
   {
      pf_readdir(&Dir, &Fno);
      if( Fno.fname[0] == 0)
      {
         while(1);
      }
      if( Fno.fname[0] && (!(Fno.fattrib & (AM_DIR|AM_HID))) && strstr(Fno.fname, ".WAV") )
      {
         count++;
      }
      if(count == usi_rx_data)
      {
         play(Fno.fname);
         while(1);
      }
   }

}

Etant complétement débutant, je ne comprends pas comment lancer le morceau que l'on souhaite via une commande I2C dans un sketch arduino....

Donc si quelqu'un pouvait me dire le truc ou me renvoyer vers un tuto je lui en serait reconnaissant ^^

Merci à vous.
« Last Edit: December 12, 2011, 07:40:50 am by Arioch » Logged

Strasbourg
Offline Offline
Jr. Member
**
Karma: 0
Posts: 79
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Re, bon ben j'ai bien galéré mais au moins j'ai appris à compiler, à faire un scan d'adresse sur les ports SDA et SDL sur un arduino, donc je met la réponse à ma question.

Aprés avoir programmé l'ATtiny85 avec ce hex : Ici fait avec la modification de Elo-Web.
et le réglages des fuses : high:0xD6 low:0xE1 extended:0xFF
La commande de la lecture sur la SD est super simple via l'arduino:

Code:
#include <Wire.h>

void setup()
{
  Wire.begin(); // join i2c bus (address optional for master)
}


void loop()
{
  Wire.beginTransmission(85);
  Wire.send(1);
  Wire.endTransmission();
}

Voila, par contre n'essayez pas de mettre les .wav dans un dossier wav comme stipulé sur le site d'ELM, ça marche pour son hex, mais pour la modification il faut que les fichiers soit à la racine pour étre lu.

A+

PS j'ai un peu l'impression de parler seul quand méme.....

* sd8p_mo.hex (17.03 KB - downloaded 43 times.)
« Last Edit: December 12, 2011, 05:16:52 pm by Arioch » Logged

France
Offline Offline
God Member
*****
Karma: 4
Posts: 961
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Merci Arioch

-pour avoir déniché cette version (à commande i2c) d'un petit lecteur de WAV sympa,
-pour l'avoir compilé et mis le HEX à disposition avec indication des fusibles,
-pour le sketch avec la bonne adresse I2C pour le petit module I2C esclave...

Si j'ai bien compris tu mets dans Wire.send(); le numero du fichier wav à jouer

Le LM386 est un bon petit ampli BF.... qui peut parfois osciller ou se transformer en récepteur AM si les fils aboutissant à ses entrées sont un peu longs...

Pour la préparation des fichiers wav je pense à Audacity qui peut importer du mp3 pour ensuite rééchantillonner et exporter dans le bon format , avec au passage des possibilités d'édition audio.
« Last Edit: December 12, 2011, 05:59:12 pm by al1fch » Logged

Strasbourg
Offline Offline
Jr. Member
**
Karma: 0
Posts: 79
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Salut à toi al1fch, ben de rien de rien, j'ai juste farfouillé à droite et à gauche pour trouver ça, j'ai pas eu à faire grand chose en fait, puisque tout était quasiment fait, bon mis à part comprendre la marche à suivre ^^

Pour la lecture du fichier wav, oui il suffit d'envoyer juste le numéro du morceau wav à jouer, c'est vraiment ultra easy, et je suis pas mécontent d'avoir trouvé ça, ça m'évite de passer par le shield Wavplayer qui ne fait pas le méme prix pour mon petit projet smiley

En tout les cas je te remercie pour le logiciel Audacity, je m'y met ce midi, et pour le LM386 logiquement les fils ne devraient pas étre long puisque le montage sera fait sur Veroboard, enfin si je trouve un moyen convenable de fixer le LM386 CMS sur la veroboard...

Vali valou

A+
Logged

Made in Belgium
Offline Offline
God Member
*****
Karma: 0
Posts: 756
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Pour un noob comme tu as dis, tu te débrouille quand même très bien.    smiley-eek
A l'état actuel je sais pas si j'aurais su faire la même chose (motivation  smiley-mr-green )
On vois qu'il y a de la recherche, ça change du "noob" qui ce précipite sur le forum pour avoir du tout cuit.  smiley
Bravo et merci pour le partage. smiley-wink
Logged


Strasbourg
Offline Offline
Jr. Member
**
Karma: 0
Posts: 79
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Re all, bon juste pour prévenir, en fait le lancement par I2C ne se fait qu'une fois, impossible de lancer un second morceaux une fois qu'un morceau ai été lancé....
pour ma part ça ne me pose pas de soucis, puisque c'est un son final que je souhaite (bruit d'explosion ou un beau "You Win").
Donc si vous voulez pousser la chose, je crois que l'auteur donne un indice sur son site :
Quote
Die Software wurde so modifiziert, dass per I2C-Bus ein bestimmter Sound von der SD-Karte abgespielt werden kann. Benötigt werden hier 5 Sounds: Sounddatei 1-4 sind die Sounds für 1/4, 1/2, 3/4 und volle Stunde, Sounddatei 5 ist der Sound, der bei jeder vollen Stunde anschließend an Sound 4 noch entsprechend des Stundenwerts x-mal als Glockenschlag abgespielt wird, sozusagen das "Bong". Der Simple SD Audio Player ist dabei ein I2C-Slave, der über das USI realisiert wurde. Da die I2C-Pins des ATtiny85 eigentlich schon für die Ansteuerung der SD-Karte belegt sind, wurde hier eine softwaremäßige Umschaltung vorgenommen: nach PowerOn werden diese als I2C geschaltet und es wird gewartet, bis die Soundnummer empfangen wurde. Anschließend werden die Pins als SPI Interface für die SD-Kartenansteuerung verwendet. Der Atmega8 der Ping Pong Platine ist der I2C-Master und nutzt das on-chip I2C-Interface. Die erforderlichen Pullups für I2C werden im ATmega8 intern hinzugeschaltet. Nachdem die Soundnummer übertragen wurde, wird im Atmega8 das I2C-Interface abgeschaltet und beide Pins SCL und SDA werden als Eingänge beschaltet. Hierüber kann dann erkannt werden, wann der Sound zu Ende ist, da dann keine Pegelwechsel mehr auf der CLK-Leitung der SD-Karte vorhanden sind.

Traduction Googlienne :
Quote
Le logiciel a été modifié de sorte qu'il peut être joué via le bus I2C est un certain son de la carte SD. Nécessaire voici 5 sons: fichier sonore 1-4 sont les bruits de 1 / 4, 1 / 2, 3 / 4 et plein de fichiers sonores heures 5 est le son que par la suite, chaque heure de son 4 pour le moment en fonction de la valeur horaire de x parfois joué un accident vasculaire cérébral, pour ainsi dire, le "bong" est. Le simple SD Audio Player est un esclave I2C qui a été réalisé grâce à l'iodation universelle du sel. Depuis les broches I2C sont en réalité les ATTINY85 est déjà plein pour le contrôle de la carte SD, voici un logiciel de commutation à base a été faite: après une marche entre eux que I2C, puis attend jusqu'à ce que le numéro de son a été reçue. Puis les broches sont utilisés comme une interface SPI pour le lecteur de carte SD. L'Atmega8 l'Ping Pong conseil d'administration est le maître I2C et utilise l'interface I2C sur puce. Les tractions nécessaires pour I2C pour être connecté en interne dans l'ATmega8. Une fois que le numéro a été transmis le son, l'Atmega8 est l'interface I2C est éteint et les deux broches SCL et SDA sont connectés comme entrées. Par ici peut alors être détectée lorsque le son est trop tard, parce qu'alors, aucun niveau de changements plus sur la ligne CLK de la carte SD sont disponibles.

j'ai mis en bleu la phrase intéressante....
Aprés ce que j'en ai compris c'est qu'il coupé les broches d'entrée SDA/SDL de l'attiny une fois l'info donné pour laisser place au lecteur de WAV, mais ce que je ne comprends pas c'est pourquoi en ayant flashé un sketch avec une boucle, l'arduino ne fait pas en sorte que le morceau tourne en boucle une fois finit?

fin bref je verrais ça plus tard, la faut que je finisse mon projet avant tout ^^, c'était juste une info.
« Last Edit: December 19, 2011, 01:12:38 pm by Arioch » Logged

France
Offline Offline
Faraday Member
**
Karma: 52
Posts: 5341
Arduino Hacker
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Bonjour,

Re all, bon juste pour prévenir, en fait le lancement par I2C ne se fait qu'une fois, impossible de lancer un second morceaux une fois qu'un morceau ai été lancé....
pour ma part ça ne me pose pas de soucis, puisque c'est un son final que je souhaite (bruit d'explosion ou un beau "You Win").
Donc si vous voulez pousser la chose, je crois que l'auteur donne un indice sur son site :
D'après ce que j'ai compris du programme l'attiny initialise d'abord un bus i2c software et attend un octet correspondant au numéro de la musique, une fois reçu il "stop" ce bus I2C et l'utilise en port SPI pour communiquer avec la carte sd et jouer la musique, donc c'est logique qu'une fois la musique lancé il soit impossible de stopper ou de changer de musique.
Le seul moyen de stopper/changer de musique c'est d'envoyer une impulsion LOW sur le reset de l'attiny pour le faire "redémarrer" et qu'il reparte en attente sur le bus I2C.

Aprés ce que j'en ai compris c'est qu'il coupé les broches d'entrée SDA/SDL de l'attiny une fois l'info donné pour laisser place au lecteur de WAV, mais ce que je ne comprends pas c'est pourquoi en ayant flashé un sketch avec une boucle, l'arduino ne fait pas en sorte que le morceau tourne en boucle une fois finit?
Quand le programme "tombe" dans le while(1) après 1 secondes le "watch-dog" détecte la boucle infini et redémarre l'attiny, ainsi il recommence à partir en mode I2C et attend un nouveau octet, et etc etc ... c'est pour ça que le morceau ne tourne pas en boucle.
Logged

Des news, des tuto et plein de bonne chose sur http://skyduino.wordpress.com !

Strasbourg
Offline Offline
Jr. Member
**
Karma: 0
Posts: 79
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Salut à toi Skywood et merci de tes précisions, par contre petite question pour envoyer une impulsion Low et donc réinitialiser le Attiny, j'aurais donc juste besoin de brancher un cable d'une broche digital "Y" vers le pin 1 de l'attiny, et d'envoyer l'impulsion avec cette ligne de commande:

digitalWrite(PinY,LOW);

...
Logged

France
Offline Offline
Faraday Member
**
Karma: 52
Posts: 5341
Arduino Hacker
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Salut à toi Skywood et merci de tes précisions, par contre petite question pour envoyer une impulsion Low et donc réinitialiser le Attiny, j'aurais donc juste besoin de brancher un câble d'une broche digital "Y" vers le pin 1 de l'attiny, et d'envoyer l'impulsion avec cette ligne de commande:

digitalWrite(PinY,LOW);
Voila en gros un
Code:
digitalWrite(PinY, LOW);
delay(100);
digitalWrite(PinY, HIGH);
et l'ATtiny sera redémarré illico presto.
Logged

Des news, des tuto et plein de bonne chose sur http://skyduino.wordpress.com !

Strasbourg
Offline Offline
Jr. Member
**
Karma: 0
Posts: 79
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Re, ben euh ça marche pas .....
Avec un cable connecté du pin 1 de l'ATtiny sur la broche digital 3 de l'arduino ça bloque complétement la lecture.

Code:
#include <Wire.h>

void setup()
{
  Wire.begin(); // join i2c bus (address optional for master)
  pinMode(3, OUTPUT);


}


void loop()
{
  Wire.beginTransmission(85);
  Wire.send(1);
  Wire.endTransmission();
  delay(3000);
  digitalWrite(3, LOW);
  delay(100);
    digitalWrite(3, HIGH);
}
« Last Edit: December 21, 2011, 01:06:32 pm by Arioch » Logged

Pages: [1] 2   Go Up
Jump to: