Et encore une fois, nous récupérerons le capteur de lumière BH1750. Cette fois, je propose non seulement de prendre des données sur le niveau d'éclairage, mais aussi d'ajuster la luminosité de tout appareil d'éclairage en fonction de ces données. Semblable au réglage de la luminosité de l'écran d'une tablette ou d'un smartphone - plus la lumière ambiante est brillante, moins la luminosité de l'éclairage est nécessaire, et vice versa, plus il fait sombre, plus la LED, les ampoules ou tout autre élément brûleront. Oui, tout cela peut être organisé sur la base d'une photodiode ou d'une photorésistance, mais de tels dispositifs doivent être configurés, calibrés, etc. Dans le cas de l'utilisation du capteur de lumière numérique BH1750, il n'est pas nécessaire d'effectuer ces actions, puisque tout a déjà été calibré devant nous ; les données prêtes à l'emploi sont transmises via le bus I2C, qu'il suffit de comparer avec l'état ; . En termes simples, je l'ai allumé et tout a immédiatement commencé à fonctionner sans mouvements inutiles. Si l'idée vous intéresse, continuez plus loin.

Nous allons construire l'appareil selon le schéma suivant :

Le système s’est avéré être le germe d’une idée, puisqu’il peut et doit être modernisé pour divers cas d’utilisation, mais nous y reviendrons plus tard.

Tout ici nous est déjà familier. Le microcontrôleur utilisé est Atmega8a, le microcontrôleur le plus polyvalent et le plus populaire. Vous pouvez utiliser un microcontrôleur dans n'importe quel package - il n'y a aucune différence, à l'exception de l'ordre des broches sur les boîtiers. L'affichage s'effectue sur un écran LCD basé sur HD44780. Dans mon cas, j'utilise un écran avec 4 lignes de 20 caractères chacune, mais vous pouvez également utiliser la taille 1602 - peu d'informations sont affichées à l'écran, donc tout rentre. La résistance variable R2 est nécessaire pour régler le contraste des caractères sur l'écran. En tournant le curseur de cette résistance, nous obtenons pour nous les lectures les plus claires sur l’écran. Le rétroéclairage de l'écran LCD est organisé via les broches « A » et « K » sur le tableau d'affichage. Le rétroéclairage est activé via une résistance de limitation de courant - R1. Plus la valeur est élevée, plus le rétroéclairage de l'écran est faible. Il ne faut cependant pas négliger cette résistance pour éviter d’endommager le rétroéclairage. L'écran lui-même est connecté au microcontrôleur à l'aide d'un circuit 4 bits. La résistance R3 est nécessaire pour empêcher le redémarrage spontané du microcontrôleur en cas de bruit aléatoire sur la broche PC6. La résistance R3 tire la puissance plus vers cette broche, créant de manière fiable un potentiel à travers elle. La résistance R4 tire la patte du capteur vers la terre, qui est responsable de l'adresse du microcircuit pour l'interface I2C, vous pouvez voir tous ces numéros dans le code source, qui se trouve à la fin de l'article ; Pour le bon fonctionnement de l'interface I2C, les résistances R7 et R8 sont nécessaires. Avec leur aide, une unité logique est formée sur les lignes du fait qu'elles sont tirées vers la puissance positive. Lors de la génération d'un zéro logique, les lignes sont mises à la terre par un maître ou un esclave (microcontrôleur ou capteur).

L'alimentation principale du circuit est de 3,3 volts, déterminée par les paramètres électriques du capteur de lumière BH1750. 5 volts sont nécessaires uniquement pour alimenter l'écran ; si vous utilisez, par exemple, un écran du Nokia 5110, qui nécessite également 3,3 volts pour l'alimenter, vous pouvez alors omettre le régulateur de tension de 5 volts du circuit. Les stabilisateurs de tension pour 5 volts et 3,3 volts peuvent être utilisés absolument pour des tensions similaires ; vous pouvez utiliser des stabilisateurs linéaires et pulsés.

Parlons maintenant de la modernisation du circuit. La base sera toujours le capteur lui-même et le microcontrôleur, ainsi que le circuit d'alimentation. L'écran LCD, doté de cette fonctionnalité, n'est nécessaire que pour le débogage. Il peut être exclu du circuit lorsqu'il est utilisé de manière autonome. C'est le premier. La seconde est la sortie du circuit, c'est-à-dire la LED HL1 - une LED ne peut pas éclairer un grand espace et vous devez utiliser quelque chose de plus massif - des LED puissantes, des lampes à incandescence ou autre chose. Ainsi, de tels dispositifs d'éclairage avec une consommation de courant et de tension relativement élevée ne peuvent pas être facilement connectés au microcontrôleur, sinon nous brûlerons simplement le microcontrôleur. Pour ce faire, vous devez utiliser des pilotes ou d'autres circuits. Si les ampoules à incandescence utilisent une tension alternative, vous devez utiliser un coupleur optosimistor et un triac puissant pour contrôler la luminosité de l'ampoule (il vous suffit de modifier le firmware pour contrôler l'optosimistor). Pour les lampes LED, le PWM peut être appliqué à la grille d'un transistor à effet de champ et allumer les LED à travers celui-ci (sans oublier de limiter ou de stabiliser le courant), ou utiliser des pilotes contrôlés pour celles-ci. En général, il existe de nombreuses options - il y en a une pour chaque cas. Le circuit présenté sera le premier avec les fonctionnalités de base définies. Voici l'idée.

Le circuit suivant a été assemblé et débogué sur une carte de débogage en conjonction avec le module BH1750 :

La logique de fonctionnement n'est pas compliquée : nous lisons la valeur d'éclairage du capteur et convertissons cette valeur en un signal PWM. Il vous suffit de sélectionner le rapport entre le signal PWM et le niveau de lumière.

Pour déboguer le travail, une lampe de poche a été utilisée pour changer l'éclairage.

De plus, si une source de lumière apparaissait soudainement (cela pourrait être accidentel), la LED s'allumerait brusquement, ce qui n'est pas très confortable, c'est pourquoi un contrôle fluide du niveau PWM est mis en œuvre. C'est-à-dire, par exemple, qu'il y avait un faible éclairage - la LED était allumée, une courte impulsion de lumière a accidentellement frappé le capteur, par exemple, des phares d'une voiture, la LED se serait éteinte brusquement et se rallumerait soudainement, sinon pour une régulation fluide. Autrement dit, avec un changement brusque d'éclairage, le PWM ne change pas brusquement, mais tend à atteindre la valeur calculée, augmentant ou diminuant d'une seule unité avec un léger retard. Et tant de fois, l'augmentation ou la diminution se produit jusqu'à ce que la valeur requise soit atteinte. Le code source en langage C est consultable en fin d’article.

De plus, pour programmer le microcontrôleur dans cette version, vous devez connaître la configuration des bits fusibles :

Et l'article est livré avec un firmware pour le microcontrôleur selon le schéma présenté, le code source du programme AVR Studio et une vidéo de démonstration (changement fluide de la luminosité des LED en fonction du niveau de lumière, qui est ajusté avec une lampe de poche).

Liste des radioéléments

Désignation	Taper	Dénomination	Quantité	Note	Boutique	Mon bloc-notes
IC1	MK-AVR 8 bits	ATmega8A	1			Vers le bloc-notes
IC2	Capteur de lumière	BH1750FVI-E	1			Vers le bloc-notes
VR1	Régulateur linéaire	L7805AB	1			Vers le bloc-notes
VR2	Régulateur linéaire	AMS1117-3.3	1			Vers le bloc-notes
C1, C3, C5, C7	Condensateur	100 nF	4			Vers le bloc-notes
C2		470 µF	1			Vers le bloc-notes
C4	Condensateur électrolytique	220 µF	1			Vers le bloc-notes
C6	Condensateur électrolytique	10 µF	1			Vers le bloc-notes
R1	Résistance	22 ohms	1			Vers le bloc-notes
R2	Résistance réglable	10 kOhms	1			Vers le bloc-notes
R3	Résistance	10 kOhms	1			Vers le bloc-notes
R4, R7, R8	Résistance	4,7 kOhms	3			Vers le bloc-notes
R5	Résistance

Affichage suivant : http://ali.pub/1xz0e2

J'ai acheté celui-ci : http://ali.ski/zF01b

Tout d'abord, ajoutons un bloc pour recevoir des données de l'écran Nextion. Ça s'appelle Nextion Obtenir une attr.

Ce bloc se trouve dans le programme FLProg : Panneau HMI Nextion -> Éléments -> Obtenir le paramètre

La configuration de ce bloc est la suivante :

Pour configurer ce bloc, vous devez sélectionner le panneau à partir duquel nous recevrons les données, ou si vous créez un nouveau panneau. Et choisissez comment ce panneau est connecté à l'Arduino.

Eh bien, créons un élément Slider et attribuons-lui son nom et son identifiant dans le panneau Nextion.

Paramètre, sélectionnez (val) et sélectionnez la période d'interrogation toutes les secondes.

Ceci termine la configuration du bloc de réception des paramètres.

La configuration de ce bloc ressemble à ceci :

L'essentiel de ce bloc est de sélectionner le panneau Nextion précédemment créé et de remplacer la constante par l'entrée.

Après cela, vous devez ajouter un bloc Changement de numéro qui se trouve Éléments de base -> Détecteur de changement de nombre

Et connectez le tout selon ce schéma :

Ensuite, chargez le tout dans Arduino et profitez de la modification de la luminosité de notre écran.

Plus clairement dans la vidéo :

Je travaille actuellement sur un projet Arduino utilisant un écran TFT. Récemment, j'ai voulu y ajouter une fonction apparemment simple : une fonction de contrôle de la luminosité. J'ai trouvé la méthode requise dans la documentation de la bibliothèque pour travailler avec un écran TFT (bibliothèque UTFT) : setBrightness(br);

De quoi avons-nous besoin ?

• Comme base, j'ai utilisé Frearduino ADK v.2.2 basé sur le processeur ATmega2560
• Méga bouclier TFT LCD v.2.2
• L'écran lui-même est un 7" TFT LCD SSD1963 ()
• Bibliothèque UTFT - une bibliothèque universelle pour travailler avec les écrans TFT (vous pouvez trouver la bibliothèque elle-même, ainsi que la documentation)
• Fer à souder

Parlons du matériel

Après avoir ouvert le circuit d'affichage, vous pouvez voir que le convertisseur mp3032 dispose de trois entrées : LED-A, PWM, 5V. Initialement, PWM est inactif. Cette entrée n’est pas du tout utilisée. Le rétroéclairage est contrôlé par LED-A.

Si vous regardez à l'arrière de l'écran, vous trouverez une zone intitulée « Contrôle du rétroéclairage ». C’est là que nous trouverons ces mêmes entrées. Pour contrôler le rétroéclairage à l'aide de la méthode PWM, vous devez vous assurer que tout est inversé : LED-A est inactive, PWM est actif. Pour ce faire, vous devrez ressouder le cavalier. Voici une photo de ce à quoi cela devrait ressembler :

Partie logicielle

Puisque notre bibliothèque ne peut pas fournir ce dont nous avons besoin, nous écrirons nous-mêmes la fonction nécessaire. Pour ce faire, ouvrez la documentation du contrôleur qui contrôle l'affichage (SSD1963). Le SSD1963 est contrôlé à l'aide de commandes spéciales transmises depuis Arduino via des sorties spéciales, décrites dans la documentation :

Le contrôle s'effectue comme suit : sorties Arduino via RS (D/C dans le tableau) 0 si on va transmettre une commande, 1 si on va transmettre des données. Après avoir transmis la commande, RS passe à 1, puis les paramètres nécessaires sont transmis. Toutes les commandes et paramètres sont transmis via les sorties D0-D7. Si vous possédez un ATmega2560, ces huit sorties sont combinées dans le port C.

Alors, commençons par écrire une fonction pour transmettre des données sur le bus. Pour plus de facilité d'utilisation, j'écrirai directement dans UTFT.h :

Void Lcd_Writ_Bus(uint8_t bla) ( digitalWrite(WR,LOW); //Configurer le SSD1963 pour lire digitalWrite(CS, LOW); PORTC = bla; //Transférer les données vers le bus sous la forme d'un octet digitalWrite(CS,HIGH) ; digitalWrite( WR,ÉLEVÉ);

Il convient également de prêter attention aux noms des méthodes, car la bibliothèque peut déjà contenir des fonctions portant les mêmes noms.
Ajoutons deux fonctions pour générer des commandes et des données :

Void Lcd_Write_Com(uint8_t data) ( digitalWrite(RS,LOW); //Basculer RS ​​en mode de lecture de commande, c'est-à-dire 0 Lcd_Writ_Bus(data); ) void Lcd_Write_Data(uint8_t data) ( digitalWrite(RS,HIGH); //Switch RS en mode lecture de données, soit 1 Lcd_Writ_Bus(data)

Maintenant, le réglage du rétroéclairage lui-même. Pour savoir comment faire tout cela, ouvrez la documentation et recherchez la commande pour configurer PWM.

Note:

PWM peut être contrôlé à l'aide de DBC - un système de contrôle dynamique de la luminosité, mais par souci de simplicité, je ne l'ai pas utilisé. Si vous le souhaitez, vous pouvez trouver les informations nécessaires dans la même documentation.

Voici donc ce dont nous avons besoin :

C'est-à-dire qu'il faut d'abord transmettre la commande « 0xBE », puis, comme 3 paramètres, transmettre la fréquence du signal, la durée du cycle de fonctionnement, ainsi que le troisième paramètre qui détermine si DBC est activé ou non (0x01 - désactivé , 0x09 - activé) .

Pour régler la luminosité elle-même, il vous suffit de modifier la fréquence du cycle de fonctionnement. Puisque nous transmettons les données sous forme d'un octet, les valeurs de boucle peuvent aller de 0 à 255. J'ai décidé de définir 9 niveaux de luminosité (de 0 à 8). Par conséquent, les 256 valeurs doivent être divisées en 9 étapes. Mais il convient également de prêter attention au fait que si les pas sont égaux, la luminosité ne changera pas aussi doucement que nous le souhaiterions. C'est-à-dire que déjà, par exemple, à la 4ème étape, la luminosité sera presque maximale, et de la 4ème à la 8ème étape, elle changera presque imperceptiblement. Compte tenu de cela, j'ai décidé d'utiliser une progression géométrique avec un dénominateur de 2. C'est-à-dire que la luminosité sera calculée à l'aide de la formule suivante : (2^lvl) - 1, où lvl est le niveau de luminosité de 0 à 8. Notez que puisque les valeurs partent de zéro, vous devez alors en soustraire un. Bien sûr, vous pouvez choisir vous-même les étapes et leurs valeurs, mais j'ai donné cet exemple assez simple. Maintenant le code lui-même :

Void setBright (niveau d'octet) ( luminosité d'octet (1); pour (octet i (1); i<= lvl; i++) //Возведение в степень brightness *= 2; Lcd_Write_Com(0xBE); //Вывод команды Lcd_Write_Data(0x01); //Ставим частоту 760Гц Lcd_Write_Data(brightness-1); //Выводим длину рабочего цикла Lcd_Write_Data(0x01); //Отключаем DBC }

Vous pouvez maintenant utiliser UTFT.setBright(byte lvl);

Avec l'iPhone X, Apple a utilisé pour la première fois un panneau d'affichage basé sur la technologie OLED. Et si les avantages des écrans OLED sont évidents, leurs inconvénients sont rarement évoqués. L'un de ces inconvénients est le scintillement de l'écran à de faibles niveaux de luminosité en raison de l'utilisation de la modulation de largeur d'impulsion pour contrôler la lueur des LED à de faibles niveaux de luminosité. Dans le langage de l’utilisateur moyen, l’écran scintille dans l’obscurité.

Les fabricants choisissent la fréquence de scintillement de l'écran de manière à ce que la plupart des utilisateurs ne le remarquent pas. La fréquence la plus couramment utilisée est 240 Hz. Même si nous excluons un groupe important de personnes qui remarquent un tel scintillement, il reste ceux qui ne le remarquent pas, mais ressentent une fatigue accrue, des larmoiements, une inflammation et une rougeur des yeux, voire des migraines. Ces personnes ne sont pas si rares : selon l'étude et la méthodologie utilisée, leur nombre varie de 20 à 30 % de l'ensemble des utilisateurs.

Sur les appareils Android, le scintillement OLED peut souvent être résolu en installant une application qui affiche un filtre de gradation ; vous pouvez même maintenir le contrôle automatique de la luminosité si vous utilisez l'application Lux Dash pour cela (nous expliquerons comment la configurer correctement pour désactiver le scintillement de l'écran dans l'un des articles suivants).

Il s'avère qu'iOS dispose d'un mécanisme intégré qui vous permet d'obtenir un effet similaire et de vous débarrasser complètement du scintillement de l'affichage dans l'obscurité. Examinons les étapes requises pour cela, mais nous répondrons d'abord à la question de savoir pourquoi les écrans OLED ont besoin de scintillement.

Pourquoi les OLED scintillent : contrôle de la luminosité PWM

Le scintillement des écrans OLED est le résultat direct du mécanisme utilisé pour contrôler la luminosité de ces panneaux. Pour modifier la luminosité de l'écran (à la fois LCD conventionnel, sur lequel sont basées les matrices IPS, et OLED), vous pouvez soit réduire la tension fournie aux LED de rétroéclairage (ou aux LED individuelles dans le cas des OLED), soit utiliser ce qu'on appelle modulation de largeur d'impulsion.

La modulation de largeur d'impulsion contrôle la luminosité de l'image en allumant et éteignant les LED. Plus la période pendant laquelle le rétroéclairage est allumé est courte et plus la pause entre les allumages est longue, plus la luminosité perçue par l'œil humain est faible. Voici à quoi cela ressemble :

C’est le scintillement, et non la composante bleue nocive de la couleur ou les couleurs sursaturées des OLED, qui provoquent une fatigue et des migraines accrues. Le scintillement provoque la plus grande pression sur les yeux dans l'obscurité, lorsque la pupille est dilatée au maximum et que des éclairs lumineux bombardent littéralement la rétine.

OLED sans scintillement : mythe ou réalité ?

Est-il possible d'assembler un écran OLED sans scintillement ? Oui, c'est tout à fait possible, mais en pratique, c'est rarement utilisé. L'un des rares exemples de tels écrans est la matrice P-OLED, installée dans les smartphones LG G Flex 2. L'inconvénient de ces écrans était les effets suivants, qui apparaissaient avec une luminosité minimale :

Ce serait une erreur de croire que LG a rendu la matrice bien pire que celle de ses concurrents. À l'époque, les matrices Samsung avaient une qualité similaire, avec une différence majeure. Les panneaux OLED que Samsung installe dans tous ses produits phares scintillent à tous les niveaux de luminosité, même à 100 %. Pourquoi l'image sur une matrice scintillante semble-t-elle tellement plus nette que sur une OLED sans scintillement ?

L'effet est associé à la répartition des paramètres entre les LED adjacentes. La diffusion est présente sur les matrices de tous les fabricants, mais elle se manifeste davantage lorsqu'une basse tension est appliquée aux LED. L'effet est quelque peu similaire au bruit numérique lors de photographies dans des conditions sombres avec une vitesse d'obturation courte. Moins il y a de photons frappant les éléments sensibles à la lumière de la matrice - et moins il y a de photons émis par la diode OLED - plus la probabilité d'une erreur, de « bruit numérique inversé », est grande.

Samsung a résolu le problème en fournissant toujours la tension maximale aux LED et en ajustant la luminosité en utilisant le rapport cyclique des impulsions. Mais le scintillement constant de l'écran n'est pas du goût de tout le monde, et nombre de constructeurs ont opté pour une approche hybride : jusqu'à une certaine valeur, la luminosité est ajustée en réduisant la tension des LED ; Après avoir franchi un niveau minimum prédéterminé (généralement 15 à 50 %), une réduction supplémentaire de la luminosité est obtenue à l'aide du PWM.

Si nous parlons spécifiquement de l'iPhone X, la luminosité de celui-ci est ajustée comme suit (selon iXBT) :

Jusqu'au niveau de 50 %, il n'y a pas de scintillement ; une réduction supplémentaire de la luminosité est obtenue par un scintillement à une fréquence de 240 Hz. Cela a été démontré de manière convaincante par les critiques allemands du site Notebookcheck.net :

Comment vérifier le scintillement de l'écran

L'écran de votre téléphone scintille ? Même si vos yeux ne remarquent aucun scintillement, sa présence ou son absence peut être facilement vérifiée à la maison sans aucun équipement spécial. Il vous suffit d'ouvrir une page avec un fond blanc sur votre smartphone (par exemple, about:blank dans le navigateur Safari ou Chrome), de placer le téléphone dans une pièce sombre, de réduire la luminosité au minimum et de pointer la caméra d'un autre smartphone à l’écran. Si nous voyons quelque chose de similaire à ce qui est montré dans la vidéo ci-dessous, un scintillement de l'écran est présent :

Pour déterminer à quel niveau de luminosité l'écran cesse de scintiller, ouvrez le centre de contrôle et déplacez doucement le curseur de luminosité. La disparition des bandes diagonales signifie qu'il n'y a pas de PWM à un niveau de luminosité donné.

Il a été établi expérimentalement que l'iPhone X a un niveau de luminosité minimum sans scintillement de 50 %. Mais si vous maintenez la luminosité à ce niveau, dans des conditions sombres, l'appareil sera inconfortable à utiliser. L’objectif est de réduire le niveau de luminosité effectif de l’écran, mais d’éviter le scintillement.

Il s’avère que c’est tout à fait possible. Pour ce faire, il existe un mode spécial dans les paramètres iOS, qui se trouve dans les paramètres Accessibilité > Afficher les hébergements.

Dans ce mode, l'écran est assombri par un filtre logiciel. Pour activer ce mode, vous devez accéder à Afficher les hébergements et activer le curseur. Vous devez maintenant cliquer sur l'inscription Afficher les hébergements et activer le curseur Réduire le point blanc (voir capture d'écran). Essayez de commencer avec une valeur comprise entre 85 et 100 % et ajustez-la à un niveau confortable pour vos yeux (la luminosité de l'écran dans le centre de contrôle doit être de 50 %).

Désactivez PWM en trois clics

Nous avons donc pu activer un filtre logiciel qui désactive le scintillement de l'écran à de faibles niveaux de luminosité. Cependant, utiliser un téléphone avec le filtre toujours activé n'est pas pratique : en pleine lumière, l'écran sera toujours sombre.

Sur l'iPhone X, l'activation et la désactivation du filtre peuvent être effectuées en appuyant trois fois sur le bouton latéral, qui, dans les générations précédentes d'appareils, remplissait les fonctions d'allumage et d'extinction du téléphone. Pour ce faire, vous devez rechercher l'option Raccourci d'accessibilité dans les paramètres et l'attribuer pour activer ou désactiver la fonction Réduire le point blanc (voir captures d'écran).

C'est tout. Après avoir activé cette fonctionnalité, nous avons obtenu l'iPhone X, dont le scintillement de l'écran peut être rapidement activé et désactivé en appuyant trois fois sur le bouton latéral. Vous pouvez désormais utiliser l'appareil dans l'obscurité sans fatigue et désactiver rapidement le filtre sombre en appuyant trois fois sur le bouton latéral.

Informations Complémentaires

Explications sur le schéma

R2 est une résistance variable d'une valeur nominale de 10K. La borne centrale de la résistance est connectée via un filtre passe-bas au canal zéro de l'ADC. La tension aux bornes de la résistance est convertie en un code numérique, qui est écrit dans le registre de comparaison du temporisateur T0. Ainsi, à l'aide d'une résistance, le rapport cyclique du signal PWM est ajusté.

Led1 est une puissante LED blanche. La chute de tension à ses bornes est d'environ 4 Volts. Le courant maximum des LED est fixé par la résistance R5 et est égal à 100 mA.

(Upit – Uled)/R5 = (5 - 4)/10 = 100 mA

IRLU024N – Transistor à effet de champ à canal N. Au lieu de cela, vous pouvez utiliser n'importe quel transistor à effet de champ de la série IRL (L - cela signifie qu'ils sont contrôlés par un niveau logique)

R3 est une résistance de limitation de courant au cas où. R4 – résistance pull-down. La grille d’un transistor à effet de champ ne peut pas être laissée « suspendue en l’air ».

Programme

//************************************************************
// Stage de formation. Programmation des microcontrôleurs AVR en C
// Contrôle la charge en utilisant
// modulation de largeur d'impulsion (PWM, PWM)

#inclure
#inclure

int principal( vide)
{
//initialise les ports
PORTB = 0 ;
DDRB = 0xff ;

//initialise le temporisateur T0
TIMSK = 0 ;
//rép. - pwm rapide, sortie OC0 - non inversée. cale, clk/64
TCCR0 = (1<TCNT0 = 0 ;
ROC0 = 0 ;

//initialise l'ADC
//ion - tension d'alimentation, alignement à gauche, canal zéro
ADMUX = (0<//sur ADC, réal. continu convertir., rés. interruptions, fréquence du convertisseur = FCPU/128
ADCSRA = (1<//mode de conversion continue
SFIOR = 0 ;

__enable_interrupt ();
alors que (1);
retour 0;
}

//********************************
//Interruption ADC
#pragma vecteur=ADC_vect
__interromprevide adc_my( vide)
{

//lire le registre haut de l'ADC et

//écrit dans le registre de comparaison

Explications pour le code

Logique de fonctionnement

Initialisation des périphériques - timer T0, module ADC. Activer les interruptions. Boucle sans fin. Dans l'interruption ADC, la tension lue sur la résistance variable est écrite dans le registre de comparaison OCR0. Dans le microcontrôleur AVR, un tampon est organisé pour ce registre, et en fait, l'écriture s'y produit en premier. Depuis le tampon, la valeur est réécrite dans OCR0 uniquement lorsque le registre du compteur TCNT0 déborde. En parallèle avec la boucle while et le module ADC, la minuterie T0 s'exécute et génère un signal PWM sur la broche OC0 (PB2). Lorsque le registre de comptage TCNT0 déborde, OC0 est mis à 1, lorsque la valeur du registre de comptage correspond au registre de comparaison OCR0, la sortie est mise à 0.

Initialisation de la minuterie

Les interruptions de minuterie ne sont pas utilisées, donc le registre TIMSK = 0.

Le registre de configuration TCCR0 est responsable du réglage du temporisateur T0.

Les bits WGM01, WHM00 déterminent le mode de fonctionnement. 11 - Mode PWM rapide.

Bits CS02, CS01, CS00 - définissent le coefficient du pré-échelonneur de minuterie. 011 - correspond au prescaler 64. La fréquence de la minuterie/compteur sera Fcpu/64

Les bits COM01, COM00 déterminent le comportement de la broche OC0. 10 - correspond à un signal PWM non inversé. 1 - lorsque TCNT0 déborde, 0 - lorsque TCNT0 coïncide avec OCR0.

Initialisation de l'ADC

Exemple n°2. Générer une onde sinusoïdale à l'aide de PWM

Explication du schéma

J'ai simplement oublié de retirer la résistance R2 du circuit. Intégrateur R3 et C8.

Programme

//************************************************************

// Génère un sinus en utilisant

// modulation de largeur d'impulsion (PWM, PWM)

//************************************************************

#inclure
#inclure
#include "TableSin.h"

int principal( vide )
{
//initialise les ports
PORTB = 0 ;
DDRB = 0xff ;

//initialise le temporisateur T0
TIMSK = (1<//rép. - pwm rapide, sortie OC0 - non inversée. cale, prédétartreur - par 8
TCCR0 = (1<//réinitialise le registre de comptage et le registre de comparaison
TCNT0 = 0 ;
ROC0 = 0 ;

__enable_interrupt ();
alors que (1);
retour 0;
}

//**********************************************************

//Temporisateur/compteur d'interruption T0

#pragma vecteur = TIMER0_COMP_vect

__interromprevide Minuterie0CompVect( vide)