L'electronike pas de panique

:besmellah1:

Un chenillard multimode 16 sorties, qui supporte 7 fonctions différentes : Chenillard lent pour slows, pseudo vu-mètre, modulateur, chenillard automatique, chenillard musical, rafales automatiques, et rafales musicales. 3 potentiomètres de réglage multifonctions agissent sur la sensibilité musicale, le temps d'allumage, le temps d'extinction, le temps séparant deux rafales, l'inertie du vu-mètre en montée et en descente. Le rôle des potentiomètre dépend de la fonction choisie. Le tout sur un 16F876.
Auteur

Bigonoff
Contenu

Le fichier source commenté, le fichier hex et le schéma. Le montage est opérationnel chez moi depuis 2001, mais je n'ai pas le schéma, je l'ai donc redessiné de mémoire. Signalez-moi toute erreur éventuelle pour correction. ATTENTION, vérifiez le montage et n'oubliez pas que vous travaillez sur le secteur.
Taille

Un fichier .rar d'une taille de 51,4 Koctets
Historique

Le 04/01/2001 : Réalisation du programme.
Le 02/10/2003 : Première version en ligne.
Commentaires de l'auteur

Suite aux nombreuses demandes en ce domaine si prisé des amateurs, je me décide à recréer un schéma pour publier un petit chenillard assez amusant à utiliser. Le source n'est pas un modèle d'optimisation, car j'ai réalisé ce montage pour une soirée d'un ami qui m'a demandé une animation lumineuse au dernier moment. J'ai donc réalisé le logiciel et le montage en 24 heures, ceci expliquant cela.




le code source:


 
:besmellah1:

Utilitaire permettant de générer automatiquement une boucle de délai. La boucle est générée pour un PIC 16F cadencé à 4Mhz. Souvenez-vous que les délais des boucles de temporisation ne sont exacts que si les interruptions ne sont pas actives. Dans le cas contraire, le délai peut être augmenté.
Auteur

habib kassem
Contenu

La version exécutable du programme, et le fichier source en C.
Taille

Un fichier .rar d'une taille de 21,8Koctets
Historique

Le 08/06/2004 : placement en ligne
Commentaires de l'auteur

Pour utiliser ce programme, il suffit d'entrer le délai en microsecondes (entre 6 et 50 000 000) pour obtenir le code source correspondant de la boucle correspondante.




le code source:


 
definition:
COMPILATEUR PIC C CCS (Computer Customs Service.)

CCS est un compilateur C pour les processeurs de la famille MicroChip PIC16. Des fonctions intégrées permettent de développer le code de manière très aisée.
L'environnement intégré de développement C donne à l'utilisateur une méthode rapide de produire un code efficient par le biais du langage évolué C.

Le compilateur comprend des fonctions intégrées comme READ_ADC qui lit une valeur provenant du convertisseur A/D du hardware PIC.
Des fonctions telles que INPUT et OUTPUT_HIGH maintiennent proprement les registres trois-états.
Les variables y compris des structures peuvent être directement mappées en mémoire tels que les ports I/O pour mieux représenter la structure du hardware en C.

Des fonctions d'I/O Série permettent aux fonctions standard telles que GETC et PRINTF d'être utilisé comme I/O pour le RS-232. Les opérateurs du standard C et les
fonctions intégrées spéciales sont optimisés pour produire des codes efficients pour les bits et les fonctions d'I/O.

Le fichier de sortie Hex et ceux du déboguage sont sélectionnables et compatibles avec les émulateurs et programmateurs populaires y compris MPLAB pour le déboguage au niveau source.
Le kit professionnel (PCW) fournit le compilateur C dans un environnement Windows.



Supported Devices




Les liens pour CCS pcwh version 4:

http://rapidshare.com/files/231343644/CCSpcwh4.057.part1.rar
http://rapidshare.com/files/231343645/CCSpcwh4.057.part2.rar
http://rapidshare.com/files/231343647/CCSpcwh4.057.part3.rar



:ahlan:



moz-screenshot.jpg
 
:besmellah2:

1. Les Règles de bases :


  • Toutes instructions ou actions se terminent par un point virgule ;
  • Une ligne de commentaires doit commencer par /* et se terminer par */ ou commence par // norme C++.
  • Un bloc d’instructions commence par { et se termine par ** .
2. Les variables et les constantes :

2.1. Les constantes :

Les constantes n’existent pas, c'est-à-dire qu’il n’y a pas d’allocation mémoire, mais on peut affecter à un identificateur (Nom : Il ne doit pas dépasser 32 caractères, sans accent)
Une valeur constante par l’instruction #define.
Syntaxe : < #define> <identificateur> <valeur> ;
Exemple :
#define PI 3,14; 2.1.1. Déclarations spécifiques au compilateur CCS :

  • #bit id =x,y
    • Id : identifiant (Nom d’un bit)
    • X : Nom du variable ou d’une constante
    • Y : position du bit
Exemple :
#bit RW =PORTA,2
#bit BUZZER =PORTD,7
  • #byte id = X
    • Id: identifiant
    • X: valeur 8 bits
Exemple :
#byte PORTA = 5 // adresse du port A
#byte PORTB = 6 // adresse du port B
#byte PORTC = 7 // adresse du port C
#byte PORTD = 8 // adresse du port D
#byte PORTE = 9 // adresse du port E 2.2. Les variables :

Les variables sont définies par signé ou non signé,
Syntaxe : <Signed><type><identificateur1>,.., <identificateurn>
· .l’identificateur : C’est le nom (il ne doit pas dépasser 32 caractères sans accent) affecté à la variable.
· . le type : il détermine la taille de la variable et les opérations pouvant être effectuées. On peut rajouter le mot signed devant le type de la variable, alors les variables deviennent signées.
2.2.1Les types du compilateur CCS :

Type

Taille

valeurs

Int1​
1 bit​
0 OU 1​
Int8​
8 bits​
De 0x00 à 0xFF ou 0 à 255​
Int16​
16 bits​
De 0x0000 à 0xFFFF ou 0 à 655535​
Int32​
32 bits​
De 0x0000000 à 0xFFFFFFFF​
char​
8 bits​
De 0 à 255 ou une lettre A………. Z​
float​
32 bits​
Format flottant​
short​

Même type que int1​
int​

Même type que int8​
long​

Même type que int16​
Exemples :
Int A,B,C,D ;
Char MESSAGE[10] ; Les types signés
Par défaut, tous ces types de données sont signés, ils peuvent être signés en rajoutant le mot clé signed devant le type.
Exemple :
Signed int A ; // Entier de type signé, de -128 à +127
Signed long NB; // Entier de type signé, de -32768 à +32767 2.2.2 Les base du compilateur CCS :


  • Le décimal : A=10 ;
  • L’octale : A=012 ;
  • L’hexadécimal A=0x0A ;
  • Le binaire A=0b00001010 ;
Le caractère : Exemple la lettre A code ASCII 65(Décimal) ou $41(Hexadécimal), peut s’écrire :
LETTRE = 65 Ou LETTRE = 0x41 Ou LETTRE = ‘A’
3. Les opérateurs du langage C :

Lors de son exécution, un programme est amené à effectuer des opérations qui peuvent être purement arithmétiques, de comparaison, d’affectation, etc.…
3.1. L’opérateur d’affectation :

Type

Symbole

Exemple

Opérateur d’affectation​
=​
X=10 ; Y = a + b​
L’opérande de gauche prend pour valeur l’opérande de droite.
3.2. Les opérateurs arithmétiques :

Type

Symbole

Exemple

Addition​
+​
a = a + b ; x = 5+ a​
Soustraction​
-​
a = a – b ; y = c - 5​
Moins unaire​
-​
a = - b​
Multiplication​
*​
a = a * a ; b = y * 8​
Division​
/​
c = 9 / b ; d = a / b​
Reste de la division entière​
%​
r = a % b​
3.3. Les opérateurs de comparaison ou relationnels :

Type

Symbole

Exemple

Egalité​
==​
a == b ; c == 9​
Différent​
!=​
c!= a​
Supérieur​
>​
a > b ; 8 > a​
Supérieur ou égal​
>=​
a >= b ; 8 >= a​
Inférieur​
<​
a < b ; 8 < a​
Inférieur ou égal​
<=​
a <= b ; 8 <= a​
3.4. Les opérateurs logiques :

Type

Symbole

Et logique​
&&​
Ou logique​
||​
Non logique​
!​
3.5. Les opérateurs binaires bit à bit :

Type

Symbole

Exemple

Et binaire​
&​
x = y & z​
Ou binaire​
|​
x = y | z​
Ou exclusif​
^​
x = y ^ z​
Complément à 1​
~​
x = b ~ z​
Décalage de n bits à droite​
>>​
x = b >> n​
Décalage de n bits à gauche​
<<​
x = b << n​
4. Les structures répétitives.

Le langage “C” possède des instructions permettant de répéter plusieurs fois une même séquence en fonction de certaines conditions.
4.1 Structure “while” : tant que ... faire ...

Avec ce type d’instruction le nombre de répétitions n’est pas défini et dépend du résultat du test effectué sur la condition. Si cette dernière n’est jamais vérifiée, la séquence n’est pas exécutée.
while (int x!=0) { ... ** La structure précédente répète la suite d’instruction comprises entre crochets tant que la variable entière “x” est différente de 0.
4.2 Structure “do ... while” : faire ... tant que...

Cette structure ressemble fortement à la précédente à la seule différence que la séquence à répéter est au moins exécuter une fois même si la condition n’est jamais vérifiée.
do { ... **
while
(int x!=0); 4.3 Structure “for” : Pour <variable> allant de <valeur initiale> à <valeur finale> faire...

Cette instruction permet de répéter, un nombre de fois déterminé, une même séquence.
for (i=0;i<5;i++) { ... **
La structure précédente répète 5 fois la suite d’instruction comprise entre crochets. La variable “i” prendra les valeurs successives de : 0, 1, 2, 3 et 4.
4.4 Les structures alternatives.

Ces structures permettent d’exécuter des séquences différentes en fonction de certaines conditions.
4.5 Structure “if ... Else” : Si <condition> faire ... sinon faire ...

Avec cette structure on peut réaliser deux séquences différentes en fonction du résultat du test sur une condition.
if (a<b) c=b-a; else c=a-b;​
La structure précédente affecte la valeur “b-a” à “c” si “a” est inférieur à “b” sinon “c” est affecté par la valeur “a-b”.
4.6 Structure “switch ... case”.

Cette structure remplace une suite de “if ... else if ...else” et permet une de réaliser différentes séquences appropriées à la valeur de la variable testée.
switch (a)
{
case ‘1’ : b=16;
case ‘2’ : b=8;
case ‘3’ : b=4;
case ‘4’ : b=2;
**​
Dans la structure précédente “b=16” si “a=1”, “b=8” si “a=4” etc.
5. Les fonctions adaptées aux microcontrôleurs PIC :

5.1. La gestion des entrées et des sorties :

Les fonctions suivantes permettent d’agir sur les ports d’entrées et de sorties :

  • Output_low ( ) ;
  • Output_high ( ) ;
  • Output_bit (pin_xx, 0 ou 1) ;
  • Input (pin_xx) ;
  • Output _x (valeur) ; // X : nom de port A…E
  • Input_x ( ) ;
  • Set_tris_x (valeur) ; // Valeur : définie la configuration de port (1 entrée et 0 sotie)
Exemples :
Lecture de la broche Rb4 :
X = input (pin_B4) ; Mise à 1 de RA5 :
output (pin_A4 ,1) ; ou
output_high (pin_A4) ; Configuration de port c, 4 broches en entrées et 4 broches en sorties :
Set_tris_c (0b11110000) ; 5.2. La gestion des temporisations :

Le compilateur intègre des fonctions très pratique pour gérer les délais :

  • delay_cycles (valeur) ; // temporisation en NB de cycles
  • delay_us (valeur) ; // temporisation en µs
  • delay_ms (valeur) ; // temporisation en ms
Pour pouvoir utiliser ces fonctions, il faut indiquer la fréquence du Quartz de votre application, cette ligne doit être définie au début du programme.
#use delay (clock = fréquence_de_quartz) ;
Exemples :
#use delay (clock=4000000); // quartz de 4 MHz
#use delay (clock = 20000000); //quartz en 20 MHz 5.3. La gestion de la liaison série :

Toutes les fonctions d’entrée et de sortie peuvent être redirigées sur le port série du microcontrôleur, il suffit d’ajouter la ligne ci-dessous pour configurer le port série :
#use rs232 (BAUD=9600, xmit=PIN_C6, rcv=PIN_C7) //Cette ligne configure la liaison série de PIC avec une vitesse de 9600 bauds. Les fonctions suivantes utiliseront le port série comme moyenne de communication :

  • Printf() ;
  • Putc() ;
  • getc() ;
  • Kbhit() ;

Traduction d’un algorithme en langage C :

1. Constantes et variables :

1.1. Déclaration de Constantes :

Algorithmique : Constante Nomconstante : [Type] = valeur
Syntaxe C : #define ID_de_la_constante valeur
Exemple :
Affectation d’E/S de type bit : commande d’un moteur
#bit LIMIT =PORTC,1;
#bit CLOCK =PORTD,3;
#bit F_H =PORTC,5;
#bit ENABLE =PORTC,0; 1.2. Déclaration de variables:

Algorithmique : variable Nomvariable : [Type]
Syntaxe C : #define ID_de_la_variable ;
Exemples :
float VALEUR_CAN ; // variable de type réel
int ETAT_RE[4] ; // tableau de 4 éléments entier
char MESSAGE_N1[10] ; // chaîne de 9 caractères 2. Procédures et fonctions :

La traduction d’une fonction ou procédure ou encore appelé sous-programme s’effectue ainsi :
2.1. Syntaxe :

//Nom de la fonction :
//Description du rôle de la fonction :
//Paramètres d’entrée : Noms et types des paramètres d’entrée
//Paramètre de sortie : Nom et type du paramètre de sortie
Type de la variable de retour nom de fonction (types nom des paramètres)
{
Instruction 1 ;
.
.
Instruction n ;
Return (valeur) ; // Valeur à renvoyer
**
· A partir de ce syntaxe, on peut avoir plusieurs cas possibles comme :
2.2. Une fonction sans paramètres d’entrée et de sortie :

//Nom de la fonction :
//Description du rôle de la fonction :
//Paramètres d’entrée : Rien
//Paramètre de sortie : Rien
Void nom de fonction (Void)
{
Instruction 1 ;
.
.
.
Instruction n ;**
2.3. Une fonction avec des paramètres d’entrée et sans paramètre de sortie :

//Nom de la fonction :
//Description du rôle de la fonction :
//Paramètres d’entrée : Noms et types des paramètres d’entrée
//Paramètre de sortie : Rien
Void nom de fonction (types nom des paramètres)
{
Instruction 1 ;
.
.
.
Instruction n ;**
2.4. Une fonction avec des paramètres d’entrée et un paramètre de sortie :

//Nom de la fonction :
//Description du rôle de la fonction :
//Paramètres d’entrée : Noms et types des paramètres d’entrée
//Paramètre de sortie : Nom et type du paramètre de sortie
Type de la variable de retour nom de fonction (types nom des paramètres)
{
Instruction 1 ;
.

Instruction n ;
Return (valeur) ; // Valeur à renvoyer **
2.5Une fonction d’interruption :

L’exécution d’une fonction d’interruption répond a un évènement qui peut être interne (périphérique : CAN, TIMER, EEPROM, USART, I2C) ou externe (RB0,PORTB) du microcontrôleur. L’appel d’une fonction d’interruption ne dépend pas de programme principal, mais elle l’interrompe pendant son exécution.
Une fonction d’interruption n’a pas de paramètre d’entrée et de sortie. Le compilateur CCS utilise une directive spéciale INIT_XXXX (XXXX nom de l’interruption) pour les différencier avec les autres fonctions logicielles.
Syntaxe :
//Nom de la fonction :
//Description du rôle de la fonction :
#INIT_XXXX //Nom de l’interruption
Void nom de fonction (Void)
{
Instruction 1 ;
.
Instruction n ;
**
Organisation d’un programme en langage C :

///////////////////////////////////////////////////////////////////////////////////////////////
//rôle du programme : //
// Auteur : //
//Lieu : //
//Version : //
///////////////////////////////////////////////////////////////////////////////////////////////

//fichier de déclaration des registres internes du microcontrôleur 16F84A.H
#include <16F84A.H>

//Déclaration des adresses des ports E/S
#byte PORTA = 5 //adresse du port A
#byte PORTB = 6 // adresse du port B //Déclaration des constantes
#define NB_MAX 100 //Affectation des entrées et sorties de type bit
#bit BUZZER = PORTD7 //par exemple : Command d’un buzzer //Fréquence du quartz
#use delay (clock=20000000) //Configuration de la liaison série de PIC avec une vitesse de9600 bauds
#use rs232 (BAUD=9600, xmit=PIN_C6, rcv=PIN_C7) //Déclaration du prototype de toutes les fonctions logicielles //Nom de la fonction suivi d’un point virgule par exemple :
Void INIT_UC(Void) ; //Déclaration des variables globales Par exemple :
Long DEBIT ;
Long VOULUME ; //Programme principale
Main()
{
Instruction 1 ;
.
Instruction n ;
**
//Déclaration des fonctions logicielles Par exemple :
//Nom de la fonction : DECALAGE_DROITE
//Description du rôle de la fonction : décalage à droite de NB bits
//Paramètres d’entrée : entier VAL, entier NB
//Paramètre de sortie : entier RESULTAT
int DECALAGE_DROITE (int VAL ,int NB)
{
Int RESULTAT;
RESULTAT = VAL >> NB;
Return (RESULTAT);**
//Appel de la fonction: Nom de la fonction (nom des paramètres) ;
//Exemple :
A = 16 ;
B = DECALAGE_DROITE (A, 2) ; //la valeur de A sera affectée à VAL
//la valeur 2 sera affectée à NB
//le résultat de la fonction sera affectée à B​
Quelques directives et fonctions du pic C compiler

1- Directives
#use delay
Syntaxe
:
#use delay(clock=fréquence)
Rôle
:
Renseigne le compilateur sur la fréquence du quartz utilisé.
Exemple
:
#use delay(clock=4000000)

#fuses
Syntaxe
:
#fuses options
Rôle
:
Permet de définir le mot de configuration. Les options sont :
· LP, XT, HS, RC
· WDT, NOWDT
· PUT, NOPUT
· PROTECT, NOPROTECT.
Exemple
:
#fuses XT,NOWDT,NOPUT,NOPROTECT

#int_xxxx
Syntaxe
:
#int_ext
#int_ RB
#int_TIMER0
#int_EEPROM
: interruption externe.
: changement d’état de RB4 à RB7.
: débordement du timer0.
: fin d’écriture dans l’EEPROM.
Rôle
:
Spécifie la source de l’interruption.
2- Fonctions
BIT_CLEAR()
Syntaxe
:
BIT_CLEAR(var, bit)
Rôle
:
Mettre à 0 le bit « bit » de la variable « var ».
Exemple
:
a=0x1F
BIT_CLEAR(a, 3)
a devient 17 hexa.

BIT_SET()
Syntaxe
:
BIT_SET(var, bit)
Rôle
:
Mettre à 0 le bit « bit » de la variable « var ».
Exemple
:
a=0x1F
BIT_SET(a, 6)
a devient 3F hexa.

BIT_TEST()
Syntaxe
:
BIT_TEST(var, bit)
Rôle
:
Teste l’état du bit « bit » de la variable « var ».
Exemple
:
a=0x1F
BIT_TEST(a, 2)
Le résultat est 1 car le bit 2 de la variable « a » est à 1.

DELAY_MS()
Syntaxe
:
DELAY_MS(x)
Rôle
:
Temporisation se « x » ms.
Exemple
:
DELAY_MS(2000)
Temporisation de 2 secondes.

INPUT()
Syntaxe
:
etat=INPUT(pin)
Rôle
:
Permet de lire l’état d’une broche d’un port préalablement configurée en entrée.
Exemple
:
a=input(PIN_B0)
la variable « a » reçoit l’état de la broche 0 du port B.

INPUT_x()
Syntaxe
:
etat=INPUT_x()
Rôle
:
Permet de lire l’état d’un port (x sur 8 bits) préalablement configuré en entrée.
Exemple
:
c=input_A()
la variable « c » reçoit l’état du port A (1 octet).

OUTPUT_x()
Syntaxe
:
OUTPUT_x(valeur)
Rôle
:
Permet de sortir l’octet «valeur» sur le port x , préalablement configuré en sortie.
Exemple
:
OUTut_B(0x1F)
La valeur 1FH est envoyée sur le port B.

OUTPUT_BIT()
Syntaxe
:
OUTPUT_BIT(pin, etat)
Rôle
:
Permet de mettre la pin (pin) à l’état logique (etat).
Exemple
:
OUTut_BIT(PIN_A3,1)
Mettre à 1 la broche 3 du port A.

OUTPUT_HIGH()
Syntaxe
:
OUTPUT_HIGH(pin)
Rôle
:
Permet de mettre à 1 la pin (pin).
Exemple
:
OUTut_HIGH(PIN_A3)
Mettre à 1 la broche 3 du port A.

OUTPUT_LOW()
Syntaxe
:
OUTPUT_LOW(pin)
Rôle
:
Permet de mettre à 0 la pin (pin).
Exemple
:
OUTut_LOW(PIN_A3)
Mettre à 0 la broche 3 du port A.

ROTATE_LEFT()
Syntaxe
:
ROTATE_LEFT(adresse, n)
Rôle
:
Rotation à gauche de « n » positions de l’octet ayant pour adresse « adresse ».
Exemple
:
a=0x86
ROTATE_LEFT(&a, 1)
a devient 0d hexa.

ROTATE_RIGHT()
Syntaxe
:
ROTATE_RIGHT(adresse, n)
Rôle
:
Rotation à droite de « n » positions de l’octet ayant pour adresse « adresse ».
Exemple
:
a=0x86
ROTATE_ RIGHT (&a, 1)
a devient 43 hexa.

SET_TRIS_x()
Syntaxe
:
SET_TRIS_x(valeur)
Rôle
:
Configure la direction du port « x ».
Exemple
:
SET_TRIS_B(0x0F)
Les pins B7, B6, B5, B4 sont configurées en sortie (0).
Les pins B3, B2, B1, B0 sont configurées en entrée (1).

SHIFT_LEFT()
Syntaxe
:
SHIFT_LEFT(adresse, n, bit)
Rôle
:
Décalage à gauche de « n » positions de l’octet d’adresse « adresse » ; bit est le bit introduit 0 ou 1.
Exemple
:
SHIFT_LEFT(&b, 2, 0)
Décalage à gauche de 2 positions de la variable « b ».

SHIFT_RIGHT()
Syntaxe
:
SHIFT_RIGHT(adresse, n, bit)
Rôle
:
Décalage à droite de « n » positions de l’octet d’adresse « adresse » ; bit est le bit introduit 0 ou 1.
Exemple
:
SHIFT_ RIGHT (&b, 2, 0)
Décalage à droite de 2 positions de la variable « b ».
 
:besmellah1:

Programmation d'un microcontroleur PIC® avec le compilateur C CSS
La programmation des microcontroleurs PIC® de chez Microchip® à l'aide du langage C et du compilateur C de chez CSS.
Le support d'étude est la version PIC 16F876A mais l'étude reste valable pour de nombreux autres microcontroleurs.
En sus, une présentation rapide de l'évolution des microprocesseurs et microcontroleurs, leur architecture et fonctionnement interne.

Présentation des microcontroleurs et microprocesseurs (pdf)
Présentation des microcontroleurs et microprocesseurs (powerpoint)
Programmation en langage C d'un PIC® 16F876A sous CSS
Présentation du microcontroleur PIC® 16F876A

:ahlan:
 
:besmellah1:


Proteus est une suite logicielle constituée d'un éditeur de schémas (ISIS) permettant la saisie de schémas électroniques et leur simulation. Ainsi qu'un éditeur de Typon ARES pour concevoir son typon à partir d'un chevelu et d'un schéma saisi sous ISIS.

pour le téléchargement du logiciel voila les liens:

http://rapidshare.com/files/194359425/Proteus_VSM_7.4_Professional.rar

2
eme lien

http://rapidshare.com/files/246491501/PROTEUS.ENGINEERING.FASTSHIP.V6.1.29-Lz0.zip


Patch pour rendre l'interface de ISIS et ARES en Français


Document de présentation de Proteus
 
:besmellah1:
Sur cet ouvrage, vous trouverez des petits schémas, astuces, aides diverses réalisés par différents internautes, et qui ne sont pas des réalisations proprement dites


1- Les fichiers maquettes pour plusieurs types de PIC®, afin de démarrer plus facilement vos réalisations


Auteur

Bigonoff
Contenu

Fichiers pour 16F84, 16F876, 16F877, 18F258, 16F873, 16F874
Taille

Un fichier .rar d'une taille de 30,8Koctets
Historique

Le 27/10/2003 : placement en ligne.
Le 13/10/2006 : Ajout des maquettes 16F873 et 16F874


:ahlan:

 
:besmellah2:

Realisation d'une platine d'expérimentation pour le 16F84. Permet de démarrer rapidement avec un 16F84.

Auteur

J.M.B.
Contenu

Schémas et typons (proteus et bmp) nécessaires pour réaliser la platine.
Taille

Un fichier .rar d'une taille de 173Koctets
Historique

Le 06/10/2003 : Première version en ligne.
Le 08/10/2003 : Ajout des fichiers au format Proteus.
Commentaires de l'auteur

Dans ce fichier se trouvent le schéma et le typon en format bmp de la platine de développement à PIC® que j'utilise. Je me suis inspiré d'une platine d'essai parue dans électronique pratique. Je pense que ça pourrait intéresser d'autre développeurs. je joints également les fichiers qui doivent pouvoir être ouvert avec Proteus Lite si quelqu'un veut faire une modification.




http://www.abcelectronique.com/bigonoff/charger.php?par=3d69f&fic=simp




:ahlan:

 
:besmellah1:


Pilotage de différents périphériques, en utilisant un PIC® maître et un PIC® esclave, pour décharger le PIC® maître des différents accès.
Exemple de communication inter-processeurs.
2 modes de communication sont proposés :
I²C (software) :

  • Pilotage d'une horloge complete programmable à base de DS1307 + mise à l'heure protocole DCF77.
  • Pilotage d'un thermometre DS1624 , baromètre MPX2100A et d'un DS2438 en I-Button
SPI (via le MSSP) :

  • Une horloge complete programmable à base de DS1306 mode MSSP SPI + mise à l'heure protocole DCF77
  • Thermomètre DS1620 0.1°C, barometre MPX2100A et DS2438 en I-Button.
Fonctions communes : Affichage sur 4 digits 7 segments par I²C software, PIC® 16F876 esclave pour la gestion du LCD graphique. La communication I²C travaille à 100Khz.
Auteur

Claude D.
Contenu

Les différents fichiers sources maître et esclave pour chacune des 2 versions. Pour la documentation, reportez-vous à la réalisation proposée par Dominique M sur cette page.
Taille

Un fichier .rar d'une taille de 83,3Koctets
Historique

Le 30/06/2004 : placement en ligne
Commentaires de l'auteur

Le PIC® maitre se sent réellement soulagé ce qui lui laisse plus de temps pour faire autre chose. J'ai du revoir mes routines de pilotage software I²C. La communication avec le PIC® esclave est facile


 
أعلى