‏إظهار الرسائل ذات التسميات Projets. إظهار كافة الرسائل

Projet à microcontrôleur PIC 16F84A

Horloge à quartz avec affichage des secondes par 60 leds

1- Présentation
2- Schémas électriques
3- Les circuit imprimés
4- Code source du microcontrôleur PIC

1- Présentation

Il s'agit d'une horloge à quartz parfaitement classique, avec un bouton poussoir qui règle les minutes, et un autre les heures.

Vidéo réalisée par Marc Paradis :

http://youtu.be/cTPj4VDINn8

2- Schémas électriques

Le schéma de base est celui du projet horloge à quartz.

Le schéma de base est complété par le module d'affichage des secondes :

Le circuit 74HC164 est un régistre à décalage 8 bits.

3- Les circuits imprimés (réalisés par Slimane Nait-Kait)

Pour permettre l'alimentation par un adaptateur sur secteur, un pont de diodes et des régulateurs de tension ont été ajoutés.

Télécharger les autres typons

4- Code source du microcontrôleur PIC

Le code source a été écrit en langage assembleur avec l'environnement de développement gratuit MPLAB IDE de Microchip.

Le code source est basé sur celui du projet horloge à quartz avec quelques modifications :

Sur la broche RB7, on a :

une impulsion au niveau bas à la mise sous tension
une impulsion au niveau bas (durée 2 µs) toutes les minutes

0 Comments

Une alarme sonore sensible à la lumière à base de circuit intégré NE555

Le circuit dont la figure 1 donne le schéma électrique émet une note acoustique d’environ 700 Hz quand la photorésistance FR1 est occultée (quand elle ne reçoit plus ou moins de lumière).

Si, comme le montre le schéma, nous intervertissons les points ABC, nous obtenons l’effet inverse : le circuit émet alors sa note lorsque la photorésistance est illuminée.

Dans le premier cas, si on place la photorésistance de telle manière qu’elle soit éclairée par la flamme d’une chaudière (par exemple), le circuit déclenchera l’alarme en cas d’extinction.

Dans le second, si on la place dans un local contenant des substances inflammables, le circuit nous avisera en cas de début d’incendie.

Mais il existe des applications plus banales de ce circuit.

Placé dans un tiroir ou un casier, le circuit nous avertira de l’indiscrétion perpétrée par un collègue de bureau pendant que nous avons le dos tourné…ou du moins la note acoustique le fera rougir de honte.

Pour déterminer en dessous ou en dessus de quelle valeur de luminosité vous souhaitez déclencher la note acoustique dans le haut-parleur, agissez sur le bouton du potentiomètre R2.

La formule permettant de calculer la fréquence de la note est la suivante :

F en Hz = (1 440 : C2) : (R6 + R7 + R7)

R étant en k et C en μF ; la constante 1440 est fournie par le constructeur du circuit intégré.

Avec les valeurs de la liste des composants, nous aurons :

F = (1 440 : 0,01) : (10 + 100 + 100) = 685 Hz.

Pour obtenir une fréquence plus élevée, il faut faire passer la valeur de C2 de 10 nF à 5,6 nF (soit 0,0056 μF) et nous aurons :

F = (1 440 : 0,0056) : (10 + 100 + 100) = 1 224 Hz ou 1,224 kHz.

Pour augmenter la fréquence, on peut aussi réduire la valeur de la résistance R7 en la passant de 100 k à 68 k et l’on obtient ainsi :

F = (1 440 : 0,01) : (10 + 68 + 68) = 986 Hz.

Dans la liste des composants figurent des transistors bien précis (TR1 PNP BC153 et TR2 NPN BD241), mais vous pouvez aussi bien utiliser n’importe quels transistors de faible puissance (pour TR1) ou moyenne puissance (pour TR2) pourvu que TR1 soit un PNP et TR2 un NPN.

Pour augmenter le rendement acoustique du son, fixez le haut-parleur derrière un panneau de carton fort, d’isorel ou de bois que vous aurez découpé au diamètre du cône.

L’appareil peut certes être alimenté par une pile de 9 V mais le mieux est d’utiliser une alimentation stabilisée fournissant 12 à 15 V.

Figure 1 : Schéma électrique de l’alarme sonore sensible à la lumière à base de circuit intégré NE555 .

Figure 2 : Schéma d’implantation des composants de l’alarme sonore sensible à la lumière et brochages des transistors (BD241 vu de face et BC153 vu de dessous).
Attention à l’orientation de ces derniers (la semelle métallique du BD241 vers le haut-parleur et méplat du BC153 vers le coin bas droit de la platine).

Figure 3 : Dessin à l’echelle 1 du circuit imprimé double face

Liste des composants

R1 ..... 150 Ω

R2 ..... 10 kΩ potentiomètre

R3 ..... 4,7 kΩ

R4 ..... 1,2 kΩ

R5 ..... 10 kΩ

R6 ..... 10 kΩ

R7 ..... 100 kΩ

R8 ..... 470 Ω

R9 ..... 10 kΩ

R10 .... 1 Ω 1/2 W

C1 ..... 100 μF électrolytique

C2 ..... 0,01 μF (10 nF) polyester

C3 ..... 10 nF polyester

FR1 .... photorésistance de n’importe quel type

DS1 .... 1N4004 ou F111

DS2 .... 1N4004 ou F111

DS3 .... 1N4004 ou F111

TR1 .... PNP BC153

TR2 .... NPN BD241

IC1 .... NE555

S1 ..... interrupteur à levier

HP ..... haut-parleur 8 ohms

0 Comments

Projet : Système d’éclairage automatique

Description du projet

Il s’agit d’un système d’éclairage automatique.

Quand la luminosité ambiante est insuffisante, une ampoule s’allume.

Télécharger Ici

0 Comments

Projet : Commande d' un système par SMS avec Nokia 3310

Réalisé votre projet de fin d'etude avec pic 16F877A et RS232 pour communication avec pc.

projet : commande d' un systémé par sms avec Noikia 3310

schéma : sur isis7

code sur : mikroC

0 Comments

Projet électronique : Gestion d’une matrice des LED avec Arduino

Objectifs et analyse de fonctionnement

Le projet consiste la gestion d’une matrice des LED 8X8 à base d’Arduino en utilisant le circuit MAX7219CNG. Le projet électronique utilise une libraire pour la gestion du circuit MAX7219CNG avec une liaison SPI. Ce mini projet mis en évidence l’utilisation de la libraire avec d’autres fonctions secondaires (décalage, conversion, …).

Fonctionnement de la matrice des LEDs 8×8

Projet électronique Gestion d'une matrice des LED avec Arduino - matrice led

La matrice des LED est constituée de 8 lignes et 8 colonnes. On peut assimiler la matrice à un tableau 1D de 8 éléments, chaque élément du tableau est codé sur 8 bits Ex B00001111 ou 0x0F, dans la figure ci-dessous illustre le passage d’une matrice 8×8 à un tableau sur 8 éléments de type Bye ou Unsigned char. On verra dans la suite la fonction qui permet d’afficher le code dans la matrice 8×8.

Le module utilisé est basé sur MAX7219 avec une liaison série pour les données. Le bus SPI est constitué de trois fils :

CS : Chip Select pour l’activation du modèle
CLK : l’horloge synchrone pour les données. L’horloge définie la vitesse de transmission des données série
DIN : La donnée série sur 8 bits

Plus des détails sur la transmission série : SPI

Projet électronique Gestion d'une matrice des LED avec Arduino - Matrice fonctionnement

Lien vers une Application gratuite de gestion d’une matrice 8×8 des LED

Commentaires sur le programme

void int2BitArray(unsigned char dataIn,unsigned char taille, byte *dataArray)

La fonction int2BitArray permet de convertir une variable char en un tableau sur N bits (N=8 bits)

Ex1 : pour dataIn=10, taille=8 alors la variable de sortie dataArray[8]={0,0,0,0,1,0,1,0] ( équivalant à B00001010)

Ex2 : dataIn=127, taille=8 alors la variable de sortie dataArray[8]={0,1,1,1,1,1,1,1] ( équivalant à B011111111)

void DataShiftArray(unsigned char NumShift,unsigned char taille, byte *DataIn, byte *DataOutShift)

La fonction DataShiftArray permet de décaler à droit un tableau de longueur « taille » de bits (tableau binaire) DataIn, le résultat est stocké puis retourné dans le tableau DataOutShift. Au début le tableau DataOutShift est supposé initialisé à 0.

Ex : NumShift=3, taille = 8, DataIn[8]={1,1,1,1,0,0,0,0} alors DataOutShift[8]={0,0,0,1,1,1,1,0}.

L’objectif de la fonction est de décaler un objet dans la matrice 8×8 des LED.

Assemblage en cascade des matrices

Chaque matrice est définie par sont indice, la première à l’indice 0, la deuxième 1 … Pour ecrire dans une matrice il suffit de préciser l’indice de la matrice

Projet électronique Gestion d'une matrice des LED avec Arduino

Les fonctions disponibles dans la libraire LedControl.h (MAX7219/MAX7221)


class LedControl {

    private


        /* The array for shifting the data to the devices */

        byte spidata[16];

        /* Send out a single command to the device */

        void spiTransfer(int addr, byte opcode, byte data);



        /* We keep track of the led-status for all 8 devices in this array */

        byte status[64];

        /* Data is shifted out of this pin*/

        int SPI_MOSI;

        /* The clock is signaled on this pin */

        int SPI_CLK;

        /* This one is driven LOW for chip selectzion */

        int SPI_CS;

        /* The maximum number of devices we use */

        int maxDevices;



    public:

        /*

         * Create a new controler
         * Params :

         * dataPin                pin on the Arduino where data gets shifted out
         * clockPin                pin for the clock

         * numDevices        maximum number of devices that can be controled
         * csPin                pin for selecting the device
         */


        LedControl(int dataPin, int clkPin, int csPin, int numDevices=1);

        /*
         * Gets the number of devices attached to this LedControl.

         * int        the number of devices on this LedControl
         * Returns :
         */


        int getDeviceCount();

        /*
         * Set the shutdown (power saving) mode for the device

         * addr        The address of the display to control
         * Params :

         * status        If true the device goes into power-down mode. Set to false
         *                for normal operation.
         */


        void shutdown(int addr, bool status);

        /*
         * Set the number of digits (or rows) to be displayed.

         * See datasheet for sideeffects of the scanlimit on the brightness
         * of the display.
         * Params :
         * addr        address of the display to control

        void setScanLimit(int addr, int limit);
         * limit        number of digits to be displayed (1..8)
         */




        /*

         * Set the brightness of the display.
         * Params:

         * addr                the address of the display to control
         * intensity        the brightness of the display. (0..15)
         */


        void setIntensity(int addr, int intensity);

        /*
         * Switch all Leds on the display off.

         * addr        address of the display to control
         * Params:
         */


        void clearDisplay(int addr);

        /*
         * Set the status of a single Led.

         * addr        address of the display
         * Params :

         * col        the column of the Led (0..7)
         * row        the row of the Led (0..7)

         *                if false it is switched off
         * state        If true the led is switched on,
         */


        void setLed(int addr, int row, int col, boolean state);

        /*
         * Set all 8 Led's in a row to a new state

         * addr        address of the display
         * Params:

         * value        each bit set to 1 will light up the
         * row        row which is to be set (0..7)

        void setRow(int addr, int row, byte value);
         *                corresponding Led.
         */




        /*

         * Set all 8 Led's in a column to a new state
         * Params:

         * col        column which is to be set (0..7)
         * addr        address of the display

         *                corresponding Led.
         * value        each bit set to 1 will light up the
         */


        void setColumn(int addr, int col, byte value);

        /*
         * Display a hexadecimal digit on a 7-Segment Display

         * addr        address of the display
         * Params:

         * value        the value to be displayed. (0x00..0x0F)
         * digit        the position of the digit on the display (0..7)

        void setDigit(int addr, int digit, byte value, boolean dp);
         * dp        sets the decimal point.
         */




        /*

         * Display a character on a 7-Segment display.

         * There are only a few characters that make sense here :
         *        '0','1','2','3','4','5','6','7','8','9','0',

         *  '.','-','_',' '
         *  'A','b','c','d','E','F','H','L','P',
         * Params:

         * digit        the position of the character on the display (0..7)
         * addr        address of the display
         * value        the character to be displayed.

        void setChar(int addr, int digit, char value, boolean dp);
         * dp        sets the decimal point.
         */


};

Exemple de programme d’utilisation de la libraire





//Libraire à importer !
#include "LedControl.h"

/*

 Configuration des pins (MAX72XX)

 LedControl lc=LedControl(12,11,10,1);
 Pin 12  connecté au DataIn

 Pin 10  connecté au LOADََََّّّّ
 Pin 11  connecté au CLK
*/



LedControl lc=LedControl(12,10,11,1);

/* Temporisation de mise en service de l'afficheur */
unsigned long delaytime=100;

void setup() {
  /*

   The MAX72XX is in power-saving mode on startup,
   we have to do a wakeup call
  */


  lc.shutdown(0,false);

  /* Set the brightness to a medium values */

  lc.setIntensity(0,8);

  /* and clear the display */

  lc.clearDisplay(0);
}



void writeArduinoOnMatrix() {

  /* Tableaux de 8 Byte, chaque octet est constitué de 8 bits (8x8=64) */
  byte t[8]={B00000000,B11111111,B11111111,B00011000,B00011000,B00011000,B00011000,B00011000};

  byte Data[8]={0,0,0,0,0,0,0,0};

  byte DataShif[8]={0,0,0,0,0,0,0,0};

  byte XData[8]={B10111101,B11000011,B10011001,B10011001,B01000010,B01111110,B10011001,B10011001};

  byte EM[8]={B11110001,B11000011,B10100101,B10011001,B11111001,B10000001,B10000001,B11110001};



  /* Affichage du caractère T colonne par colonne (8écritures) */

  for(int i=0;i<8;i++)

  {

    // Afficher la ligne t[i] à la position de la colonne i

    lc.setColumn(0,i,t[i]);

    delay(delaytime);

  }

  lc.clearDisplay(0);



  delay(1000);

  /* Affichage du caractère T ligne par ligne (Rotation 90° par rapport
  à la fonction setColumn ((8 écritures)*/

  for(int i=0;i<8;i++)

  {

    // Afficher la colonne t[i] à la position de la ligne i

    lc.setRow(0,i,t[i]);

    delay(delaytime);

  }

  lc.clearDisplay(0);

  delay(1000);



  /* Ecriture dans l'afficheur pixel par pixel (8x8 écritures) */

  for(int k=0;k<8;k++)

  {

    //Décalage à droite de valeur=k [0..7]

    DataShiftArray(k,8, EM,DataShif )  ;

    for(int i=0;i<8;i++)

    {

      // Conversion du Byte DataShif[i] en binaire sur 8 bits

      int2BitArray( DataShif[i],8 ,Data );

      for(int j=0;j<8;j++)

      {

        // Affichage le Bit Data[j] à la position (i,j) de la matrice (8x8)

        lc.setLed(0,i,j,Data[j]);

        //delay(1);

      }

    }

    delay(1000);

    lc.clearDisplay(0);

  }




}


void int2BitArray(unsigned char dataIn,unsigned char taille, byte *dataArray)

  int i=0;
{


  for(i=0;i<taille;i++)

    dataArray[taille-i-1]= (dataIn>>i)&0x01;
}

void DataShiftArray(unsigned char NumShift,unsigned char taille,  byte *DataIn, byte *DataOutShift)
{

  int i=0;



  for(i=0;i<taille;i++)

    DataOutShift[i]= (DataIn[i]>>NumShift);
}



void loop() {

  writeArduinoOnMatrix();

}