Bonjour,
 
Je suis entrain de plancher sur un projet d'école dans le cadre du cours de programmation, il s'agirait d'un effet reverb réalisé avec microcontrôleur (Atmel, Bascom imposé).
 
Je me retrouve donc avec la notion d'algorithme en main... le principe est +- bien compris mais qu'en est-il au niveau programmation ? Y aurait-il un endroit ou trouver des exemples ? Le mien n'a vraiment pas besoin d'être sophistiqué, tout est fixe sauf le temps de réverbération (jusque 5 secondes +-).
 
J'aurais aussi besoin de quelques indications concernant l'échantillonnage (dans le programme, comment prendre le signal original, le découper (bit par bit ?) et le réinjecter suivant l'algorithme), et peut-être d'autres choses que j'oublie et qu'il faut me rappeler.
 
Niveau choix du µC, avec 5 secondes de reverb max. +-, d'après un petit calcul (échantillonnage 44,1 kHz, 16 Bits), j'aurais assez avec 64k de mémoire, c'est bien cela ? Y en a-t-il chez Atmel avec CAN en entrée et CNA en sortie intégrés dans le µC ?
 
Pouvez-vous m'aider sur ce sujet ?
 
Merci Beaucoup !
 
Axhan

Pourquoi tu parles de découpage bit par bit?
Non, tu prend tes échantillons, t'appliques ton algo de réverbération aux échantillons et tu t'occupes pas vraiment de leurs bits en tant que tels.
 
Pour la quantité de mémoire, tas fait comment ton calcul? Parce que j'arrive pas à la même conclusion (mais peut-être que je me trompe).
Mets voir ton algo de reverb ici (pas forcément écrit en C, juste pour voir ce que tu veux faire)

Le voici :

Voila ce que je dois mettre par écrit en Bascom (imposé par le prof).
Donc en temps réel ce serait appliquer cet algorithme à chaque échantillon bufferisé (je m'étais mal exprimé, c'était bien échantillon par échantillon et non bit par bit ). Hum et aussi, comment ça se passe avec le buffer ?
Pour la mémoire, je veux bien que tu me donnes ton calcul car je ne l'ai pas en écrit, le prof l'a sorti comme ça sur son ordi mais je ne rappelle plus trop bien..

Edit : Trouvé sur musicdsp :

int   numlines = 8;
float t1 = 50.0;        // d0 time
float g1 = 0.75;        // d0 gain
float rev = -3*t1 / log10 (g1);

for (int n = 0; n < numlines; ++n)
{
  float dt = t1 / pow (2, (float (n) / numlines));
  float g = pow (10, -((3*dt) / rev));
  printf ("d%d t=%.3f g=%.3f\n", n, dt, g);
}

Bein pour moi :
- 44.1kHz -> 44.1k échantillons / sec
- 5x44.1k = 220.5k échantillons x 5sec
- 16 bits x 220.5k échantillons de mémorisés = 3528kbits = 0.441 Mo
 
Maintenant, c'est pour ça que je te demande quel algo tu veux utiliser. Parce que suivant comment tu veux le faire (quel type de d'amortissement tu veux & co), tu peux tricher en gardant moins d'échantillons pour les "vieux" échantillons (qui de toutes façons sont de plus en plus faibles). Et aussi les stocker sur moins de bits... Enfin tu vois quoi. Ca dépend beaucoup de l'effet que tu cherches