Voir les contributions

Cette section vous permet de consulter les contributions (messages, sujets et fichiers joints) d'un utilisateur. Vous ne pourrez voir que les contributions des zones auxquelles vous avez accès.


Messages - Benoit92

Pages: 1 ... 4 5 [6] 7 8 ... 14
76
Composants / Re : Teensy 3.1, 3.2 - Sonorisation locomotive
« le: janvier 22, 2018, 09:12:25 pm »
1) Ok, je vais essayer de comprendre la fonction "Input Capture". Je ne sais pas si je dois modifier le NmraDcc.h / NmraDcc.cpp : je suis très loin d'être un Mozart de l'Arduino.
Nota : J'utilise et j'ai modifié le Timer 2 pour piloter le moteur (pont en H) à 125 Hz.

2) L'avantage d'une flash SPI par rapport à une carte SD.
Le temps d'accès ?
La mise en œuvre plus facile ?
Pour installer des fichiers dans une Flash SPI, j'installe mes fichiers sons dans des onglets différents (ajouter un fichier . . .), puis je fais des <Include> dans le programme principal (*.ino) ?

77
Composants / Re : Teensy 3.1, 3.2 - Sonorisation locomotive
« le: janvier 20, 2018, 09:08:42 pm »
1) Tu peux m'expliquer comment tu ferais pour mon application ?

2) Si j'ai bien compris, pour la liaison série, si j'utilise Rx Tx (pin 0 et 1), je ne suis pas obligé de charger la bibliothèque "SoftwareSerial.h".
    Par contre, dans ce cas, je ne peux pas utiliser le moniteur série.


78
Composants / Re : Teensy 3.1, 3.2 - Sonorisation locomotive
« le: janvier 20, 2018, 06:21:40 pm »
Aujourd'hui, je pars sur l'hypothèse de l'utilisation de 2 Arduino Nano :
Arduino 1
Gestion de la vitesse (pont en H) + l'éclairage (Feux avant/Arrière + cabine) + Pantographe (servo) + Dételage (servo)

Arduino 2
Dédié pour le son, je pense le piloter à partir de l'Arduino Nano 1 par l'intermédiaire de la liaison série Tx/Dx.
L'Arduino 2 recevra les consignes de son (vitesse, accélération, freinage, arrêt, sifflet, . . .).
Une routine ISR dans l'Arduino 2 permettra de vérifier que la consigne de son n'a pas changé.
    - Si pas de changement de consigne, la lecture continue.
    - Si changement de consigne, la lecture en cours s’arrête et la lecture du nouveau fichier commence.
-> Je vais étudier le dossier "interruptions" du forum.

Je pense qu'il vaut mieux découpler la fonction "son" des autres. Les trames DCC arrive de manière asynchrone.
Un certain nombre de trames ne concerne pas la locomotive (Adresse)
Quand je lie un fichier son, l'Arduino ne fait rien d'autre (en particulier, la vitesse n'est pas gérer pendant ce temps). Je risque de rater des trames DCC concernant la locomotive.

79
Composants / Re : Teensy 3.1, 3.2 - Sonorisation locomotive
« le: janvier 20, 2018, 02:47:59 pm »
Bonjour,
Au total, j'ai essayé les configurations suivantes :
1) - Arduino Nano + Carte SD + Bibliothèque "SoftwareSerial.h"- Sortie PWM:
            -> le temps est trop long entre chaque morceau de musique pour mon application. Cette architecture semble plutôt faite pour des lecteurs MP3.

2) - Arduino Nano + Bibliothèque "PCM.h"+ codage son "EncodeAudio"- Sortie PWM:

-> Cette architecture inspirée du le site "Train35" est intéressante en terme de temps de réponse, mais la durée des bruitages doit être très courte (32 Ko Flash Memory sur l'Arduino).

3)  - Teensy 3.2 + codage son "wav2sketch" + bibliothèque "Audio.h" - Sortie Convertisseur Numérique Analogique (DAC A14)
-> Ce contrôleur, compatible de l'arduino (instructions + IDE arduino) est plus rapide que le Nano (72 MHz au lieu de 16 Mhz), mais plus cher (environ 25 €). Il possède 256 Ko de Flash.
Le temps de réponse est bon (peut être liè surtout au performance des bibliothèques plus que la vitesse du processeur et à l'adéquation entre la bibliothèque utilisée et l'application?). La bibliothèque Audio.h est assez lourde. Elle est dédiée (en association avec une carte "son" PJRC SGTL5000") pour des applications complexes de mixage, d'effets sonores et de calcul (Transformée de Fourier).
 La capacité mémoire est à la fois trop importante pour de bruitages de type EncodeAudio" (voir 2), mais pas suffisante pour des sons complexes et de longues durées : Il faudrait à priori entre 500 Ko et 2Mo de Flash (en utilisant le codage "wav2sketch").

4) - Arduino Nano + Carte SD + Bibliothèque "TMRpcm.h"- Sortie PWM:
Cette architecture ressemble à la 1) - mais la bibliothèque utilisée est différente. Le temps de réponse est bon (pas de temps d'attente). Le manque de mémoire est compensé par la carte SD. Je crois que je vais choisir cette configuration.
Il me reste le choix entre 2 possibilités :
        4.1) Carte Arduino Nano (Décodage DCC + moteur + éclairage) + Carte Arduino Nano (Décodage DCC + commande "son") + Carte SD
               -> Problème de synchronisation avec l'arrivée d'une trame dcc valide pour le "son" de la locomotive) -> interruption ??

        4.2) Carte Arduino Nano (Décodage DCC + moteur + éclairage) + Carte Arduino Nano (piloté en liaison série Tx/Dx par le 1er Arduino Nano) + Carte SD.--> reste à essayer
              -> Je pense que la synchronisation entre la commande "son" (provenant du premier Arduino) et la lecture des "sons" sur le deuxième Arduino sera plus facile :  ??

80
Composants / Re : Teensy 3.1, 3.2 - Sonorisation locomotive
« le: janvier 16, 2018, 07:51:30 pm »
Dans le code que j'ai intégré dans mon message, je n'ai pas mis la totalité des fichiers "son" pour éviter de faire exploser mon post (> 192 ko).
J'ai remplacé une partie des fichiers "son" par des petits points.

81
Composants / Re : Teensy 3.1, 3.2 - Sonorisation locomotive
« le: janvier 15, 2018, 01:17:11 pm »
Le simple fait de faire un copier/coller du programme utilise 236 Ko dans "NotePad".

82
Composants / Re : Teensy 3.1, 3.2 - Sonorisation locomotive
« le: janvier 14, 2018, 02:11:52 pm »
Ok, je vais voir pour EEPROM.

Mes fichiers son en *.wav (8 bits PCM) avant conversion par EncodeAudio prennent au total environ 110 Ko.

83
Composants / Re : Teensy 3.1, 3.2 - Sonorisation locomotive
« le: janvier 13, 2018, 11:17:29 pm »
Si j'ai bien compris, sur le teensy, il n y a pas d'équivalent de la bibliothèque EEPROM.h.

84
Composants / Re : Teensy 3.1, 3.2 - Sonorisation locomotive
« le: janvier 13, 2018, 02:14:16 pm »
1) sur la base du template que tu m'as donné, j'ai créé un fonction par son (je pense que ce sera plus lisible lorsque le son sera intégré dans le décodeur "NmraDcc".

2) Il y a certes plus de mémoires dans le Teensy (256 k), mais c'est malgré un peu juste. Je pense que pour être vraiment à l'aise, il faudrait entre 2 à 4 Mo. Il faut donc optimiser la taille des tableaux "son".
Le code en 3) donne le résultat de compilation :
Le croquis utilise 199700 octets (76%) de l'espace de stockage de programmes. Le maximum est de 262144 octets.
Les variables globales utilisent 3468 octets (5%) de mémoire dynamique, ce qui laisse 62068 octets pour les variables locales. Le maximum est de 65536 octets.

Même en déclarant les tableaux "son" en "const"
De plus  sur le Teensy, contrairement à l'arduino, ce n'est pas évident de gérer" manuellement" la mémoire Flash.

3)
IntervalTimer myTimer;

const int StartLokBR99[] PROGMEM = { // from EncodeAudio
  39, 26, 26, 62, 80, 97, 90, 59
};

const int BrakeLokBR99[] PROGMEM = { // from EncodeAudio
122, 143, 160, 164, 159, 143, 138, 131
};

const int SiffletLokBR99[] PROGMEM = { // from EncodeAudio
12, 68, 109, 132, 167, 195, 167, 142, 137, 174, 184,
};
 
const int MarcheLokBR99[] PROGMEM = { // from EncodeAudio
124, 128, 134, 124, 100, 100, 113, 110, 118, 145,
};

const int ClocheLokBR99[] PROGMEM = { // from EncodeAudio
130, 123, 118, 123, 128, 128, 128, 130, 135, 132, 130,
};

const int StandbyLokBR99[] PROGMEM = { // from EncodeAudio
130, 134, 135, 131, 124, 121, 122, 125, 129, 131

unsigned int echantillonCourant = 0;
 
void BrakeLok(){
        analogWrite(A14, BrakeLokBR99[echantillonCourant++]);
        if (echantillonCourant >= sizeof(BrakeLokBR99)/sizeof(int)) {
        echantillonCourant = 0;
        }
}

 void SiffletLok(){
        analogWrite(A14, SiffletLokBR99[echantillonCourant++]);
        if (echantillonCourant >= sizeof(SiffletLokBR99)/sizeof(int)) {
        echantillonCourant = 0;
        }
}

void StartLok(){
        analogWrite(A14, StartLokBR99[echantillonCourant++]);
        if (echantillonCourant >= sizeof(StartLokBR99)/sizeof(int)) {
        echantillonCourant = 0;
        }
}

  void MarcheLok(){
        analogWrite(A14, MarcheLokBR99[echantillonCourant++]);
        if (echantillonCourant >= sizeof(MarcheLokBR99)/sizeof(int)) {
        echantillonCourant = 0;
        }
}
void StandbyLok(){
        analogWrite(A14, StandbyLokBR99[echantillonCourant++]);
        if (echantillonCourant >= sizeof(StandbyLokBR99)/sizeof(int)) {
        echantillonCourant = 0;
       }
}

void ClocheLok (){
        analogWrite(A14, ClocheLokBR99[echantillonCourant++]);
        if (echantillonCourant >= sizeof(ClocheLokBR99)/sizeof(int)) {
        echantillonCourant = 0;
        }
}
void setup(){
       analogWriteResolution(8);
       myTimer.begin(StartLok, 500);
       myTimer.begin(BrakeLok, 125);
       myTimer.begin(SiffletLok, 125);
       myTimer.begin(ClocheLok, 125);
       myTimer.begin(StandbyLok, 125);
}

void loop()
{
}


85
Composants / Re : Teensy 3.1, 3.2 - Sonorisation locomotive
« le: janvier 11, 2018, 09:05:27 pm »
Merci, ça marche super bien.
En faisant varier les microseconds dans
myTimer.begin(function, microseconds); le son de la locomotive accélère ou ralenti.

86
Composants / Re : Teensy 3.1, 3.2 - Sonorisation locomotive
« le: janvier 11, 2018, 03:43:54 pm »
Merci pour ta patience.
Je vais analyser tout cela.

87
Composants / Re : Teensy 3.1, 3.2 - Sonorisation locomotive
« le: janvier 11, 2018, 10:46:02 am »
Bonjour et merci pour tes commentaires :
1) Création de la fonction ReadSound : elle est censée (c'est ce que j'ai essayé de faire!) avoir pour argument un tableau d'échantillons de son dont je ne connais pas à priori la taille.
Cette fonction devrait pouvoir en effet s'appliquer sur n’importe quel tableau de son (donc avec des tailles variables).

2) Ok, à vrai dire, je suis un peu perdu avec les déclarations car le  tableau de son généré par EncodeAudio est un "unsigned char" alors que AnalogWrite n'admet que les "int".

3) Ok, en y réfléchissant, tu as raison.

4) Je pensais que l'instruction suivante suffisait :
       myTimer.begin(ReadSound(SoundArray[sizeof(SoundArray)]), 125); // 125 MicroS -> 8 kHz

88
Composants / Re : Teensy 3.1, 3.2 - Sonorisation locomotive
« le: janvier 11, 2018, 12:01:27 am »
J'ai essayé d'utiliser la fonction "IntervalTimer", mais, je dois certainement très mal m'y prendre pour implémenter la fonction de lecture du tableau "son" et l'envoi de l'échantillon vers la pin A14 ( DAC ).
IntervalTimer myTimer;
  int SoundArray[sizeof(SoundArray)] ;
  int StartLok[] PROGMEM = { // from EncodeAudio
  39, 26, 26, 62, 80, 97, 90,
  };
 
    void ReadSound(int SoundArray[sizeof(SoundArray)]){ // Déclaration Fonction : lit un échatillon et l'envoi sur le DAC pin A14
          for(int i = 0; i < sizeof(SoundArray); i++){
          analogWrite(A14, SoundArray[i]);
          Serial.println(SoundArray[i]);
          return void;
          }
  }
void setup(){
       Serial.begin(9600);
       analogWriteResolution(8);  // analogWrite value 0 to 256 (8 by default)
}

void loop(){
       for(int i = 0; i < sizeof(StartLok); i++){
       SoundArray[i] = StartLok[i]
       }
       myTimer.begin(ReadSound(SoundArray[sizeof(SoundArray)]), 125); // 125 MicroS -> 8 kHz

Teensy_Sound_PWM_V2:2: error: 'SoundArray' was not declared in this scope
 int SoundArray[sizeof(SoundArray)] ;                      ^

Teensy_Sound_PWM_V2:7: error: 'SoundArray' was not declared in this scope
     void ReadSound(int SoundArray[sizeof(SoundArray)]){ // Déclaration Fonction : lit un échatillon et l'envoi sur le DAC pin A14                                   

Teensy_Sound_PWM_V2:7: error: 'SoundArray' was not declared in this scope
     void ReadSound(int SoundArray[sizeof(SoundArray)]){ // Déclaration Fonction : lit un échatillon et l'envoi sur le DAC pin A14                                       

Teensy_Sound_PWM_V2: In function 'void ReadSound(...)':
Teensy_Sound_PWM_V2:8: error: 'SoundArray' was not declared in this scope
           for(int i = 0; i < sizeof(SoundArray); i++){

Teensy_Sound_PWM_V2:11: error: expected primary-expression before 'void'
           return void;

Teensy_Sound_PWM_V2:11: error: return-statement with a value, in function returning 'void' [-fpermissive]
Teensy_Sound_PWM_V2:11: error: expected ';' before 'void'
Teensy_Sound_PWM_V2:11: error: declaration does not declare anything [-fpermissive]
Teensy_Sound_PWM_V2: In function 'void loop()':
Teensy_Sound_PWM_V2:21: error: 'SoundArray' was not declared in this scope
 int SoundArray[sizeof(SoundArray)] ;

Teensy_Sound_PWM_V2:22: warning: comparison between signed and unsigned integer expressions
         for(int i = 0; i < sizeof(StartLok); i++){
               
'SoundArray' was not declared in this scope

89
Composants / Re : Teensy 3.1, 3.2 - Sonorisation locomotive
« le: janvier 09, 2018, 11:44:22 am »
1) Ok, pour l'instant, j'ai installé, pour les essais, le petit haut-parleur directement sur la sortie du Teensy (avec un condensateur de 10 MicroF placé en série) :
le son est faible, mais suffisant pour vérifier le son.
Par la suite, je mettrais effectivement un LM386 ou une petite carte intégrant un LM386.

2) J'aimerai utiliser "EncodeAudio" (8 bits-8kHz) pour piloter le DAC mais, "EncodeAudio" fournit du "const unsigned char" et le DAC n'accepte que de l' "int" (AnalogWrite (n°pin, int ->  0 to 256) ?

 3) A priori, la résolution du DAC peut être spécifiée :  analogWriteResolution ( 8 ) ;  // analogWrite value 0 to 256 (8 by default)

90
Composants / Re : Teensy 3.1, 3.2 - Sonorisation locomotive
« le: janvier 08, 2018, 03:40:00 pm »
Ok, Merci.

Quand j'intègre le fichier "son" directement dans le programme, c'est uniquement une étape  pour vérifier que "ça marche"sur le principe.
Après je crée le *.h et *.cpp des fichiers audio et je les copie dans le répertoire.
Je rajoute les <include *.h> dans  le *.ino.


Etat d’avancement du projet (provisoire)

Les fichiers "son" originaux sont convertis à l'aide de"Audacity.
1) Arduino + *.wav + carte SD + sortie PWM
Avantages :
Bonne qualité de son
Simplicité de gestion des fichiers son : *.wav
Capacité Mémoire (directement liée à la capacité de la carte SD)
Inconvénients :
« Blanc » à chaque changement de lecture de fichier « sons »
#include <SD.h>
2) Arduino + EncodeAudio + Bibliothèque <PCM.h> + sortie PWM
Avantages :
Qualité de son moyenne mais acceptable pour réaliser du bruitage (8 bits – 8kHz)
Fichiers « son » codé avec EncodeAudio -> fichiers « son » de petite taille

Inconvénients :
Essentiellement lié au fait que l’arduino ne possède que peu de mémoire (Flash ou RAM)
#include <PCM.h>
…………………………………………
const unsigned char sample1[] PROGMEM = {
39, 26, 26, 62, 80, 97, …………………………..
};
startPlayback(sample2, sizeof(sample2)); // sortie sur une pin PWM Arduino

3) Teensy + Wav2Sketch + Bibliothèque <Audio.h> + sortie PWM

Avantages :
Bonne qualité de son moyenne (8 bits ulaw– 11025 kHz) - ulaw est un codage qui permet d'avoir "un sentiment" de  résolution 12 bits en n'utilisant que 8 bits

Inconvénients :
Les fichiers obtenu par Wav2Sketch sont très lourds (taille supérieur au fichier *.wav original !!). Cela s’explique en partie parce que le fichier « son » est en fait codé en ASCII).

Donc, l’avantage de la capacité mémoire du Teensy est perdu
#include <Audio.h>
// Audio data converted from WAV file by wav2sketch
// Converted from Demarrage BR99.wav, using 44100 Hz, u-law encoding
const unsigned int Demarragebr99[29441] = {
0x0101CC00,0x17001724,0x2431362C,0x00800080,0xABA4980, ………………………..
};
……………………………….
       analogWriteFrequency(SoundPin, 8000); // Teensy pin 3 also changes to 8kHz
       analogWriteResolution(8);  // analogWrite value 0 to 256 (8 by default)
       analogWrite(SoundPin, DemarrageBR99); // sortie sur une pin PWM Teensy AnalogWrite (n° pin, int -> 0 to 256)

4) Teensy + EncodeAudio + sortie DAC – A14 (en cours d’essai)
Le problème est que EncodeAudio fournit un tableau de « const unsigned char » alors que le DAC demande des données « de type « int ». (analogWrite(A14, (int)val);
Réponse de Forun PJRC :
You could pretty easily make such a program, since 8 kHz is so very slow. Just use IntervalTimer to run a function that reads the next byte and do analogWrite. Also use analogWriteFrequency in setup() so the frequency is higher. Details here:

IntervalTimer:
https://www.pjrc.com/teensy/td_timin...rvalTimer.html

analogWriteFrequency:
https://www.pjrc.com/teensy/td_pulse.html


Pages: 1 ... 4 5 [6] 7 8 ... 14