Embedded C est le langage de programmation le plus populaire dans le domaine des logiciels pour le développement de gadgets électroniques. Chaque processeur est associé à un logiciel embarqué. Programmation C intégrée joue un rôle majeur dans l'exécution de fonctions spécifiques par le processeur. Dans notre vie de tous les jours, nous utilisons fréquemment de nombreux appareils électroniques tels que des machines à laver, des téléphones portables, des appareils photo numériques, etc. fonctionnant sur la base de microcontrôleurs programmés par C.
Programmation système intégrée
Le code C écrit est plus fiable, portable et évolutif et en fait, beaucoup plus facile à comprendre. Le premier outil et avant tout est le logiciel embarqué qui décide du fonctionnement d'un système embarqué. Le langage de programmation C intégré est le plus fréquemment utilisé pour la programmation des microcontrôleurs.
Tutoriel de programmation C intégré (8051)
Pour écrire le programme, les concepteurs embarqués doivent avoir des connaissances suffisantes sur le matériel de processeurs ou contrôleurs particuliers car la programmation C embarquée est une technique de programmation entièrement liée au matériel.
Tutoriel de programmation
Auparavant, de nombreuses applications embarquées étaient développées à l'aide de la programmation au niveau de l'assemblage. Cependant, ils n'ont pas fourni de portabilité pour surmonter ce problème avec l'avènement de divers langages de haut niveau comme C, COBOL et Pascal. Cependant, c'est le langage C qui a été largement accepté pour développement d'applications de systèmes embarqués , et il continue de le faire.
Système embarqué
Le système embarqué est défini comme la combinaison d'un logiciel de programmation C embarqué et d'une partie matérielle constituée majoritairement de microcontrôleurs et est destiné à effectuer la tâche spécifique. Ces types de systèmes embarqués sont utilisés dans notre vie quotidienne tels que les machines à laver et les enregistreurs vidéo, les réfrigérateurs, etc. Le système embarqué a été introduit pour la première fois par les microcontrôleurs 8051.
Système embarqué
Présentation du microcontrôleur 8051
Le microcontrôleur 8051 est un microcontrôleur de base, il est introduit pour la première fois par «Intel Corporation» depuis 1970. Il est développé par l’architecture de processeur 8086. Le 8051 est une famille de microcontrôleurs, qui a été développée par différents fabricants tels que Philips, Atmel, dalls, etc. Les microcontrôleurs 8051 a été utilisé dans de nombreux produits intégrés, des petits jouets pour enfants aux grands systèmes automobiles.
Microcontrôleur 8051
Le microcontrôleur 8051 est le 8 bits Architecture «CISC» . Il se compose de mémoires, de communication série, d'interruptions, de ports d'entrée / sortie et de temporisateur / compteurs, intégrés dans une seule puce intégrée, qui est programmée pour contrôler les périphériques qui lui sont interfacés. Le programme est stocké dans la RAM du microcontrôleur mais avant d'écrire le programme, il faut prendre conscience de la RAM organisation du microcontrôleur.
Programmation système embarquée: déclaration de base
Chaque fonction est une collection d'instructions qui exécutent une tâche spécifique et la collection d'une ou plusieurs fonctions est appelée un langage de programmation. Chaque langue se compose de quelques éléments de base et de règles grammaticales. La programmation en langage C est conçue pour fonctionner avec le jeu de caractères, les variables, les types de données, les constantes, les mots-clés, les expressions, etc. sont utilisés pour écrire un programme C. Tous ces éléments sont considérés sous un fichier d'en-tête ou un fichier de bibliothèque et il est représenté par
#comprendre
Développement de programmation C embarquée
L'extension du langage C s'appelle un langage de programmation Embedded C. Par rapport à ci-dessus, la programmation intégrée en langage C a quelques fonctionnalités supplémentaires telles que les types de données et les mots-clés et le fichier d'en-tête ou le fichier de bibliothèque est représenté comme
#comprendre
Mots clés supplémentaires incorporés C
- sbit
- bit
- SFR
- volatil
- les macros définissent
Le «sbit» est utilisé pour déclarer le code PIN unique du microcontrôleur. Par exemple, la LED est connectée à la broche P0.1, il n'est pas recommandé d'envoyer la valeur directement à la broche du port, d'abord, nous devons déclarer la broche avec une autre variable, puis après que nous puissions l'utiliser n'importe où dans le programme.
Syntaxe: sbit a = P0 ^ 1 // déclare la broche respective avec une variable //
a = 0x01 // envoyer la valeur à la broche du port //
Le «bit» est utilisé pour vérifier l'état de la variable.
Syntaxe: bit c // déclare la variable bit //
c = a // une valeur est affectée à la variable c //
if (c == 1) // vérifie la condition vraie ou fausse //
{
… ..
……
}
Le mot clé «SFR» permet d'accéder aux registres SFR sous un autre nom. Le registre SFR défini comme un registre des fonctions spéciales , il contient tous les registres périphériques en indiquant l'adresse. Le registre SFR est déclaré par le mot clé SFR. Le mot-clé SFR doit être en majuscules.
Syntaxe: SFR port = 0x00 // 0x00 est une adresse port0, elle est déclarée par la variable de port //
Port = 0x01 // puis envoyer la valeur au port0 //
retard()
port = 0x00
retard()
Le mot-clé «volatile» est le plus important dans le développement de systèmes embarqués. La variable qui déclare avec la valeur de mot clé volatile n'a pas pu être modifiée de manière inattendue. Il peut être utilisé dans les registres périphériques mappés en mémoire, variables globales modifiées par les ISR. Sans utiliser le mot-clé volatile pour transmettre et recevoir les données, une erreur de code ou une erreur d'optimisation se produira.
Syntaxe: volatile int k
La macro est un nom utilisé pour déclarer le bloc d'instructions en tant que directive de pré-processeur. Chaque fois que le nom est utilisé, il est remplacé par le contenu de la macro. Les macros représentent la #define. L'ensemble des broches du port est défini par les macros.
Syntaxe: #define dat Po // tout le port est déclaré par une variable //
dat = 0x01 // données envoyées au port0 //
Programmes C intégrés de base
La programmation du microcontrôleur sera différente pour chaque type de système d'exploitation . Même s'il existe de nombreux systèmes d'exploitation tels que Linux, Windows, RTOS, etc. Cependant, RTOS présente plusieurs avantages pour le développement de systèmes embarqués. Cet article décrit la programmation C intégrée de base pour développer la programmation C intégrée à l'aide d'un microcontrôleur 8051.
Étapes de programmation C intégrées
- LED clignotant avec le microcontrôleur 8051
- Affichage du nombre sur un écran à 7 segments à l'aide du microcontrôleur 8051
- Calculs et programme de minuterie / compteur à l'aide du microcontrôleur 8051
- Calculs et programme de communication série à l'aide du microcontrôleur 8051
- Interrompre les programmes à l'aide du microcontrôleur 8051
- Programmation du clavier à l'aide du microcontrôleur 8051
- Programmation LCD avec microcontrôleur 8051
LED clignotante à l'aide du microcontrôleur 8051
La LED est un dispositif semi-conducteur qui est utilisé dans de nombreuses applications, principalement à des fins d'indication. Il trouve une vaste gamme d'applications comme indicateurs pendant le test pour vérifier la validité des résultats à différentes étapes. Ils sont très bon marché et facilement disponibles dans une variété de formes, de couleurs et de tailles. Les LED sont utilisées pour concevoir panneaux d'affichage de message et les feux de signalisation de contrôle de la circulation, etc. Ici, les LED sont interfacées avec le PORT0 des microcontrôleurs 8051.
LED clignotante à l'aide du microcontrôleur 8051
1. 01010101
10101010
#include // fichier d'en-tête //
void main () // le point de statistique d'exécution du programme //
{
unsigned int i // type de données //
while (1) // pour une boucle continue //
{
P0 = 0x55 // envoyer la valeur hexa au port0 //
pour (i = 0i<30000i++) //normal delay//
P0 = 0x3AA // envoyer la valeur hexa au port0 //
pour (i = 0i<30000i++) //normal delay//
}
}
2. 00000001
00000010
00000100
.
.
10 000 000
#comprendre
void main ()
{
unsignedint i
caractère non signé j, b
tandis que (1)
{
P0 = 0x01
b = P0
pour (j-0j<3000j++)
pour (j = 0j<8j++)
{
b = b<<1
P0 = b
pour (j-0j<3000j++)
}
}
}
3. 00001111
11110000
#comprendre
void main ()
{
unsignedint i
tandis que (1)
{
P0 = 0x0F
pour (j-0j<3000j++)
P0 = 0xF0
pour (j-0j<3000j++)
}
}
4. 00000001
00000011
00000111
.
.
11111111
#comprendre
void main ()
{
unsignedint i
caractère non signé j, b
tandis que (1)
{
P0 = 0x01
b = P0
pour (j-0j<3000j++)
pour (j = 0j<8j++)
0x01
P0 = b
pour (j-0j<3000j++)
}
}
Affichage des nombres sur un affichage à 7 segments à l'aide du microcontrôleur 8051
Le Écrans à 7 segments sont les affichages électroniques de base, qui sont utilisés dans de nombreux systèmes pour afficher les informations numériques. Il se compose de huit LED qui sont connectées de manière séquentielle afin d'afficher des chiffres de 0 à 9, lorsque des combinaisons appropriées de LED sont allumées. Ils ne peuvent afficher qu'un seul chiffre à la fois.
Affichage des nombres sur un affichage à 7 segments à l'aide du microcontrôleur 8051
1. WAP pour afficher les nombres de «0 à F» sur quatre écrans à 7 segments?
#comprendre
sbit a = P3 ^ 0
sbit b = P3 ^ 1
sbit c = P3 ^ 2
sbit d = P3 ^ 3
void main ()
{
unsignedchar n [10] = {0 × 40,0xF9,0 × 24,0 × 30,0 × 19,0 × 12,0 × 02,0xF8,0xE00,0 × 10}
vous non signé, j
a = b = c = d = 1
tandis que (1)
{
pour (i = 0i<10i++)
{
P2 = n [i]
pour (j = 0j<60000j++)
}
}
}
2. WAP pour afficher les nombres de «00 à 10» sur les écrans à 7 segments?
#comprendre
sbit a = P3 ^ 0
sbit b = P3 ^ 1
affichage vide1 ()
affichage vide2 ()
délai d'annulation ()
void main ()
{
unsignedchar n [10] = {0 × 40,0xF9,0 × 24,0 × 30,0 × 19,0 × 12,0 × 02,0xF8,0xE00,0 × 10}
vous non signé, j
ds1 = ds2 = 0
tandis que (1)
{
pour (i = 0, i<20i++)
affichage1 ()
affichage2 ()
}
}
affichage vide1 ()
{
a = 1
b = 0
P2 = s [ds1]
retard()
a = 1
b = 0
P2 = s [ds1]
retard()
}
affichage vide2 ()
{
ds1 ++
si (ds1> = 10)
{
ds1 = 0
ds2 ++
si (ds2> = 10)
{
ds1 = ds2 = 0
}
}
}
délai d'annulation ()
{
unsignedint k
pour (k = 0k<30000k++)
}
Calculs de minuterie / compteur et programme à l'aide du microcontrôleur 8051
Le retard est l'un des facteurs importants dans le développement du logiciel d'application. Cependant, le retard normal ne donnera pas le résultat précieux pour surmonter ce problème de mise en œuvre du retard du temporisateur. Le minuteries et compteurs sont des composants matériels du microcontrôleur, qui est utilisé dans de nombreuses applications pour fournir le précieux retard avec des impulsions de comptage. Les deux tâches sont mises en œuvre par la technique logicielle.
Retard de la minuterie
WAP pour générer le délai de 500us en utilisant T1M2 (timer1 et mode2)?
#comprendre
void main ()
{
caractère non signé i
TMOD = 0x20 // définir le mode de minuterie //
pour (i = 0i<2i++) //double the time daly//
{
TL1 = 0x19 // définir le délai //
TH1 = 0x00
TR1 = 1 // temporisateur oN //
While (TF1 == 0) // vérifier le bit de drapeau //
TF1 = 0
}
TR1 = 0 // minuterie désactivée //
}
Délai de boucle normal
délai d'annulation ()
{
unsignedint k
pour (k = 0k<30000k++)
}
Calculs et programme de communication série à l'aide du microcontrôleur 8051
La communication série est couramment utilisée pour transmettre et recevoir le signal. Le microcontrôleur 8051 est composé Communication série UART les signaux émis et reçus par les broches Rx et Tx. L'UART prend des octets de données et envoie les bits individuels de manière séquentielle. Les registres sont un moyen de collecter et de stocker les données dans la mémoire. UART est un protocole semi-duplex. Le semi-duplex signifie le transfert et la réception des données, mais pas en même temps.
Calculs et programme de communication série à l'aide du microcontrôleur 8051
1. WAP pour transmettre le caractère «S» à la fenêtre série utilise 9600 comme débit en bauds?
28800 est la vitesse de transmission maximale du microcontrôleur 8051
28800/9600 = 3
Cette vitesse de transmission «3» est stockée dans les minuteries
#comprendre
void main ()
{
SCON = 0x50 // démarrer la communication série //
TNOD = 0x20 // a sélectionné le mode minuterie //
TH1 = 3 // charger la vitesse de transmission //
TR1 = 1 // Timer ON //
SBUF = ’S’ // stocke le caractère dans le registre //
while (TI == 0) // vérifier le registre d'interruption //
TI = 0
TR1 = 0 // OFF la minuterie //
while (1) // boucle continue //
}
2. WAP pour recevoir les données de l'hyperterminal et envoyer ces données au PORT 0 du microcontrôleur en utilisant 9600 bauds?
28800 est la vitesse de transmission maximale du microcontrôleur 8051
28800/9600 = 3
Cette vitesse de transmission «3» est stockée dans les minuteries
#comprendre
void main ()
{
SCON = 0x50 // démarrer la communication série //
TMOD = 0x20 // a sélectionné le mode minuterie //
TH1 = 3 // charger la vitesse de transmission //
TR1 = 1 // Timer ON //
PORT0 = SBUF // envoyer les données de SBUF au port0 //
while (RI == 0) // vérifier le registre d'interruption //
RI = 0
TR1 = 0 // OFF la minuterie //
while (1) // arrête le programme lorsque le caractère est reçu //
}
Interrompre les programmes à l'aide du microcontrôleur 8051
L'interruption est un signal qui oblige à arrêter le programme en cours et à exécuter immédiatement l'autre programme. Le microcontrôleur 8051 fournit 6 interruptions, qui sont internes et externes interrompre les sources . Lorsque l'interruption se produit, le microcontrôleur met en pause la tâche en cours et s'occupe de l'interruption en exécutant l'ISR, puis le microcontrôleur revient à la tâche récente.
WAP pour effectuer l'opération de décalage vers la gauche lorsque le temporisateur 0 interrompt, puis effectuer l'opération d'interruption pour le P0 dans la fonction principale?
#comprendre
caractère non signé b
void timer0 () interruption 2 // minuterie sélectionnée0 interruption //
{
b = 0x10
P1 = b<<2
}
void main ()
{
caractère non signé a, i
IE = 0x82 // activer l'interruption timer0 //
TMOD = 0x01
TLo = 0xFC // temporisateur d'interruption //
TH1 = 0xFB
TR0 = 1
a = 0x00
tandis que (1)
{
pour (i = 0i<255i++)
{
a ++
Po = a
}
}
}
Programmation du clavier à l'aide du microcontrôleur 8051
Le clavier matriciel est un dispositif de commutation analogique, qui est utilisé dans de nombreuses applications embarquées pour permettre à l'utilisateur d'effectuer les tâches nécessaires. UNE clavier matriciel se compose d'un agencement de commutateurs au format matriciel en lignes et en colonnes. Les lignes et les colonnes sont connectées au microcontrôleur de sorte que la rangée de commutateurs soit connectée à une broche et les commutateurs de chaque colonne soient connectés à une autre broche, puis effectuez les opérations.
Programmation du clavier à l'aide du microcontrôleur 8051
1. WAP pour faire basculer la LED en appuyant sur le commutateur
#comprendre
sbit a = P3 ^ 0
sbit b = P3 ^ 1
sbit c = P3 ^ 2
sbit d = P3 ^ 3
délai d'annulation ()
void main ()
{
tandis que (1)
{
a = 0
b = 1
c = 1
d = 1
retard()
a = 1
b = 0
c = 1
d = 1
délai d'annulation ()
{
caractère non signé i
TMOD = 0x20 // définir le mode de minuterie //
pour (i = 0i<2i++) //double the time daly//
{
TL1 = 0x19 // définir le délai //
TH1 = 0x00
TR1 = 1 // temporisateur oN //
While (TF1 == 0) // vérifier le bit indicateur //
TF1 = 0
}
TR1 = 0 // minuterie désactivée //
}
2. WAP pour allumer la LED en appuyant sur la touche «1» du clavier?
#comprendre
sbit r1 = P2 ^ 0
sbit c1 = P3 ^ 0
LED sbit = P0 ^ 1
void main ()
{
r1 = 0
si (c1 == 0)
{
LED = 0xff
}
}
3. WAP pour afficher le nombre 0,1,2,3,4,5 sur les sept segments en appuyant sur la touche respective sur le clavier?
#comprendre
sbit r1 = P2 ^ 0
sbit c1 = P3 ^ 0
sbit r2 = P2 ^ 0
sbit c2 = P3 ^ 0
sbit a = P0 ^ 1
void main ()
{
r1 = 0 a = 1
si (c1 == 0)
{
a = 0xFC
}
Si (c2 == 0)
{
a = 0x60
}
si (c3 == 0)
{
a = 0xDA
}
Si (c4 == 0)
{
a = 0xF2
}
}
Programmation LCD avec microcontrôleur 8051
Le affichage LCD est un appareil électronique, qui est fréquemment utilisé dans de nombreuses applications pour afficher les informations dans un format texte ou image. L'écran LCD est un affichage qui peut facilement afficher des caractères sur son écran. L'écran LCD se compose de 8 lignes de données et de 3 lignes de contrôle qui sont utilisées pour s'interfacer avec le microcontrôleur.
Programmation LCD avec microcontrôleur 8051
WAP pour afficher les «KITS EDGEFX» sur l'écran LED?
#comprendre
#define kam P0
voidlcd_initi ()
voidlcd_dat (caractère non signé)
voidlcd_cmd (caractère non signé)
délai d'annulation ()
affichage vide (caractère non signé * s, caractère non signé)
sbitrs = P2 ^ 0
sbitrw = P2 ^ 1
sbit à = P2 ^ 2
void main ()
{
lcd_initi ()
lcd_cmd (0x80)
retard (100)
lcd_cmd (0xc0)
affichage («kits edgefx», 11)
tandis que (1)
}
affichage vide (caractère non signé * s, caractère non signé)
{
unsignedint w
pour (w = 0w
lcd_data (s [w])
}
}
voidlcd_initi ()
{
lcd_cmd (0 × 01)
retard (100)
lcd_cmd (0 × 38)
retard (100)
lcd_cmd (0 × 06)
retard (100)
lcd_cmd (0x0c)
retard (100)
}
voidlcd_dat (dat car non signé)
{
peigne = ça
rs = 1
rw = 0
dans = 1
retard (100)
dans = 0
}
}
voidlcd_cmd (caractère non signé cmd)
{
venu = cmd
rs = 0
rw = 0
dans = 1
retard (100)
dans = 0
}
délai d'annulation (unsigned int n)
{
unsignedint a
pour (a = 0a
J'espère que cet article donne des informations de base sur la programmation du système intégré à l'aide du microcontrôleur 8051 avec quelques exemples de programmes. Pour un didacticiel détaillé sur la programmation C intégrée, veuillez publier vos commentaires et requêtes dans la section commentaires ci-dessous.
