recherche composant timer...

Super_Cinci:
Dans l'idée, ce serait une carte "bus" sur laquelle on enfiche des cartes filles, donc le 82C54 collait très bien : une carte pour 3 sorties PWM...

Surtout qu'avec l'alim et les mosfets, le boîtier sera assez grand (je pars de toutes façon sur un format 19", 1U si je peux en fonction de l'alim et des raccordements derrière...)

ok
tu peux voir aussi à légèrement moduler les filles :grin:

faire du 2voies avec un 20 pin ça doit etre possible (sans mux inutile là )
8+2+2
faire du 4 voies avec un 28 pin aussi (sans mux)
8+4+4

Au pire, un 328p peut me fournir 6 belles PWM et il me restera 14 pins pour data / adressage... mais je me disais qu'un composant tout fait eu été plus simple...

Super_Cinci:
Au pire, un 328p peut me fournir 6 belles PWM et il me restera 14 pins pour data / adressage... mais je me disais qu'un composant tout fait eu été plus simple...

bien d'accord , mais en logique cablée et à chaud je ne vois pas de compo //--->PWM

en clock interne (pas de BdT externe en "tripaille") , le 328P monte à quelle fréquence ?

Il y a bien un bidule qui s'appelle le FPGA qui permet de faire ce que l'on veut en logique synchrone et asynchrone.
C'est ce que je viens de commencer à regarder, mais la bête à l'air bien difficile à apprivoiser.
Je m'étais justement dit que ce serait sympa de faire dans un FPGA une dizaine (ou plus) de PWM à des fréquences différentes le tout géré en I2C pour pouvoir communiquer avec une carte Arduino.
C'est faisable mais au rythme où je progresse, et si je craque pas avant, ce ne sera pas fini pour l'été 2014 mais plus probablement en 2015 ou 2016.

Un FPGA c'est un ensemble de "éléments logiques élémentaires" que l'on peut associer comme on veut. Les associations étant mémorisées dans un fichier binaire implanté dans une eeprom externe.

La difficulté est que pour obtenir ce fichier binaire on utilise un langage qui ressemble à de la programmation mais qui n'en est absolument pas, même si on utilise des boucles if,for,while on est vraiment au niveau du matériel : une variable "registre" est plus à considérer comme une bascule D-Latch que comme en C un registre de 8 bits manipulable à volonté.

68tjs:
Il y a bien un bidule qui s'appelle le FPGA qui permet de faire ce que l'on veut en logique synchrone et asynchrone.
...

Bonjour 68tjs
oui d'accord avec toi , mais l'approche (idée--->"truc qui marche" ) sur base FPGA
n'est pas spécialement d'un abord facile en DIY , la chaine est "compliquée" (compo, environnement, base de test, autres ).
perso , dans ce cadre "ludique" , et à ce jour j'oublie :grin:
je changerais peut etre un jour d'avis, mais je suis sur que ce ne sera pas aujourd'hui 8)

Oui, ces logiques programmables, on nous en avait parlé à l'école, c'était avant l'arrivée fulgurante des proc RISK. du coup, les procs ont gagné. Dans le but de faire de la PWM avec, je suis pas sûr que ça soit vraiment capable, car ça fait vraiment beaucoup de fonctions logiques à enchaîner...

Tu es vraiment attaché à l'interface parallèle?

Parce qu'il y a des trucs comme ça http://www.ti.com/product/tlc5940 qui sont plutôt pas mal. Par contre en interface parallèle il n'y a rien avec PWM.

68tjs:
La difficulté est que pour obtenir ce fichier binaire on utilise un langage qui ressemble à de la programmation mais qui n'en est absolument pas, même si on utilise des boucles if,for,while on est vraiment au niveau du matériel : une variable "registre" est plus à considérer comme une bascule D-Latch que comme en C un registre de 8 bits manipulable à volonté.

En VHDL ou Verilog, on peut écrire très bas niveau (en décrivant la bascule et la porte) mais on peut aussi écrire assez haut niveau. Dans ce cas les variables peuvent représenter un registre de taille quelconque. Un compteur s'écrit alors comme une addition et l'écriture n'est pas très éloignée du C.

Il y a des chaînes de développement gratuites. Pour ce faire la main c'est pas mal.

Le problème c'est plutôt le prix. Un petit FPGA coûte déjà assez cher comparativement à un microcontrôleur. Et du coup il est plus économique de faire 10 PWM avec interface SPI dans 10 ATtiny que dans un FPGA.

Salut,

Un petit CPLD (pas un FPGA, faut rester calme hein :grin:) serait un candidat idéal pour solutionner ton probléme :wink:

Je te conseille le XC9572XL de Xilinx.
Il coute quelque chose comme 3.5€ sur Farnell si tu veut te faire une carte maison, ou ~13€ en format breakout toute préte de Dangerous Prototypes.

Niveaux spec c'est du bon (tout en restant simple) :

  • 72 "macrocells" (léger mais largement suffisant)
  • inputs "5volt tolerant" (mais pas toutes attention !)
  • prog par JTAG, soit avec un FT2232, soit avec une carte bus pirate (ou sinon avec n'importe quel "player XSVF" compatible Xilinx)

Niveau software c'est moins simple (c'est pas de la dév software, mais hardware).
-> Verilog, VHDL ou schéma (je te conseille le Verilog, mais surtout pas le mode schéma)
-> IDE "webpack ISE" de Xilinx (gratuit mais qui fait +6Go)

Si tu veut je peut te faire un morceau de Verilog et te le pré-compiler.
Donne moi juste tes spécifications concernant le fonctionnement et âpres un petit coup de simulation ça devrait être bon :wink:

NB: le Verilog peut sembler barbare et imbuvable aux premiers abords mais c'est vraiment pas compliqué en fait.

Bonjour,
Je n'ai pas lu l'ensemble des éléments ci-dessus mais j'ai utilisé : http://www.nxp.com/documents/data_sheet/PCA9685.pdf
@+
[EDIT]
TLC 5940 - PWM Driver - COM-10136 - SparkFun Electronics

Dans le but de faire de la PWM avec, je suis pas sûr que ça soit vraiment capable, car ça fait vraiment beaucoup de fonctions logiques à enchaîner.

FPGA Cyclone II Ep2c5 dispo sur Ebay autour de 7/20 €.
Ecrire une PWM tient en très peu de lignes en langage Verilog, le VHDL est plus verbeux et moins aisé en prime abord.

/*    PWM   Essais préliminaire   09/09/2013   */
module PWM(h,set,st);
	parameter M_bits = 8;   // Profondeur de réglage pour la PWM	
	input wire h ;
	input [M_bits-1:0] set ;
	output reg st = 1; 
	// variables internes
	reg [M_bits-1:0] compteur =0;
	
	always @ (posedge h)
	begin
		if (compteur < set) st<= 1 ;
		else 
			st<=0 ;
			compteur <= compteur +1;
	end
endmodule

Cela se simule bien mais il reste a l'intégrer avec une interface I2C et une "vraie" gestion des horloges et I/O et ça c'est pas gagné.
Parce que le compilateur/simulateur IcarusVerilog associé à GtkWave c'est simple mais pour la synthèse et la programmation du cyclone II d'Altera il faut passer par le logiciel Quartus dont la prise en main est complexe, le manuel fait 1700 pages.
D'autant que ce qui est simulable n'est pas forcément synthétisable : la simulation est proche du logiciel classique, la synthèse c'est du matériel pur.

Le problème c'est plutôt le prix. Un petit FPGA coûte déjà assez cher comparativement à un microcontrôleur. Et du coup il est plus économique de faire 10 PWM avec interface SPI dans 10 ATtiny que dans un FPGA.

Le prix sur Ebay un cyclone II avec un peu plus de 4000 élément logique, 16 multiplieurs, 2 Pll : entre 7 et 20€, d'accord les gros FPGA sont largement plus chers mais avec 4000 éléments logiques on peut déjà faire des choses.

Ce n'est bien évidement rentable que si on rempli un minimum le FPGA, si c'est juste pour 5 ou 6 PWM ce n'est pas intéressant mais il existe multitude de modèles de différentes fonctions sur le web : c'est là que j'y ai trouvé delui de la PWM qui entre nous a un défaut elle ne descend pas à 0, mais à 0001, mais il existe d'autre projets plus complexes qui fonctionnent parfaitement mais celui ci est suffisant pour apprendre à réaliser un FPGA.
Bien sur dans l'immédiat assembler des boîtiers "peut être plus économique", je mets des guillemets parce que si on ajoute le prix d'un PCB pour reporter les boîtiers ou même simplement une carte pastillée la différence de prix risque de s'amenuiser.

Un petit CPLD (pas un FPGA, faut rester calme hein :grin:

J'avais compris qu'un CPLD est en gros un FPGA moins complexe et avec l'Eeprom intégré.
C'est vraiment plus simple à maîtriser ?
Parce que si c'est le cas pour me faire la main autant débuter avec les marches les moins hautes possibles.

D'accord pour le verilog : le VHDL de l'avis commun serait plus adapté pour les réalisations complexes où le verilog s’essoufflerait mais le verilog est plus simple à maîtriser ça c'est vérifiable dès l'écriture du premier module.

Et il n'est pas interdit de réver : il est possible de synthétiser un micro-controleur dans un FPGA, j'ai même vu un exemple de micro-controleur AVR, hélas ce n'était pas un ATMega :drooling_face:

68tjs:
FPGA Cyclone II Ep2c5 dispo sur Ebay autour de 7/20 €.

Oula du calme !
Pas la peine de sortir le tank pour aller chercher une baguette à la boulangerie :grin:

68tjs:
Cela se simule bien mais il reste a l'intégrer avec une interface I2C et une "vraie" gestion des horloges et I/O et ça c'est pas gagné.

Il n'est pas question d'I2C ou d'autre chose qu'un port parallèle avec une clock, à moins que j'ai raté un truc ?

68tjs:
Le prix sur Ebay un cyclone II avec un peu plus de 4000 élément logique, 16 multiplieurs, 2 Pll : entre 7 et 20€, d'accord les gros FPGA sont largement plus chers mais avec 4000 éléments logiques on peut déjà faire des choses.

Moi je suis plutôt Xilinx que Altera, mais c'est vrai que les prix des Cyclones II semblent plus attractif que les 15/20/30€ pour un Spartan-3E de Xilinx.

68tjs:
J'avais compris qu'un CPLD est en gros un FPGA moins complexe et avec l'Eeprom intégré.

C'est un FPGA avec beaucoup moins de macrocells, pas de PLL, pas de DSP. Juste le strict minimum pour faire de la logique.

68tjs:
C'est vraiment plus simple à maîtriser ?
Parce que si c'est le cas pour me faire la main autant débuter avec les marches les moins hautes possibles.

Pour te faire la main mieux vaut commencer avec une carte de démo style BASYS2 pour les FPGA Xilinx.
Si tu sait faire du code pour FPGA tu pourras faire du code pour un CPLD sans probléme :wink:
L'avantage des cartes de démo c'est que t'as tout dessus : fpga, mémoire, boutons, leds, programmateurs, ...
(j'ai une carte BASYS2 version 250K pour ma part)

68tjs:
Et il n'est pas interdit de réver : il est possible de synthétiser un micro-controleur dans un FPGA, j'ai même vu un exemple de micro-controleur AVR, hélas ce n'était pas un ATMega :drooling_face:

Au choix :
CPU 32bits : Papilio RetroCade Synth
CPU AVR (compatible ATmega) : ArduinoCore
(plus d'info ici : http://papilio.cc/)

Il n'est pas question d'I2C ou d'autre chose qu'un port parallèle avec une clock, à moins que j'ai raté un truc ?]

Non tu n'as rien raté , c'est moi qui est resté bloqué sur mon idée : utiliser l'I2C pour utiliser le moins de pins possible sur un 328P.

@Super_Cinci: il te faudrait combien de sorties PWM ?
Avec les 72 macrocells du XC9572XL il semblerait qu'on puisse pas dépasser les 7 sorties @8bits.

Sinon pour les curieux voila à quoi ça ressemble un générateur de PWM 8 bits à 8 voies en Verilog :
(code testé sur carte physique et qui marche)

// Multi-channels PWM generator with parallel loading.
// By Fabien Batteix
// 
// Tested on BASYS2 board
//
module PwmGenerator(
    output wire [7:0]Pwm, // PWM output (output only)
    input wire Reset,     // Reset signal (active LOW)
    input wire Load,      // Load signal (active LOW)
    input wire Addr,      // Load address if LOW or data if HIGH
    input wire Clk,       // Clock signal
    input wire [7:0]Data  // Data bus (input only)
   );

    // Internal PWM values (8 registers x 8bits)
    reg [7:0]channels[7:0];

    // Internal counter (8 bits)
    reg [7:0]counter;
    
    // Internal address pointer (3 bits = 8 registers)
    reg [2:0]address;

    // At each clock front
    always @(negedge Clk)
    begin
        if(!Reset) // Reset pulse
            counter <= 0;
        else // Increment the counter
            counter <= counter + 1;
    end
    
    // At each front of Reset or Load pins
    always @(negedge Reset or negedge Load)
    begin
        if(!Reset) // Reset pulse
            begin
                channels[0] <= 0;
                channels[1] <= 0;
                channels[2] <= 0;
                channels[3] <= 0;
                channels[4] <= 0;
                channels[5] <= 0;
                channels[6] <= 0;
                channels[7] <= 0;
                address <= 0;
            end
        else // Load pulse
            begin
                if(!Addr) // Load Address
                    begin
                        address[0] <= Data[0];
                        address[1] <= Data[1];
                        address[2] <= Data[2];
                    end
                else // Load data
                    channels[address] <= Data;
            end
    end
    
    // Assign PWM output signals
    assign Pwm[0] = (channels[0] > counter);
    assign Pwm[1] = (channels[1] > counter);
    assign Pwm[2] = (channels[2] > counter);
    assign Pwm[3] = (channels[3] > counter);
    assign Pwm[4] = (channels[4] > counter);
    assign Pwm[5] = (channels[5] > counter);
    assign Pwm[6] = (channels[6] > counter);
    assign Pwm[7] = (channels[7] > counter);

endmodule
  • Fichier de contrainte pour les broches (pour carte BASYS2) :
# Pins constraint for BASYS2 board

NET "Clk" LOC = "B8"; # Bank = 0, Signal name = MCLK
NET "Clk" CLOCK_DEDICATED_ROUTE = FALSE;

NET "Pwm<7>" LOC = "G1" ;  # Bank = 3, Signal name = LD7
NET "Pwm<6>" LOC = "P4" ;  # Bank = 2, Signal name = LD6
NET "Pwm<5>" LOC = "N4" ;  # Bank = 2, Signal name = LD5
NET "Pwm<4>" LOC = "N5" ;  # Bank = 2, Signal name = LD4
NET "Pwm<3>" LOC = "P6" ;  # Bank = 2, Signal name = LD3
NET "Pwm<2>" LOC = "P7" ;  # Bank = 3, Signal name = LD2
NET "Pwm<1>" LOC = "M11" ; # Bank = 2, Signal name = LD1
NET "Pwm<0>" LOC = "M5" ;  # Bank = 2, Signal name = LD0

NET "Data<7>" LOC = "N3";  # Bank = 2, Signal name = SW7
NET "Data<6>" LOC = "E2";  # Bank = 3, Signal name = SW6
NET "Data<5>" LOC = "F3";  # Bank = 3, Signal name = SW5
NET "Data<4>" LOC = "G3";  # Bank = 3, Signal name = SW4
NET "Data<3>" LOC = "B4";  # Bank = 3, Signal name = SW3
NET "Data<2>" LOC = "K3";  # Bank = 3, Signal name = SW2
NET "Data<1>" LOC = "L3";  # Bank = 3, Signal name = SW1
NET "Data<0>" LOC = "P11"; # Bank = 2, Signal name = SW0

NET "Reset" LOC = "A7";    # Bank = 1, Signal name = BTN3
NET "Load"  LOC = "M4";    # Bank = 0, Signal name = BTN2
NET "Addr"  LOC = "C11";   # Bank = 2, Signal name = BTN1

skywodd:
@Super_Cinci: il te faudrait combien de sorties PWM ?

Bonsoir skywodd
je crois qu'il a évoqué 32 sorties

Artouste:
je crois qu'il a évoqué 32 sorties

Ha ok, moi je croyais que c'était le DMX qui avait 32 canaux :.

Mouai mouai mouai pour 32 canaux de PWM faudrait presque partir sur un petit ARM-CortexM0/3 en boitier 44/48 broches.
(histoire d'avoir un joli port 32 bits complet et un timer pour le refresh + SPI pour le contrôle)

skywodd:

Artouste:
je crois qu'il a évoqué 32 sorties

Ha ok, moi je croyais que c'était le DMX qui avait 32 canaux :.

Mouai mouai mouai pour 32 canaux de PWM faudrait presque partir sur un petit ARM-CortexM0/3 en boitier 44/48 broches.
(histoire d'avoir un joli port 32 bits complet et un timer pour le refresh + SPI pour le contrôle)

il confirmera

mais j'en suis là

...Dans mes données DMX, je reçois 1 valeur 8bits par canal (sur 512 possibles), donc une PWM 8 bits, c'est nikel. Côté nombre de sorties, j'imagine bien un truc genre 32 canaux...

perso et compte tenu de ce qui peut se passer en "spectacles" , je resterait sur du petit module basé sur du MCU tres abordable, facile a implanté, clock interne , en dip ,mais bon ça ce discute

merci les copains!

Pour le nombre de canaux, je n'ai pas encore choisi, tout dépend de mon stock et de ce que j'achèterai en plus (du RGB, ça serait top aussi!)

Le DMX, lui, il permet d'envoyer une trame de 512 données, soit adresser jusqu'à 512 canaux. Je n'irai pas jusque là. Mais j'ai déjà monté un UNO dans ma machine à fumée, et c'est à partir de ça que j'ai eu l'idée de monter un pupitre spécifique (émetteur qui insère des canaux dans une trame émise par une première console), et sur scène, des récepteurs, dont un qui va me gérer des leds.

j'aimerais monter ce genre de sunstrip : http://www.thomann.de/fr/showtec_sunstrip_active_dmx.htm, en général, on en met plusieurs à la verticale au fond de la scène. Ca sert à rien, mais on m'en demande tout le temps. Et vu le prix...

J'ai fait un premier montage, chaque plaque contient 20 modules de 300mW chacun, soit 6W (0,5A / 12V). Et ça pète grave, à 5m tu as encore du mal à les regarder en face.

Je compte donc pouvoir alimenter chaque plaque indépendamment, sur un strip, mais mettre des strips en // etc etc... Je dois avoir déjà de quoi monter 40 plaques dece genre, plus certainement bien d'autres encore, je n'ai pas ouvert tous les cartons...

Je regarde vos liens et vais tenter de me faire une idée. Le parallèle, c'est pour gagner du temps, car gérer un port série quand sur un autre y'a des données qui déboulent à 250kb/s en continu qu'il ne faut surtout pas mélanger ni rater (il n'y a pas d'adressage, il faut compter les octets reçus pour savoir où on en est, il y a juste un start tous les 512 octets)...

Idée en l'air comme ça.

Des ATtiny 45/85 programmés pour écouter le signal DMX et extraire un seul canal pour générer un unique signal PWM.
C'est modulaire, certes un peu cher si tu fait des 10aine de cartes mais ça ce discute.

Un gros µc qui fait tout VS plein de petit µc qui font juste un morceau. A voir.

skywodd:
Idée en l'air comme ça.

Des ATtiny 45/85 programmés pour écouter le signal DMX et extraire un seul canal pour générer un unique signal PWM.
C'est modulaire, certes un peu cher si tu fait des 10aine de cartes mais ça ce discute.

on en avait un peu discuté sur un de mes projets en cartons, mais en clock interne, je crois que l'on était arrivé à la conclusion
que le DMX et PWM n'etait pas possible avec une clock interne..

a retrouver


http://forum.arduino.cc/index.php?topic=172898.msg1285348#msg1285348