Le site de Steve

Configuration d'une imprimante multifonction DCP-9020CDW sous Gentoo GNU/Linux avec CUPS

Steve — 2015-10-10T18:13:46Z

PrÃ©-requis

Il faut que CUPS (net-print/cups) soit dÃ©jÃ installÃ© ainsi que l'outil de gestion de paquets Red Hat (app-arch/rpm).

Les fichiers pilote

CommenÃ§ons par tÃ©lÃ©charger les fichiers d'installation des pilotes suivants :
Pilote LPR
Pilote encapsulation CUPS

Installation des pilotes

Avant d'effectuer l'installation des deux paquets, il faut crÃ©er le rÃ©pertoire /var/spool/lpd
mkdir -p /var/spool/lpd
Puis l'installation des deux paquets peut-Ãªtre fait.

rpm -ihv --nodeps dcp9020cdwlpr-1.1.2-1.i386.rpm

rpm -ihv --nodeps dcp9020cdwcupswrapper-1.1.2-1.i386.rpm

Le filtre

Il reste Ã tÃ©lÃ©charger le filtre pour que CUPS puisse envoyer les donnÃ©es Ã l'imprimante.

wget -P /usr/libexec/cups/filter https://raw.githubusercontent.com/illwieckz/debian_copyist_brother/master/material/abstract/printers/generated_content/filter/brother_lpdwrapper_dcp9020cdw

chmod a+x /usr/libexec/cups/filter/brother_lpdwrapper_dcp9020cdw

Ajout de l'imprimante

AccÃ¨dons Ã l'interface de CUPS (http://127.0.0.1:631/).

Choisissions le lien Adding Printers and Classes dans la rubrique CUPS for Administrators.

CUPS propose l'imprimante dans la rubrique Discovered Network Printers que l'on sÃ©lectionne puis on clique sur Continue.

Les options, par dÃ©faut, permettent d'utiliser l'imprimante et il suffit de cliquer sur Continue.

Il faut sÃ©lectionner le modÃ¨le parmi la liste proposÃ©e et cliquer sur Add Printer.

On clique sur Query Printer for Default Options pour finaliser l'installation.

Conclusion

Je me suis basÃ© sur un article de Gentoo Wiki Archives [1] ainsi que des diffÃ©rents messages d'erreurs que j'ai rencontrÃ©.

[1] http://www.gentoo-wiki.info/HOWTO_Brother_Printer/Scanners

DynHost d'OVH avec une LiveBox Play d'Orange

Steve — 2015-09-11T20:42:05Z

Introduction

Je souhaitais rendre accessible un CubieTruck qui me sert pour Seafile (cloud privÃ©) et pour une application de domotique. Mon choix s'est portÃ© sur OVH avec sa solution DynHost incluse dans l'offre Nom de domaine.

Configuration de DynHost

Il faut Ã©videmment se connecter Ã son compte. On sÃ©lectionne ensuite le nom de domaine que l'on souhaite utiliser. Puis on choisit l'onglet DynHost.

LÃ , sur la droite, on choisit Ajouter un DynHost.

Une boÃ®te de dialogue apparaÃ®t dans laquelle on indique le sous-domaine ainsi que l'adresse IP actuelle de sa Livebox Play.

Maintenant, on va crÃ©er un identifiant pour pouvoir mettre Ã jour l'adresse IP de maniÃ¨re automatique. Pour cela, on choisit GÃ©rer les accÃ¨s sur la droite.

Toujours sur la droite, on sÃ©lectionne CrÃ©er un identifiant.

On saisit l'identifiant, le nom de sous-domaine ainsi que le mot de passe choisi.

C'est tout pour la partie DynHost. Un peu de patience est nÃ©cessaire avant que le sous-domaine soit accessible.
De plus, la page d'Adrin FURET [1] me fÃ »t d'un grand secours pour comprendre le service DynHost d'OVH.

Configuration de la Livebox Play

Ici, il faut aller dans la configuration avancÃ©e puis choisir configuration rÃ©seau sur la gauche. Moi, j'ai choisi de diriger tous les flux vers mon pare-feu avec la fonction DMZ de la Livebox Play.

Je n'ai rien fait de plus pour ce point-lÃ .

Le script de mise Ã jour

Ce script est fortement inspirÃ© par celui de Zwindler [2]. J'y ai corrigÃ© quelques bourdes et, surtout, remplacer l'appel Ã des services de type Â« http://ifconfig.me/ipÂ» et Â« http://checkip.dyndns.com/Â» par l'appel Ã un json via curl [3].
Il comporte aussi une condition qui limite la taille du fichier de consignation.
Je vous livre le rÃ©sultat ci-dessous :

#! /bin/bash

# Mainly inspired by DynHost script given by OVH

# New version by zwindler (zwindler.fr/wordpress)

# Newer version stores the return code in the logfile (smuller@s-muller.fr)

#

# Initial version was doing nasty grep/cut on local ppp0 interface

#

# This coulnd't work in a NATed environnement like on ISP boxes

# on private networks.

#

# Also got rid of ipcheck.py thanks to mafiaman42

#

# This script uses curl to get the public IP, and then uses wget

# to update DynHost entry in OVH DNS

#

# Logfile: dynhost.log

#

# CHANGE: "HOST", "LOGIN" and "PASSWORD" to reflect YOUR account variables



HOST="sous-domaine"

LOGIN="identifiant"

PASSWORD="mot de passe"

LOG_PATH="chemin pour le stockage des fichiers de journalisation"

LIVEBOX="adresse IP de la Livebox Play"



echo ---------------------------------- >> $LOG_PATH/dynhost.log

echo `date` >> $LOG_PATH/dynhost.log

echo 'DynHost' >> $LOG_PATH/dynhost.log



TMPFILE=`tempfile`



IP=`curl -s -X POST -H "Content-Type: application/json" -d '{"parameters":{}}' http://$LIVEBOX/sysbus/NMC:getWANStatus | sed -e 's/.*"IPAddress":"\(.*\)","Remo.*/\1/g'`

IPv6=`curl -s -X POST -H "Content-Type: application/json" -d '{"parameters":{}}' http://$LIVEBOX/sysbus/NMC:getWANStatus | sed -e 's/.*"IPv6Address":"\(.*\)","IPv6D.*/\1/g'`

OLDIP=`dig +short @$LIVEBOX $HOST`



if [ $IP ]; then
 if [ $OLDIP != $IP ]; then
 echo -n 'Old IP: ' >> $LOG_PATH/dynhost.log
 echo $OLDIP >> $LOG_PATH/dynhost.log
 echo -n 'New IP: ' >> $LOG_PATH/dynhost.log
 echo $IP >> $LOG_PATH/dynhost.log
 echo 'Try to update!' >> $LOG_PATH/dynhost.log
 wget -q -O $TMPFILE "http://www.ovh.com/nic/update?system=dyndns&hostname=$HOST&myip=$IP" --user="$LOGIN" --password="$PASSWORD" >> $LOG_PATH/dynhost.log
 RESULT=`cat $TMPFILE`
 echo "Result: $RESULT" >> $LOG_PATH/dynhost.log
 if [[ $RESULT =~ ^(good|nochg).* ]]; then
 echo ---------------------------------- >> $LOG_PATH/dynhost-changes.log
 echo `date` >> $LOG_PATH/dynhost-changes.log
 echo "New IP : $IP" >> $LOG_PATH/dynhost-changes.log
 fi
 rm $TMPFILE
 else
 echo "IP $HOST $OLDIP is identical to WAN $IP! No update required." >> $LOG_PATH/dynhost.log
 fi

else
 echo 'WAN IP not found. Exiting!' >> $LOG_PATH/dynhost.log

fi



# Some implementations of 'wc' use tabulation as separator others use space.

NB_LINES=`wc -l $LOG_PATH/dynhost.log | cut -d" " -f1 | cut -f1`

if [ "$NB_LINES" -gt "200" ]; then
 tail -n100 $LOG_PATH/dynhost.log >> $TMPFILE
 mv $TMPFILE $LOG_PATH/dynhost.log

fi

crontab

J'ai simplement rajoutÃ© la ligne ci-dessous au fichier /etc/crontab afin de vÃ©rifier le changement d'adresse IP toutes les 5 minutes :

*/5 * * * * root /chemin vers le script executable/dynhost

Conclusion

La mise en Å“uvre n'est pas bien compliquÃ© mais la recherche de tous les Ã©lÃ©ments a Ã©tÃ© chronophage d'oÃ¹ cette synthÃ¨se qui, je l'espÃ¨re, profitera au plus grand nombre. J'allais oublier, j'ai trouvÃ© les codes de retour du moteur DynDNS sur le site de Matthias PIERSCHEL [4]

[1] http://adrienfuret.fr/2015/05/nas-synology-ddns-ovh/

[2] http://zwindler.fr/wordpress/2014/09/22/mise-a-jour-de-votre-dns-chez-ovh-avec-dynhost/

[3] http://communaute.orange.fr/t5/ma-connexion/Recup%C3%A9ration-de-l-IP-WAN-d-une-Livebox-Play-noire/td-p/226035

[4] https://www.pierschel.com/en/software-blog/11-user-manuals/33-dyndny-returncodes-en?hitcount=0

Filtre numÃ©rique du 1er ordre

Steve — 2010-06-19T07:21:45Z

Introduction

La description qui suit permet de filtrer des Ã©chantillons en temps rÃ©el. Le filtre est implÃ©mentÃ© sous sa forme dit directe.

La synthÃ¨se du filtre (transformÃ©e bilinÃ©aire)

CommenÃ§ons par un peu de thÃ©orie afin de transformer un filtre continu vers un filtre discret.

La forme gÃ©nÃ©rale du filtre dans le domaine de Laplace est :

En substituant par dans , on obtient :

On obtient :

Posons :

On obtient l'Ã©quation aux diffÃ©rences :

Et finalement, l'Ã©quation aux diffÃ©rences qui sera implÃ©mentÃ©e dans la description VHDL :

La description

L'implÃ©mentation se base sur trois multiplieur sÃ©rie et un additionneur sÃ©rie.
La description se dÃ©compose en quatre parties :
le multiplieur sÃ©rie,
l'additionneur sÃ©rie,
le registre Ã dÃ©calage de sortie et
le sÃ©quenceur.

Le multiplieur sÃ©rie

Le multiplieur est sous une forme sÃ©quencÃ©e qui nÃ©cessite 37 coups d'horloge afin de produire le rÃ©sultat. Le signal 'start' dÃ©marre le processus de multiplication. Le bus 'selector' provient d'un compteur (qui est mutualisÃ© par plusieurs instances du multiplieur) et fournit un auxiliaire dans l'opÃ©ration de multiplication. 'a' et 'b' sont respectivement le multiplicande et le multiplicateur. Le produit se prÃ©sente sous la forme d'un flux sÃ©rie, idÃ©al pour alimenter un additionneur sÃ©rie.

library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity serialMultiplier is port ( clr : in std_logic; clk : in std_logic; start : in std_logic; a : in std_logic_vector(17 downto 0); b : in std_logic_vector(17 downto 0); selector : in std_logic_vector(5 downto 0); complete : out std_logic; r : out std_logic); end serialMultiplier; architecture Behavioral of serialMultiplier is signal internal : std_logic_vector(17 downto 0); signal intermediary : std_logic_vector(18 downto 0); signal bitResult : std_logic_vector(17 downto 0); signal multiplier : std_logic; begin process (clr, clk) begin if (clr = '1') then internal <= (others => '0'); complete <= '0'; r <= '0'; elsif (rising_edge(clk)) then if (start = '0') then internal <= (others => '0'); complete <= '0'; r <= '0'; elsif ((selector /= "100100") and (selector /= "100101"))then internal <= intermediary(18 downto 1); r <= intermediary(0); elsif (selector = "100100") then r <= intermediary(0); complete <= '1'; end if; end if; end process; bitResult <= a when (multiplier = '1') else (others => '0'); multiplier <= b(0) when (selector = "000000") else b(1) when (selector = "000001") else b(2) when (selector = "000010") else b(3) when (selector = "000011") else b(4) when (selector = "000100") else b(5) when (selector = "000101") else b(6) when (selector = "000110") else b(7) when (selector = "000111") else b(8) when (selector = "001000") else b(9) when (selector = "001001") else b(10) when (selector = "001010") else b(11) when (selector = "001011") else b(12) when (selector = "001100") else b(13) when (selector = "001101") else b(14) when (selector = "001110") else b(15) when (selector = "001111") else b(16) when (selector = "010000") else b(17) when (selector = "010001") else '0'; intermediary <= ('0' & internal) + ('0' & bitResult); end Behavioral;

L'additionneur sÃ©rie

L'additionneur sÃ©rie prÃ©sentÃ© ici est basÃ© sur un additionneur complet avec une rÃ©troaction des retenues. Il additionne trois termes correspondant aux produits des multiplieurs dÃ©crits ci-dessus. La somme se prÃ©sente sous un flux sÃ©rie.

library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity serialAdder is port ( clr : in STD_LOGIC; clk : in STD_LOGIC; sclr : in STD_LOGIC; ce : in STD_LOGIC; a : in STD_LOGIC; b : in STD_LOGIC; c : in STD_LOGIC; r : out STD_LOGIC); end serialAdder; architecture Behavioral of serialAdder is signal ea : std_logic_vector(2 downto 0); signal eb : std_logic_vector(2 downto 0); signal ec : std_logic_vector(2 downto 0); signal eci : std_logic_vector(2 downto 0); signal ci : std_logic_vector(1 downto 0); signal co : std_logic_vector(1 downto 0); signal temp : std_logic_vector(2 downto 0); begin ea <= "00" & a; eb <= "00" & b; ec <= "00" & c; eci <= "0" & ci; temp <= ea + eb + ec + eci; r <= temp(0); co <= temp(2 downto 1); process (clr, clk) begin if (clr = '1') then ci <= (others => '0'); elsif (rising_edge(clk)) then if (sclr = '1') then ci <= (others => '0'); elsif (ce = '1') then ci <= co; end if; end if; end process; end Behavioral;

Le registre Ã dÃ©calage de sortie

library ieee; use ieee.std_logic_1164.all; entity outputShifter is port ( clr : in std_logic; clk : in std_logic; shift : in std_logic; indata : in std_logic; outdata : out std_logic_vector(19 downto 0)); end outputShifter; architecture behavioral of outputShifter is signal internal : std_logic_vector(outdata'range); begin process (clr, clk) begin if (clr = '1') then internal <= (others => '0'); elsif (rising_edge(clk)) then if (shift = '1') then internal <= indata & internal(19 downto 1); end if; end if; end process; outdata <= internal; end behavioral;

Le sÃ©quenceur du filtre

Le filtre

Round-robin pour FPGA

Steve — 2009-11-22T17:07:00Z

Introduction

La description qui suit permet de partager une ressource entre plusieurs processus dans une FPGA. Elle est basÃ©e sur deux dÃ©caleurs Ã barillet et une pseudo-bascule RSC par processus.

La description

La description est paramÃ©trable en nombre d'entrÃ©es donc de processus.

Le premier dÃ©caleur permet la rÃ©organisation des candidats Ã l'accÃ¨s de la ressource partagÃ©e en fonction du prÃ©cÃ©dent Ã©lu. DÃ¨s que le prÃ©cÃ©dent Ã©lu libÃ¨re la ressource, elle sera affectÃ©e au prochain candidat. Cela permet d'Ã©viter une appropriation par un seul des candidats.

Le second dÃ©caleur effectue l'opÃ©ration inverse du premier afin que chaque allocation soit Ã associer Ã la bonne requÃªte.

La bascule RSC mÃ©morise le processus Ã©lu. Lorsque le processus n'a plus besoin d'accÃ©der Ã la ressource, il remet la cellule RSC Ã zÃ©ro afin de permettre Ã un autre processus d'avoir l'accÃ¨s Ã la ressource.

library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity round_robin is generic ( width : integer := 4); port ( clr : in std_logic; clk : in std_logic; req : in std_logic_vector(width - 1 downto 0); ack : in std_logic_vector(width - 1 downto 0); grant : out std_logic_vector(width - 1 downto 0)); end round_robin; architecture Behavioral of round_robin is signal choice : std_logic_vector(req'range); signal mask : std_logic_vector(req'range); signal decision : std_logic_vector(req'range); signal internal : std_logic_vector(req'range); constant zero : std_logic_vector(req'range) := (others => '0'); signal entrance : std_logic_vector(req'range); signal elected : std_logic_vector(req'range); signal req_doubled : std_logic_vector(2 * width - 2 downto 0); signal decision_doubled : std_logic_vector(2 * width - 1 downto 1); begin req_doubled <= req(width - 2 downto 0) & req; choice <= entrance - 1; mask <= not(entrance); decision <= choice or mask; decision_doubled <= decision & decision(width - 1 downto 1); process (clr, clk) begin if (clr = '1') then internal <= (others => '0'); elsif (rising_edge(clk)) then if (internal = zero) then internal <= not(elected); elsif (internal = ack) then internal <= not(elected); end if; end if; end process; process (internal, req_doubled) variable temp : std_logic_vector(req'range); begin temp := req_doubled(width - 1 downto 0); for index in internal'range loop if (internal(index) = '1') then temp := req_doubled(width + index - 1 downto index); end if; end loop; entrance <= temp; end process; process (internal, decision_doubled) variable temp : std_logic_vector(req'range); begin temp := decision_doubled(2 * width - 1 downto width); for index in internal'range loop if (internal(index) = '1') then temp := decision_doubled(2 * width - index - 1 downto width - index); end if; end loop; elected <= temp; end process; grant <= internal; end Behavioral;

Remarque

L'ordonnanceur tel qu'il est dÃ©crit permet d'effectuer une dÃ©cision par coup d'horloge. Par exemple, un processus est prÃªt Ã rendre la main, au prochain coup d'horloge un autre processus est autorisÃ© Ã accÃ©der Ã la ressource.

Conclusion

J'ai synthÃ©tisÃ© la description sous plusieurs outils et pour plusieurs cibles.

Nombre d'entrÃ©es	Outil de synthÃ¨se	Cible	PÃ©riode minimum	Niveau logique
4	ISE 11.3	XC3S400-5PQ208	6,213 ns	4
8	ISE 11.3	XC3S400-5PQ208	9,887 ns	7
4	Quartus 9.0sp2	EP3C40Q240C8	5,017 ns	?
8	Quartus 9.0sp2	EP3C40Q240C8	9,943 ns	?
4	Quartus 9.0sp2	EP3C16Q240C8	4,796 ns	?
8	Quartus 9.0sp2	EP3C16Q240C8	11,011 ns	?

Attention : Ces rÃ©sultats ne sont donnÃ©s qu'Ã titre indicatif. En effet, il n'y a pas de contraintes sur l'affectation des broches.

Un daemon UNIX en Python

Steve — 2007-12-30T11:21:35Z

Introduction

Cette classe permet de crÃ©er aisÃ©ment un daemon python. Pour l'utiliser, il suffit de dÃ©river de cette classe et de rajouter une mÃ©thode launch(self). Elle gÃ¨re un systÃ¨me de verrou basÃ© sur un fichier ainsi qu'une mÃ©thode permettant de tuer le daemon.

Les mÃ©thodes de la classe

__init__

Cette mÃ©thode instancie la classe et elle initialise quelques variables.

_daemonExists

Cette mÃ©thode teste l'existence du fichier verrou.

_lock

Cette mÃ©thode crÃ©e le fichier verrou et elle Ã©crit le pid du daemon.

_unlock

Cette mÃ©thode ferme le fichier verrou puis elle efface le fichier verrou.

_fork

Cette mÃ©thode crÃ©e le daemon.

_run

Cette mÃ©thode doit Ãªtre surchargÃ©. Cette mÃ©thode effectue le travail en boucle. Elle doit vÃ©rifier que la variable "_loop" ne passe pas Ã "False".

__signalHandler

Cette mÃ©thode est le gestionnaire de signaux. Seul le signal SIGTERM est interceptÃ© afin de pouvoir terminer le daemon proprement. Elle modifie la variable "_loop" Ã "False".

setOutput

Cette mÃ©thode permet de rediriger les flux stdout et stderr vers des fichiers que l'on aura crÃ©e.

launch

Cette mÃ©thode effectue tous les appels nÃ©cessaires Ã la crÃ©ation du daemon. Elle finit par appeler la mÃ©thode "_run". Si le daemon est arrÃªtÃ©, elle restaure les flux et supprime le fichier verrou grÃ¢ce Ã la mÃ©thode "_unlock".

Exemple d'utilisation

from pyUnixDaemon import pyUnixDaemon from datetime import datetime from os import getpid from time import sleep import sys class pyTest(pyUnixDaemon): def __init__(self, lockFilename): pyUnixDaemon.__init__(self, lockFilename) def _run(self): while(self._loop): print "%s - %s" % (datetime.now(), getpid()) sys.stdout.flush() sleep(5) daemon = pyTest("/var/run/pyTest.pid") daemon.setOutput(open("/var/log/pyTest.log", "a")) daemon.launch()

Cette exemple Ã©crit, dans le fichier "/var/log/pyTest.log", l'heure courante ainsi que le "pid" du processus. Cette opÃ©ration est effectuÃ© toutes les cinq secondes.

Conclusion

Cette classe devrait permettre de dÃ©velopper trÃ¨s rapidement des scripts Python qui seront utilisÃ©s comme daemon.

ContrÃ´leur I2C

Steve — 2007-06-23T08:09:58Z

Introduction

La description qui suit est un contrÃ´leur de bus I2C Ã©lÃ©mentaire. Il ne gÃ¨re pas le mode multi-maÃ®tre, toutefois le Â« clock strechingÂ » est pris en charge.
La frÃ©quence de transmission est dÃ©fini grÃ¢ce Ã un dÃ©compteur externe Ã la description.

DÃ©coupage

Le contrÃ´leur est dÃ©coupÃ© en plusieurs sÃ©quenceurs dont la liste exhaustive est la suivante :
le sÃ©quenceur de requÃªte,
le dÃ©tecteur d'Ã©vÃ©nements de bus,
le sÃ©quenceur de bus,
le contrÃ´leur de bus et
une bascule RSC.

Chaque unitÃ© sera dÃ©crite dans les dÃ©tails ci-dessous.

Le sÃ©quenceur de requÃªte

Cette description prend en charge le sÃ©quencement des actions sur le bus, Ã savoir :
la condition de â€œStartâ€ (start_req),
la condition de â€œRepeat Startâ€ (repeat_start_req),
la condition de â€œStopâ€ (stop_req) et
la gÃ©nÃ©ration de l'horloge lors de la transmission des donnÃ©es (byte_req).

Le bloc a besoin de connaÃ®tre :
l'Ã©tat du bus (busy) et
l'Ã©tat de l'action (complete).

Et il fournit :
la demande d'exÃ©cution de la condition de â€œStartâ€ (process_start),
la demande d'exÃ©cution de la condition de â€œRepeat Startâ€ (process_repeat_start),
la demande d'exÃ©cution de la condition de â€œStopâ€ (process_stop),
la demande d'exÃ©cution du signal d'horloge et
l'Ã©tat d'activitÃ© des actions de bus.

library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity bus_state_seq is port ( \~CLR\ : in std_logic; clk : in std_logic; busy : in std_logic; start_req : in std_logic; repeat_start_req : in std_logic; stop_req : in std_logic; byte_req : in std_logic; complete : in std_logic; in_progress : out std_logic; process_start : out std_logic; process_repeat_start : out std_logic; process_stop : out std_logic; process_byte : out std_logic); end bus_state_seq; architecture Behavioral of bus_state_seq is signal state : std_logic_vector(5 downto 0); constant idle_state : std_logic_vector(state'range) := "000000"; constant start_state : std_logic_vector(state'range) := "010001"; constant busy_state : std_logic_vector(state'range) := "100000"; constant repeat_start_state : std_logic_vector(state'range) := "010010"; constant byte_state : std_logic_vector(state'range) := "011000"; constant stop_state : std_logic_vector(state'range) := "010100"; begin process (\~CLR\, clk) begin if (\~CLR\ = '0') then state <= idle_state; elsif (rising_edge(clk)) then case state is when idle_state => if ((start_req = '1') and (busy = '0')) then state <= start_state; end if; when start_state => if (complete = '1') then state <= busy_state; end if; when busy_state => if (repeat_start_req = '1') then state <= repeat_start_state; end if; if (byte_req = '1') then state <= byte_state; end if; if (stop_req = '1') then state <= stop_state; end if; when repeat_start_state => if (complete = '1') then state <= busy_state; end if; when byte_state => if (complete = '1') then state <= busy_state; end if; when stop_state => if (complete = '1') then state <= idle_state; end if; when others => state <= idle_state; end case; end if; end process; process_start <= state(0); process_repeat_start <= state(1); process_stop <= state(2); process_byte <= state(3); in_progress <= state(4); end Behavioral;

Le dÃ©tecteur d'Ã©vÃ©nements de bus

Cette description permet de dÃ©tecter une condition de â€œStartâ€ ou â€œRepeat Startâ€ , une condition de â€œStopâ€ , le front montant du signal d'horloge ou le front descendant du signal d'horloge.
Ces informations sont importantes pour le sÃ©quencement de certains unitÃ©s.

library ieee; use ieee.std_logic_1164.all; entity event_detector is port ( \~CLR\ : in std_logic; clk : in std_logic; sda : in std_logic; scl : in std_logic; start : out std_logic; stop : out std_logic; re : out std_logic; fe : out std_logic); end event_detector; architecture behavioral of event_detector is signal old_sda : std_logic; signal old_scl : std_logic; begin process (\~CLR\, clk) begin if (\~CLR\ = '0') then old_sda <= '1'; old_scl <= '1'; elsif (rising_edge(clk)) then old_sda <= sda; old_scl <= scl; start <= scl and old_sda and not(sda); stop <= scl and not(old_sda) and sda; re <= not(old_scl) and scl; fe <= old_scl and not(scl); end if; end process; end behavioral;

Cette description permet de gÃ©nÃ©rer :
la condition de â€œStartâ€ ,
la condition de â€œRepeat Startâ€ ,
la condition de â€œStopâ€ ,
le signal d'horloge nÃ©cessaire aux Ã©changes de donnÃ©es.

Lors de la gÃ©nÃ©ration d'horloge, le bloc nÃ©cessite l'Ã©tat du signal â€œSCLâ€ afin de traiter le cas du â€œclock strechâ€ .
En effet, lorsque le sÃ©quenceur impose un niveau haut sur l'horloge, il attend que le signal passe effectivement Ã un avant de lancer un processus extÃ©rieur de temporisation.

library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity bus_seq is port ( \~CLR\ : in std_logic; clk : in std_logic; process_start : in std_logic; process_repeat_start : in std_logic; process_stop : in std_logic; process_byte : in std_logic; bo_cnt : in std_logic; scl : in std_logic; s_sda : out std_logic; r_sda : out std_logic; s_scl : out std_logic; r_scl : out std_logic; clr_cnt : out std_logic; complete : out std_logic); end bus_seq; architecture Behavioral of bus_seq is signal counter : std_logic_vector(3 downto 0); signal state : std_logic_vector(7 downto 0); constant idle : std_logic_vector(state'range) := "00000000"; constant repeat_start_step0 : std_logic_vector(state'range) := "00010010"; constant repeat_start_step1 : std_logic_vector(state'range) := "00000010"; constant repeat_start_step2 : std_logic_vector(state'range) := "00011000"; constant repeat_start_step3 : std_logic_vector(state'range) := "00001000"; constant start_step0 : std_logic_vector(state'range) := "00011010"; constant start_step1 : std_logic_vector(state'range) := "00001010"; constant start_step2 : std_logic_vector(state'range) := "00010001"; constant start_step3 : std_logic_vector(state'range) := "00000001"; constant start_step4 : std_logic_vector(state'range) := "00010100"; constant start_step5 : std_logic_vector(state'range) := "00000100"; constant start_step6 : std_logic_vector(state'range) := "00100000"; constant stop_step0 : std_logic_vector(state'range) := "00010101"; constant stop_step1 : std_logic_vector(state'range) := "00000101"; constant stop_step2 : std_logic_vector(state'range) := "01011000"; constant stop_step3 : std_logic_vector(state'range) := "01001000"; constant stop_step4 : std_logic_vector(state'range) := "01010010"; constant stop_step5 : std_logic_vector(state'range) := "01000010"; constant stop_step6 : std_logic_vector(state'range) := "01100000"; constant byte_step0 : std_logic_vector(state'range) := "10010100"; constant byte_step1 : std_logic_vector(state'range) := "10000100"; constant byte_step2 : std_logic_vector(state'range) := "10011000"; constant byte_step3 : std_logic_vector(state'range) := "10001000"; constant byte_step4 : std_logic_vector(state'range) := "11010100"; constant byte_step5 : std_logic_vector(state'range) := "00100100"; begin process (\~CLR\, clk) begin if (\~CLR\ = '0') then state <= idle; counter <= (others => '0'); elsif (rising_edge(clk)) then case state is when idle => if (process_start = '1') then state <= start_step0; end if; if (process_repeat_start = '1') then state <= repeat_start_step0; end if; if (process_stop = '1') then state <= stop_step0; end if; if (process_byte = '1') then state <= byte_step0; end if; when repeat_start_step0 => state <= repeat_start_step1; when repeat_start_step1 => if (bo_cnt = '1') then state <= repeat_start_step2; end if; when repeat_start_step2 => state <= repeat_start_step3; when repeat_start_step3 => if (bo_cnt = '1') then state <= start_step2; end if; when start_step0 => state <= start_step1; when start_step1 => if (bo_cnt = '1') then state <= start_step2; end if; when start_step2 => state <= start_step3; when start_step3 => if (bo_cnt = '1') then state <= start_step4; end if; when start_step4 => state <= start_step5; when start_step5 => if (bo_cnt = '1') then state <= start_step6; end if; when start_step6 => state <= idle; when stop_step0 => state <= stop_step1; when stop_step1 => if (bo_cnt = '1') then state <= stop_step2; end if; when stop_step2 => state <= stop_step3; when stop_step3 => if (bo_cnt = '1') then state <= stop_step4; end if; when stop_step4 => state <= stop_step5; when stop_step5 => if (bo_cnt = '1') then state <= stop_step6; end if; when stop_step6 => state <= idle; when byte_step0 => counter <= (others => '0'); state <= byte_step1; when byte_step1 => if (bo_cnt = '1') then state <= byte_step2; end if; when byte_step2 => if (scl /= '0') then state <= byte_step3; end if; when byte_step3 => if (bo_cnt = '1') then state <= byte_step4; end if; when byte_step4 => counter <= counter + 1; if (counter = 8) then state <= byte_step5; else state <= byte_step1; end if; when byte_step5 => state <= idle; when others => state <= idle; end case; end if; end process; r_sda <= state(0); s_sda <= state(1); r_scl <= state(2); s_scl <= state(3); clr_cnt <= state(4); complete <= state(5); end behavioral;

Le contrÃ´leur de bus

Cette description permet de :
dÃ©tecter la direction du transfert,
indiquer l'instant oÃ¹ doit se produire l'acquittement et
fournir l'Ã©tat du bus.

Le bloc utilise les signaux â€œstartâ€ et â€œstopâ€ pour indiquer l'Ã©tat du bus. Le signal interne â€œfirstâ€ associÃ© au compteur interne et au signal â€œsdaâ€ permet de dÃ©tecter la direction du transfert. Le compteur est aussi utilisÃ© pour dÃ©tecter l'instant oÃ¹ les acquittements doivent se produire.

library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity bus_ctrl is port ( \~CLR\ : in std_logic; clk : in std_logic; sda : in std_logic; start : in std_logic; stop : in std_logic; re : in std_logic; fe : in std_logic; acktime : out std_logic; write : out std_logic; busy : out std_logic); end bus_ctrl; architecture Behavioral of bus_ctrl is signal internal : std_logic; signal must_count : std_logic; signal direction : std_logic; signal first : std_logic; signal counter : std_logic_vector(3 downto 0); begin process (\~CLR\, clk) begin if (\~CLR\ = '0') then internal <= '0'; counter <= (others => '0'); must_count <= '0'; acktime <= '0'; direction <= '0'; write <= '0'; first <= '1'; elsif (rising_edge(clk)) then if (start = '1') then internal <= '1'; counter <= (others => '0'); must_count <= '0'; direction <= '0'; write <= '0'; first <= '1'; end if; if (stop = '1') then internal <= '0'; end if; if (fe = '1') then if (must_count = '1') then if (counter = 8) then counter <= (others => '0'); acktime <= '0'; if (first = '1') then write <= direction; first <= '0'; end if; elsif (counter = 7) then counter <= counter + 1; acktime <= '1'; else counter <= counter + 1; end if; else must_count <= '1'; end if; end if; if (re = '1') then if (counter = 7) then direction <= sda; end if; end if; end if; end process; busy <= internal; end Behavioral;

La bascule RS

Voici la description VHDL de la bascule :

library ieee; use ieee.std_logic_1164.all; entity rsc is port ( \~CLR\ : in std_logic; clk : in std_logic; s : in std_logic; r : in std_logic; q : out std_logic); end rsc; architecture behavioral of rsc is begin process (\~CLR\, clk) begin if (\~CLR\ = '0') then q <= '1'; elsif (rising_edge(clk)) then if (s = '1') then q <= '1'; elsif (r = '1') then q <= '0'; end if; end if; end process; end behavioral;

Le contrÃ´leur de bus I2C

Le contrÃ´leur de bus I2C est composÃ© de toutes les descriptions ci-dessus auxquels on ajoute un multiplexeur pour la gÃ©nÃ©ration du signal SDA en sortie, un premier registre Ã dÃ©calage pour l'Ã©mission et un second pour la rÃ©ception ainsi que deux blocs de synchronisation pour les signaux SDA et SCL en entrÃ©e.

library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity master_i2c is port ( \~CLR\ : in std_logic; clk : in std_logic; start_req : in std_logic; repeat_start_req : in std_logic; stop_req : in std_logic; byte_req : in std_logic; d : in std_logic_vector(7 downto 0); ackin : in std_logic; sda_in : in std_logic; scl_in : in std_logic; bo_cnt : in std_logic; clr_cnt : out std_logic; sda_out : out std_logic; scl_out : out std_logic; busy : out std_logic; in_progress : out std_logic; q : out std_logic_vector(7 downto 0); ackout : out std_logic); end master_i2c; architecture Behavioral of master_i2c is component bus_state_seq port ( \~CLR\ : in std_logic; clk : in std_logic; busy : in std_logic; start_req : in std_logic; repeat_start_req : in std_logic; stop_req : in std_logic; byte_req : in std_logic; complete : in std_logic; in_progress : out std_logic; process_start : out std_logic; process_repeat_start : out std_logic; process_stop : out std_logic; process_byte : out std_logic); end component; component event_detector port ( \~CLR\ : in std_logic; clk : in std_logic; sda : in std_logic; scl : in std_logic; start : out std_logic; stop : out std_logic; re : out std_logic; fe : out std_logic); end component; component bus_seq port ( \~CLR\ : in std_logic; clk : in std_logic; process_start : in std_logic; process_repeat_start : in std_logic; process_stop : in std_logic; process_byte : in std_logic; bo_cnt : in std_logic; scl : in std_logic; s_sda : out std_logic; r_sda : out std_logic; s_scl : out std_logic; r_scl : out std_logic; clr_cnt : out std_logic; complete : out std_logic); end component; component bus_ctrl port ( \~CLR\ : in std_logic; clk : in std_logic; sda : in std_logic; start : in std_logic; stop : in std_logic; re : in std_logic; fe : in std_logic; acktime : out std_logic; write : out std_logic; busy : out std_logic); end component; component rsc port ( \~CLR\ : in std_logic; clk : in std_logic; s : in std_logic; r : in std_logic; q : out std_logic); end component; signal internal_busy : std_logic; signal complete : std_logic; signal process_start : std_logic; signal process_repeat_start : std_logic; signal process_stop : std_logic; signal process_byte : std_logic; signal start : std_logic; signal stop : std_logic; signal re : std_logic; signal fe : std_logic; signal s_sda : std_logic; signal r_sda : std_logic; signal s_scl : std_logic; signal r_scl : std_logic; signal acktime : std_logic; signal write : std_logic; signal sda_bs : std_logic; signal outgoing : std_logic_vector(8 downto 0); signal incoming : std_logic_vector(8 downto 0); signal sda : std_logic_vector(1 downto 0); signal scl : std_logic_vector(1 downto 0); begin inst_bss : bus_state_seq port map (\~CLR\, clk, internal_busy, start_req, repeat_start_req, stop_req, byte_req, complete, in_progress, process_start, process_repeat_start, process_stop, process_byte); inst_ed : event_detector port map (\~CLR\, clk, sda(1), scl(1), start, stop, re, fe); inst_bs : bus_seq port map ( \~CLR\, clk, process_start, process_repeat_start, process_stop, process_byte, bo_cnt, scl(1), s_sda, r_sda, s_scl, r_scl, clr_cnt, complete); inst_bc : bus_ctrl port map ( \~CLR\, clk, sda(1), start, stop, re, fe, acktime, write, internal_busy); inst_rsc_sda : rsc port map ( \~CLR\, clk, s_sda, r_sda, sda_bs); inst_rsc_scl : rsc port map ( \~CLR\, clk, s_scl, r_scl, scl_out); sda_out <= sda_bs when (process_byte = '0') else '1' when ((write /= '0') xor (acktime = '1')) else outgoing(8); process (\~CLR\, clk) begin if (\~CLR\ = '0') then outgoing <= (others => '0'); incoming <= (others => '0'); elsif (rising_edge(clk)) then if (fe = '1') then outgoing <= outgoing(7 downto 0) & sda(1); elsif (byte_req = '1') then outgoing <= d & ackin; end if; if (re = '1') then incoming <= incoming(7 downto 0) & sda(1); end if; end if; end process; process (\~CLR\, clk) begin if (\~CLR\ = '0') then sda <= (others => '1'); scl <= (others => '1'); elsif (rising_edge(clk)) then sda <= sda(0) & sda_in; scl <= scl(0) & scl_in; end if; end process; busy <= internal_busy; q <= incoming(8 downto 1); ackout <= incoming(0); end Behavioral;

PWM pour FPGA

Steve — 2007-06-02T12:40:49Z

Introduction

La description qui suit permet de gÃ©rer une ou plusieurs PWM dans une FPGA. Elle est basÃ©e sur un compteur 16 bits, de deux ou plusieurs comparateurs et d'une ou plusieurs bascules RS.

Le compteur

Mon expÃ©rience m'a appris Ã me mÃ©fier des outils de synthÃ¨se. Toutefois, Ã ce jour, ils sont susceptibles de synthÃ©tiser un compteur performant.
Voici la description VHDL du compteur :

library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity cnt16 is port (clr : in std_logic; clk : in std_logic; q : out std_logic_vector(15 downto 0)); end cnt16; architecture behavioral of cnt16 is signal internal : std_logic_vector(15 downto 0); begin process (clr, clk) begin if (clr = '1') then internal <= (others => '0'); elsif (rising_edge(clk)) then internal <= internal + 1; end if; end process; q <= internal; end behavioral;

La bascule RS

Voici la description VHDL de la bascule :

library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity rs is port (clr : in std_logic; clk : in std_logic; s : in std_logic; r : in std_logic; q : out std_logic); end rs; architecture behavioral of rs is begin process (clr, clk) begin if (clr = '1') then q <= '0'; elsif (rising_edge(clk)) then if (r = '1') then q <= '0'; elsif (s = '1') then q <= '1'; end if; end if; end process; end behavioral;

Le comparateur

Le code du comparateur est extrÃªmement simple, jugez plutÃ´t :

library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity cmp is port (a : in std_logic_vector(15 downto 0); b : in std_logic_vector(15 downto 0); eq : out std_logic); end cmp; architecture behavioral of cmp is begin eq <= '1' when (a = b) else '0'; end behavioral;

La PWM

library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity pwm is port (clr : in std_logic; clk : in std_logic; d : in std_logic_vector(15 downto 0); q : out std_logic); end pwm; architecture behavioral of pwm is signal zero : std_logic; signal eq : std_logic; signal internal : std_logic_vector(15 downto 0); component cnt16 port (clr : in std_logic; clk : in std_logic; q : out std_logic_vector(15 downto 0)); end component; component rs port (clr : in std_logic; clk : in std_logic; s : in std_logic; r : in std_logic; q : out std_logic); end component; component cmp port (a : in std_logic_vector(15 downto 0); b : in std_logic_vector(15 downto 0); eq : out std_logic); end component; begin counter : cnt16 port map (clr, clk, internal); cmpzero : cmp port map (internal, x"0000", zero); cmplimit : cmp port map (internal, d, eq); rsc : rs port map (clr, clk, zero, eq, q); end behavioral;

Plusieurs PWMs

Si le besoin de plusieurs PWMs existe, il est possible de mutualiser le compteur ainsi que le comparateur Ã zÃ©ro. De ce fait, chaque PWM supplÃ©mentaire nÃ©cessite qu'un comparateur et qu'une bascule RS.

library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity fourpwm is port (clr : in std_logic; clk : in std_logic; d0 : in std_logic_vector(15 downto 0); q0 : out std_logic; d1 : in std_logic_vector(15 downto 0); q1 : out std_logic; d2 : in std_logic_vector(15 downto 0); q2 : out std_logic; d3 : in std_logic_vector(15 downto 0); q3 : out std_logic); end fourpwm; architecture behavioral of fourpwm is signal zero : std_logic; signal eq0 : std_logic; signal eq1 : std_logic; signal eq2 : std_logic; signal eq3 : std_logic; signal internal : std_logic_vector(15 downto 0); component cnt16 port (clr : in std_logic; clk : in std_logic; q : out std_logic_vector(15 downto 0)); end component; component rs port (clr : in std_logic; clk : in std_logic; s : in std_logic; r : in std_logic; q : out std_logic); end component; component cmp port (a : in std_logic_vector(15 downto 0); b : in std_logic_vector(15 downto 0); eq : out std_logic); end component; begin counter : cnt16 port map (clr, clk, internal); cmpzero : cmp port map (internal, x"0000", zero); cmplimit0 : cmp port map (internal, d0, eq0); rsc0 : rs port map (clr, clk, zero, eq0, q0); cmplimit1 : cmp port map (internal, d1, eq1); rsc1 : rs port map (clr, clk, zero, eq1, q1); cmplimit2 : cmp port map (internal, d2, eq2); rsc2 : rs port map (clr, clk, zero, eq2, q2); cmplimit3 : cmp port map (internal, d3, eq3); rsc3 : rs port map (clr, clk, zero, eq3, q3); end behavioral;

Remarque

L'utilisation d'un comparateur avec une sortie Â« plus petit queÂ » se comporte de la mÃªme maniÃ¨re. Toutefois, il nÃ©cessite plus de logique que l'opÃ©rateur Â« Ã©galeÂ ». De ce fait, la description que je propose permet une frÃ©quence de travail plus Ã©levÃ©e. De plus, la synthÃ¨se de l'opÃ©rateur Â« Ã©galeÂ » est optimale sur tous les synthÃ©tiseurs que j'ai pu essayer ce qui n'est pas le cas de l'opÃ©rateur Â« plus petit queÂ ».

Conclusion

Version	Outil de synthÃ¨se	Cible	PÃ©riode minimum	Niveau logique
pwm	ISE 7.1	XC2S300E-7PQ208	8,049 ns	3
fourpwm	ISE 7.1	XC2S300E-7PQ208	8,670 ns	3
pwm	ISE 7.1	XC3S500E-4PQ208	8,180 ns	5
fourpwm	ISE 7.1	XC3S500E-4PQ208	11,313 ns	5
pwm	Libero 7.1	A54SX32A-F PQ208	12,155 ns	?
fourpwm	Libero 7.1	A54SX32A-F PQ208	12,155 ns	?
pwm	ispLEVER 7.0	LFXP3C-3P208C	6,107 ns	8
fourpwm	ispLEVER 7.0	LFXP3C-3P208C	7,375 ns	8

Attention : Ces rÃ©sultats ne sont donnÃ©s qu'Ã titre indicatif. En effet, il n'y a pas de contraintes sur l'affectation des broches.

Steve — 2006-12-05T14:00:11Z

Description

La petite astuce suivante permet de faire dialoguer des noeuds I2C qui sont disposÃ©s sur deux segments de tension diffÃ©rente. Il faut mettre un exemplaire de la structure pour la ligne SDA et un autre pour la ligne SCL.

SchÃ©ma

Rappel sur le bus I2C

C'est un bus qui connaÃ®t deux Ã©tats :
le niveau haut qui est associÃ© au 1 logique est un niveau rÃ©cessif et
le niveau bas qui est associÃ© au 0 logique est un niveau dominant.

Principe

Trois possibilitÃ©s :
Les deux cotÃ©s prÃ©sentent un niveau haut, le transistor est bloquÃ©,
Le cÃ´tÃ© 3,3V est forcÃ© au niveau bas, la tension Grille-Source est suffisant pour rendre le transistor conducteur et le cÃ´tÃ© 5V se retrouve lui aussi forcer au niveau bas et
Le cÃ´tÃ© 5V est forcÃ© au niveau bas, dans ce cas, la diode, crÃ©e par le substrat "bulk" et la source, permet de faire baisser le 3,3V jusqu'Ã 0,6V et on se retrouve dans le cas prÃ©cÃ©dent.

Le site de Steve

Configuration d'une imprimante multifonction DCP-9020CDW sous Gentoo GNU/Linux avec CUPS

PrÃ©-requis

Les fichiers pilote

Installation des pilotes

Le filtre

Ajout de l'imprimante

Conclusion

DynHost d'OVH avec une LiveBox Play d'Orange

Introduction

Configuration de DynHost

Configuration de la Livebox Play

Le script de mise Ã jour

crontab

Conclusion

Filtre numÃ©rique du 1er ordre

Introduction

La synthÃ¨se du filtre (transformÃ©e bilinÃ©aire)

La description

Le multiplieur sÃ©rie

L'additionneur sÃ©rie

Le registre Ã dÃ©calage de sortie

Le sÃ©quenceur du filtre

Le filtre

Round-robin pour FPGA

Introduction

La description

Remarque

Conclusion

Un daemon UNIX en Python

Introduction

Les mÃ©thodes de la classe

Exemple d'utilisation

Conclusion

ContrÃ´leur I2C

Introduction

DÃ©coupage

Le sÃ©quenceur de requÃªte

Le dÃ©tecteur d'Ã©vÃ©nements de bus

Le sÃ©quenceur de bus

Le contrÃ´leur de bus

La bascule RS

Le contrÃ´leur de bus I2C

PWM pour FPGA

Introduction

Le compteur

La bascule RS

Le comparateur

La PWM

Plusieurs PWMs

Remarque

Conclusion

Conversion de niveaux Ã©lectriques pour le bus I2C

Description

SchÃ©ma

Rappel sur le bus I2C

Principe