TCP / UDP

innhold
  1. Internett-protokoller, del 1: TCP / IP, grunnlaget for protokollene
  2. TCP / UDP
  3. transmisjonsmekanismer
  4. Konklusjon og fremtidsutsikter
  5. leste på en side

TCP / UDP: to ulike søsken

Når du velger en som passer for din egen søknad protokollen bortskjemte starter med å avgjøre om TCP eller UDP brukes. User Datagram Protocol (UDP) er beskrevet i RFC 768 og lar deg sende meldinger (datagram) til en eller flere mottakere. En forbindelse mellom sender og mottaker ikke er etablert. Avsenderen har ingen måte å avgjøre om en mottatt melding. Det er heller ikke sikker på om meldinger i samme rekkefølge levert til adressaten, der de ble sendt.

Siden UDP selve meldingen legger lite informasjon i overskriften og dataene blir levert uten ytterligere kontroll til mottakeren, er overføring veldig fort. etablere riktig rekkefølge av meldingene og be tapte data på nytt, men det er opp til applikasjonen.

Flere mottakere kan oppnås med en broadcast adresse innen et subnett. Spesielt denne egenskapen gjør UDP interessant for applikasjoner som node signal hendelser i nettverket eller automatisk se etter andre noder. Med sistnevnte, sender du en epost til alle noder. Etter en viss tid uten svar, blir forespørselen gjentas.

Når (TCP) Transmission Control Protocol sikre sikker overføring av data er viktig. en forbindelse må gjøres før starten av transmisjonen. Mellom de to endepunktene for koblingen, er en datastrøm som er mulig i begge retninger (full dupleks). TCP sikrer at mottakerne motta dataene i nøyaktig samme rekkefølge som den sender senderen (rør).

De viktigste forskjellene mellom UDP og TCP er:

  • UDP er forbindelsesløs. TCP er forbindelsesorientert.
  • UDP overfører meldinger. TCP sender en datastrøm.
  • UDP er verken for eller levering av meldinger trygt. TCP sørger for sikker levering av data i riktig rekkefølge.
  • UDP-pakker kan sendes til flere mottakere (broadcast). TCP bare tillatt kommunikasjon mellom to sammenkoblede noder.

Transmission Control Protocol tillater programmer å overføre data pålitelig uten å måtte forholde seg til detaljene i nettverkslaget. Spesifikasjonen og gjennomføring av protokollene, idet det TCP som en basis, blir derved betydelig forenklet. Likevel må de møtes, avhengig av behov mange oppgaver. For å forstå hvilke funksjoner et program protokollen må gi nøyaktig, så det gir moderne Internett-applikasjoner, et solid fundament, er forklart noen grunnleggende funksjoner i TCP nedenfor.

forbindelse søkes

Hver TCP / IP-forbindelse blir etablert mellom to såkalte stikkontakter. En holder er en kombinasjon av IP-adresse og TCP-port. IP-adressen identifiserer et nettverksgrensesnitt. Dette kan for eksempel være et nettverksgrensesnittkort (NIC), en trådløs forbindelse eller den interne lokale vertsgrensesnittet. En datamaskin kan ha en rekke grensesnitt til ulike nettverk. Nettverkslaget muliggjør utveksling av data mellom forskjellige nett. Denne prosessen kalles videresending. Ofte i sammenheng med begrepet ruting blir brukt, men det er nevnt å bestemme en rute gjennom hele nettverket, fra sender til mottaker.

TCP-porter identifiseres med et tall, og kan tildeles per nettverksgrensesnitt bare én gang. For eksempel er det ikke mulig å starte to Internett-servere som tillater på samme nettverksgrensesnittet på port 80 tilkoblinger.

Således kan en TCP-forbindelse mellom to noder bli etablert i nettverket, må en node være villig til å tillate en forbindelse til en kjent port (velkjent port). Denne tilstanden av forbindelsen kalles en lytte tilstand (Se på). Først nå kan aktivt fra en annen node for å etablere en forbindelse (initiere). Her lytteren varslet herunder fritt tildelt porten på initiator.

JavaScript: Introduction à React

contenu
  1. JavaScript: Introduction à React
  2. Structure, la syntaxe et les caractéristiques
  3. Spécification des objets, des événements et des flux de données
  4. Flux et React
  5. Réductions et conclusion
  6. lire sur un côté
JavaScript: Introduction à React

React est maintenu par une communauté toujours plus développé par le cadre Facebook JavaScript. En raison de la possibilité de rendre React vues à la fois sur le client et sur le serveur, le cadre satisfait de nombreux développeurs très populaires.

Bien que d'autres cadres déjà le chemin d'un isomorphes (client rendus / serveur) sont partis, React diffère d'eux en fonction de base: le modèle objet de document virtuel (DOM). Les points de vue ne sont pas modifier directement les DOM du navigateur, mais gardez pratiquement dans les composants avant et sont donc complètement détachés de toutes les dépendances. Avec des méthodes telles que renderToString (), les composants de React Voir peuvent rendre sur le serveur.

Travaux qui réagissent, certaines grandes entreprises ont déjà montré: Non seulement les parties de Facebook ont ​​été mis au point avec elle, mais aussi des plates-formes telles que Instagram ou la version web de WhatsApp utiliser le cadre. Surtout pour les pages qui devraient jouer un rôle dans les moteurs de recherche est Search Engine Optimization en bref référencement, un critère KO. Par conséquent, il convient de noter que le rendu côté serveur d'applications Web qui ont été développés à l'aide des cadres comme AngularJS, est très cher. Par exemple, en prenant des instantanés du code HTML avec PhantomJS est pas facile dans les pages dynamiques - et pas très performant.

En revanche, dans React tous les composants créent leur propre DOM virtuel. Ainsi, ils peuvent rendre non seulement sur le serveur, ils facilitent également les tests unitaires. Si les composants changent par exemple, par l'interaction de l'utilisateur ou de nouvelles réponses du serveur, le DOM virtuel tente de rendre pas toute l'application, mais seulement le plus petit élément affecté nouveau.

Un exemple peut expliquer le gain de performance plus claire: Supposons qu'il y ait un modèle (voir Model View Controller), qui est destiné à réfléchir à un immeuble de bureaux. Toutes les caractéristiques pertinentes du bâtiment (chambres, fenêtres ...) se reflètent sur l'état actuel de l'objet. Un tel comportement met React avec le DOM à la lumière.

Sont dans le bâtiment de plusieurs salles utilisées pour promouvoir un bureaux décloisonnés, le cadre traiterait comme suit: D'abord, il identifie tous les changements qui ont lieu (réconciliation), puis il met à jour les DOM en conséquence. Il est important que React construire un nouveau bâtiment, mais les chambres en question se redessiner. Donc changer un élément DOM, son élément parent, cependant, ce dernier n'est pas affecté pas.

install React

REACT Starter Kit est disponible en téléchargement ou jsFiddle Snipped avant d'aller de l'avant. Du côté client, il suffit d'intégrer le fichier react.js. En option JSXTransformer.js fixes peuvent ajouter à XML JavaScript (JSX) analyser les composants écrits (plus tard à ce sujet). React le code peut alors, dans un bloc de script avec type ="text / js" développer:










React.render (

Bonjour, monde!

,
document.getElementById ( 'Exemple')
);


Le code JSX est pas dans le code du site, mais il a été sous-traitée à un fichier séparé, ainsi que des outils tels que Webpack ou Browserify et intégrée unique.

Est-Webpack et le module NPM associé jsx-chargeur installé, depuis le fichier webpack.config.js pour commencer à droite:

« Utiliser stricte »;

chemin var = require ( 'path'),
targetPath = (rép __ 'build', 'actifs') path.join,
config;

config = {
résoudre: {
extensions: [ '', 'js', '.jsx']
},
entrée: [
'./site.jsx'
]
sortie: {
path: targetPath,
nom de fichier: '' bundle.js
},
modules: {
chargeurs: [
{Test: /\.jsx$/, chargeur 'jsx-loader'},
]
}
};

module.exports = config;

Le paquet doit être inclus avant la balise de corps de fermeture de la page HTML:


...

Salaires IT: StackOverflow fournit un calculateur de revenus pour les développeurs

Stack Overflow a une calculatrice de revenu pour les développeurs

L'outil web est de montrer aux employés ce que le revenu est approprié pour ses activités dans la région. Les données proviennent du plus récent sondage de développeur de la plate-forme Internet.

Les opérateurs de StackOverflow ont ajouté leurs développeurs de logiciels orientés plate-forme Internet est un outil qui permet de calculer leur revenu à prévoir en fonction de certains facteurs avec le développeur. Les données utilisées comme base, sont de la plus récente enquête de développement. StackOverflow mène depuis 2011 chaque année par enquête Developer. L'enquête n'est pas représentatif, mais en 2017 a pris un total de 64.000 développeurs de certains pour lui donner sans doute exprimé seulement bon 12 000 au revenu, comme il ressort de regarder les tableaux. Allemagne près de 1000 commentaires sont venus au contenu.

Le calculateur de revenu demande les facteurs suivants qui faisaient également partie de l'enquête:

Emplacement en tant que facteur clé

Pour prédire le contenu correspondant StackOverflow utilise la régression linéaire multiple. L'outil calcule de manière aussi fiable que possible, comme l'apprentissage d'une langue supplémentaire a un impact sur le revenu attendu. En tant que la situation géographique de l'ordinateur sait à l'heure actuelle aux États-Unis, au Royaume-Uni, le Canada, l'Allemagne et la France.

Stack Overflow a également attiré séparément les différentes villes du classement, où le revenu du développeur est très différent de la moyenne nationale. Ces valeurs ne se trouvent pas dans les résultats de l'enquête qui ne contenaient pas le terrain pour la ville. Au lieu de cela, l'adresse IP respective des répondants ont utilisé comme base pour déterminer l'emplacement.

Stack Overflow Les développeurs gagnent aux États-Unis évidemment beaucoup plus qu'au Canada et en Europe.(Image: débordement de pile)

Détails pour l'évaluation statistique et d'autres informations sur la calculatrice de revenu peuvent être prises à partir du poste de blog.

Pour des emplois et des possibilités de carrière dans l'industrie des TI voir le marché du travail sur le H:

(RME)

Java 9 est terminée

Java 9 est terminée

Oracle a publié après plusieurs quarts de travail, la version finale du 9 JDK. En plus du système de module très discuté, il a de nombreuses autres innovations telles que la JShell et une API de flux étendu à offrir.

Après le développement de la nouvelle version de Java déjà en 2014 avec les propositions des premières propositions d'amélioration JDK (PEC) ont commencé, il est maintenant, après plus de trois années de développement viennent enfin: Le 9 est JDK la version finale. Il comprend 92, préciser les projets européens changements dans chaque mineur ou majeur. Une liste complète des projets européens se trouve sur le site Web de la JDK9.

Modularisation avec le projet Jigsaw

A l'origine, Jigsaw projet devrait déjà faire partie de 8 Java. Cependant, la modularisation de la plate-forme Java est avéré être compliqué et a été déplacé vers Java. 9 Encore une fois, le projet a été responsable de certains retards dans le calendrier. En particulier, l'impact de la modularisation aux applications existantes a causé beaucoup de discussion et un rejet dans le premier tour de scrutin d'examen public par le Comité exécutif (CE) du JCP.

Cela a conduit à un affaiblissement significatif de Modulkapselung pour que puisse fonctionner d'abord aussi des applications existantes sans modifications majeures. Cette approche vise à permettre une migration progressive des applications existantes, rendant plus facile de passer à Java. 9 Après les ajustements, le projet a reçu l'approbation requise dans le deuxième examen public Ballot en Juin.

Dans le moyen de migrer les applications existantes seront toutefois encore nécessaires, comme les règles d'accès simplifiées devraient disparaître dans les versions ultérieures. Pour les messages d'erreur qui se produisent et de leurs solutions, il y a déjà quelques éléments détaillés.

Expansion de l'API flux

projet Side Jigsaw Java contient 9 beaucoup plus de changements. L'une est l'expansion de l'API Stream. Les caractéristiques de l'interface de flux en Java 9 méthodes supplémentaires qui simplifient la mise en œuvre des tâches communes.

(Les nouvelles méthodes prennent en prédicats<? super T> prédicat) et goutte tandis que (prédicat<? super T> prédicat) peut maintenant appliquer un prédicat pour les premiers éléments d'un flux ordonné et créer ainsi un nouveau flux. La prise en méthode ajoute a ajouté des éléments si longtemps au courant, jusqu'à ce qu'un prédicat n'est pas satisfait. La baisse tandis que la méthode, cependant, articles loin tant qu'ils ne satisfont pas le prédicat. Le flux généré commence donc avec le premier élément du flux original qui ne satisfait pas le prédicat.

En outre, la méthode iterate a été surchargé avec de nouveaux paramètres avec lequel un critère de terminaison pour produire des courants peuvent être définis:

Stream.iterate (1, i -> Je <= 50, i -> 10 * i) .foreach (System.out :: println);

Le comportement résultant est similaire au courant de boucle. Le courant commence avec la semence-élément, dans ce cas 1, à condition que le prédicat, dans cet exemple, <= 50 est satisfaite. l'élément suivant utilise ensuite l'opérateur suivant, ici 10 * i est généré. Cela continue jusqu'à ce que l'élément nouvellement créé ne satisfait plus le prédicat.

En outre, l'interface de flux contient le nouveau procédé ofNullable (T t), ce qui crée un nouveau flux de l'objet donné si elle est non nulle. Lors du passage de zéro, la méthode crée un flux vide.

Facultatif nouvelles méthodes

Aussi l'interface en option a été ajoutée à quelques autres méthodes utiles. Ici sont principalement flux () et ou (Fournisseur<? étend en option<? T étend>> fournisseur) au nom. Le premier crée un flux, lorsque l'option contient une valeur et un flux vide si l'option comprend une valeur nulle. Par conséquent, être déterminé à partir d'un flux> génération d'un flux. La ou méthode vous permet de créer une nouvelle option si l'option actuelle contient une valeur NULL:

En option b = books.findBook (titre) (.ou () -> books.createBook (titre));

Java dans le Shell

Un autre ajout intéressant est petit mais la nouvelle application en ligne de commande JShell. Avec elle, les développeurs peuvent exécuter Java expressions au principe de REPL (boucle en lecture Eval-Print). Ceci est de faciliter, entre autres, la création de prototypes et l'apprentissage du langage de programmation:

-> System.out.println ("Bonjour, monde!")
Bonjour, monde!

En plus de l'application en ligne de commande est également une API qui peut être utilisé avec d'autres applications JShell.

De nouvelles méthodes d'usine de collecte

JEP 269 étend les interfaces de collecte à des méthodes d'usine supplémentaires qui créent de petites collections stables beaucoup plus facile.

En utilisant la méthode de-maintenant, par exemple, une liste immuable des éléments peut être produit:

Liste list = List.of ("Une chaîne". "chaîne B". "chaîne C");

Le même procédé est également sur la mise en interface. Il convient de noter qu'il ne supporte pas les valeurs nulles, et l'ordre des éléments dans l'ensemble n'est pas défini:

Set set = Set.of ("Une chaîne". "chaîne B". "chaîne C");

méthodes comparables les créateurs ont ajouté à l'interface de la carte. Ici, les développeurs peuvent désormais créer une carte immuable jusqu'à dix paires clé-valeur avec la méthode de:

map =
Map.of ( "String A" 1, "Chaîne B" 2, "String C", 3);

Qui a besoin d'une carte avec plusieurs éléments, ils peuvent utiliser les essais du four (Map.Entry<? étend K,? étend V>... entrées) Créer:

map =
Map.ofEntries (entrée ( "String", 1);
entrée ( "String B", 2);
entrée ( "String C", 3);

Oracle prévoit des cycles de libération plus courts

La sortie du JDK 9 apporte de nombreux changements et dépose modularisation les bases pour le développement du langage de programmation. À l'avenir, cette évolution devrait avoir lieu dans les plus petites et beaucoup plus rapides étapes. Les versions ultérieures apparaîtront tous les 6 mois.

Java 2017

Plus d'informations sur Java 9, Java EE 8 et les développements actuels dans l'environnement Java est disponible dans le spécial Developer iX Edition, qui est disponible, entre autres, dans la boutique H.

Ici, Oracle mettra également à jour les cycles de support et différents en commençant par 9 entre JDK non LTS et LTS libère. La plupart - y compris JDK9 - sont classés comme des rejets non LTS. Le soutien à la fin au bout de six mois, de sorte que les mises à jour fréquentes sont nécessaires. Tous les trois ans à plus créé une étiquette comme LTS, qui est exécuté comme les versions existantes JDK sur plusieurs années.

A l'heure Oracle a célébré officiellement lors de la soirée de lancement de Munich le lancement de Java 9; le téléchargement était pas encore disponible.

[Mise à jour 9/22. 7:00]:

Pendant ce temps, le 9 OpenJDK est officiellement en ligne. La construction open source peut être téléchargé à partir Java.net. Sur Java.com cependant encore lieu Java 8.(Thorben Janssen) /(RME)

Dans la voie rapide avec Teensy 3.2

En plus de la famille Arduino il y a maintenant beaucoup de cartes qui écrivent la compatibilité Arduino sur leurs bannières. Un exemple frais petit facteur de forme et le prix bas sont les conseils de la famille Teensy. Dont la version 3.2 devrait venir exemplairement discuté.

Après les derniers épisodes des exemples de projets concrets pour la plupart ont été consacrés à des effets de lumière, je veux présenter une carte microcontrôleur à nouveau après une longue période cette fois-ci. En plus de la famille de l'original Arduino il y a toute une série de conseils provenant d'autres sources, qui permettent la programmation de l'Arduino IDE. Quelque chose conseils plus puissant, mais plus chers sont disponibles par exemple d'Intel.

Qui moins cher de préférence, est spécifiquement pour les cartes avec les processeurs ARM faveur sous licence. Ils offrent un bon rapport qualité-prix et des facteurs de forme plus petits. Plus précisément, je veux que ce temps d'introduire un des conseils de mon équipe de microcontrôleur dans un bref aperçu: le Teensy 3.2 de PJRC.

Note sur notre propre nom

Je l'ai décrit dans un passé récent, deux autres conseils intéressants.

  • Le Conseil photonique des particules qui intègre non seulement un microcontrôleur et un composant sans fil, et pour les projets IdO est grande: l'article.
  • L'Arduino cultivé MKR1000 qui intègre les fonctions spécialement IdO: l'article.
Teensy 3.2 dans le cadre d'une famille de produits
A 3.2 Teensy est bien équipé pour Maker / projets IdOA 3.2 Teensy est bien équipé pour Maker / projets IdO

Les petites entreprises américaines PJRC.com a créé ce puissant carte compatible Arduino. Qui devrait être surpris par le nom de la société PJRC: représentant le fondateur de l'entreprise, Paul J. Stoffregen et Robin Coon. Stoffregen est connu dans les cercles Arduino pour son soutien dévoué de la communauté Arduino.

Teensy 3.2, succédant teensy 3.1 est un système de développement de microcontrôleur complet basé sur USB pour un prix modéré d'environ 19,80 dollars américains.

Comme son frère Teensy LC est également Teensy 3.2 une carte 32 bits. Contrairement à cela, il est basé un microcontrôleur Cortex-M4 72 MHz. Il peut être, soit dit en passant, overclocker facilement à 96MHz. Fait intéressant, le M4 est principalement en raison de ses fonctionnalités supplémentaires, pour DSP (Digital Signal Processing), un important pour les appareils IdO ou micro-contrôleurs fonction.

Mais le Teensy 32 Bitter 3.2, 3.1 et LC ne sont pas les seuls représentants de la famille Teensy. En outre, il y a encore les 8 bits conseils Teensy Teensy 2.0 et 2.0 Teensy ++ avec des processeurs Atmel AVR. l'article pour le manque d'espace est un pas plus parce qu'ils se déplacent plus dans le spectre des prix et des performances des cartes Arduino classiques.

L'accent est donc entièrement sur la machine de course en cours sous les Teensies, le Teensy 3.2.

Entrées et sorties

Les broches de la Teensy 3,2 attend des signaux de 3,3 V, mais sont tolérants à 5V. Dans l'ensemble, la carte dispose de 34 ports E / S, y compris les 21 entrées analogiques et 12 avec PWM - (= modulation de largeur d'impulsion) support. Avec 256K flash et 64 Ko de RAM la carte fournit un multiple de l'équipement d'un Mega Arduino. En outre, il y a 2K mémoire EEPROM. Il y a trois UART à bord, et deux bus I2C et SPI pour la communication. Contrairement à cartes Arduino le Teensy 3.2 carte dispose également d'une connexion de bus CAN.

Teensy 3.1 / 3.2 Vue de face des brochesTeensy 3.1 / 3.2 Vue de face des brochesTeensy 3.2 vue de dessousTeensy 3.2 vue de dessous

Première impression: Donc, 3,2 Teensy a beaucoup de potentiel pour des projets plus complexes.

programmation

En teensyduino pour aider les conseils Teensy facilement dans l'intégration Arduino IDE En teensyduino pour aider les conseils Teensy facilement dans l'intégration Arduino IDE


Pour utiliser Teensy 3.2 sous l'Arduino IDE, vous devez installer le logiciel premier teensyduino. Je suppose que vous avez déjà installé l'Arduino IDE et au moins une fois. Dans le cas contraire, l'installation de teensyduino fonctionne pas. Sous Windows, vous avez encore besoin d'un pilote supplémentaire pour Teensy 3.2.

Une fois l'installation sont Outils Arduino IDE | Conseil Les systèmes disponibles Teensy. En outre, des exemples précis des panneaux d'esquisse se trouvent dans le menu échantillon.

Vous pouvez utiliser des fichiers | Exemples | le programme clignotant obligatoire flash Blink sur le Teensy 3.2. Ensuite, la LED orange de la carte doit clignoter rythmiquement.

Au cours du processus flash, une petite fenêtre apparaît avec le titre sur l'ordinateur hôte "teensy", Ceci est la soi-disant Teensy Loader:

Le chargeur permet également Teensy flash manuel sur les cartes TeensyLe chargeur permet également Teensy flash manuel sur les cartes Teensy

Normalement, le clignotement des Sketches exécute automatiquement l'Arduino IDE. mais vous pouvez également faire toutes les activités manuellement à l'aide chargeur Teensy et charger des sketchs par exemple sous forme de fichiers hexagonaux à la carte. Plus de détails se trouvent sur cette page.

exemple complexe

Un exemple plus complexe illustrera comment le conseil Teensy peut être utilisé pour des projets dans le domaine des petits systèmes embarqués. Pour ce faire, nous connecter la carte à un écran OLED comme un affichage graphique. Dans l'exemple d'un Adafruit SSD1306 est utilisé, ce qui a un timbre de taille moyenne de la taille. Ces types de OLEDs, il y a un prix très raisonnable (de 6 à 7 euros) dans les portails de vente en ligne pertinents. Une recherche "0,96" (Pour la taille 0,96 pouces) et "OLED" suffisante.

L'affichage existe en plusieurs variantes:

pjrc.comConnexion d'un Adafruit SSD1306 OLED affiche à 3,2 teensy(Photo: pjrc.com)

L'exemple montre un 128 x 32 carte I2C. Un grand nombre desdites cartes OLED I2C ont 4 broches (Vcc, GND, SDA, SCL). L'OLED a montré une broche supplémentaire RESET.

En raison de la loi d'inertie pour des informaticiens j'écris pas son propre sketch, mais a donné l'exemple d'une bibliothèque d'Arduino Adafruit. Pour utiliser aussi, vous avez besoin des bibliothèques suivantes dans l'IDE Arduino, vous avez tous Sketch | Inclure Bibliothèque | Gérer les bibliothèques peuvent importer ...:

Les OLED j'ai dans le circuit par l'intermédiaire du 3,3 V (permet jusqu'à 100 mA) et est reliée à la sortie GND du Teensy 3,2. La broche SCL de l'écran nous avons connecté au port 19 du Teensy 3,2 et la broche de SDA au port 18 du Teensy 3,2.

Les fragments de code

Pour moi, je présente OLED utilise du chemin de menu Fichier | Exemples | Adafruit SSD1306 la ssd1306_128x32-i2c de croquis. Il a abordé les cartes Arduino, mais passe juste au Teensy 3.2. Le code est assez détaillé, donc je veux et tu me épargner le refrappe ennuyeux. Seuls quelques aspects intéressants dans le code sont maintenant discutés.

Au début de l'esquisse, l'importation des bibliothèques concernées sont les suivantes:

#include // I2C
#include // Bibliothèque graphique
#include // pilote pour OLED
#define OLED_RESET 4 // Régler la broche de remise à zéro
Adafruit_SSD1306 affichage (OLED_RESET); // variable d'accès pour les OLED

La boucle () - Méthode de croquis de Adafruit ne contient pas de code. Tout pièces intéressantes au lieu de la configuration de la méthode (). Dans un premier temps, le croquis que vous voyez le logo Adafruit comme un écran d'accueil. La bibliothèque a chargé cette image dans la mémoire tampon d'image, donc il semble que le premier appel à display.display ():

// ... dans la configuration ....
display.begin (SSD1306_SWITCHCAPVCC, 0x3C); // adresse I2C 0x3C
display.display (); // Affichage image tampon => Adafruit logo apparaît
display.clearDisplay (); // contenu d'affichage clair
testdrawline (); // Demo ligne
...

Procédé testdrawline () dessine des lignes:

testdrawline vide () {
// lignes du coin supérieur gauche (0,0) points
// inférieur caractéristique de bord horizontal:

pour (int16_t i = 0; i
display.drawLine (0, 0, i, display.height () - 1, WHITE);
display.display ();
retard (1);
}
...
display.clearDisplay ();
...

}

La méthode testdrawchar () sont tous les caractères ASCII avec des codes 0-167 sur l'écran:

void testdrawchar (void) {
display.setTextSize (1); // Taille du texte simple
display.setTextColor (BLANC); // la couleur réelle est différente de
display.setCursor (0,0); // curseur sur le coin supérieur gauche

pour (uint8_t i = 0; i < 168; i ++) { // codes ASCII 0 .. 167
if (i == '\ n') continuer; // passe saut de ligne
display.write (i); // envoyer caractère
if ((i > 0) && (I% 21 == 0)) // sortie par ligne 21 caractères
display.println (); puis // à la ligne suivante
}
display.display (); // Tout afficher
retard (1);
}

En combinant un puissant Teensy 3.2 panneaux avec un écran OLED toutes sortes d'applications peuvent être mises en œuvre qui nécessitent une sortie graphique, tels que les stations de surveillance ou des applications de jeux.

Étant donné que le conseil d'administration Teensy fonctionne avec des croquis Arduino, inutiles en l'absence de grands moments de bulbes sketches plus démonstratifs. Seules les broches sont sporadiques dans le changement Sketches. Par exemple, la LED est au bord de cartes Arduino à la sortie 13, lorsque Teensy 2,0 à 11, lorsque Teensy 2,0 ++ à 6, et à l'habitude dans la production de panneaux 3.x Teensy 13.

Sparkfun Adaptateur Shield

Teensy 3.2 intègre avec ses caractéristiques très bien dans l'écosystème Arduino un, en particulier en ce qui concerne la question du logiciel. Il serait souhaitable, les développeurs pourraient sur le côté matériel existant blindages Arduino utilisés pour le conseil. permet exactement Sparkfun Teensy bouclier adaptateur.

L'adaptateur Bouclier Sparkfun permet aux conseils Teensy 3.1 et 3.2 à utiliser Arduino ShieldsL'adaptateur Bouclier Sparkfun permet aux conseils Teensy 3.1 et 3.2 à utiliser Arduino Shields(Photo: sparkfun.com)

Elle apporte, entre autres, de:

Cela permet d'assurer une participation Teensy 3.2 dans l'écosystème matériel de l'Arduino.

En regardant dans la boule de cristal

Stoffregen reste comme toujours sur la route. Il est toujours à la recherche pour le prochain défi. Au moment où il est à la recherche avec succès Kickstarter pour les sponsors pour le développement des conseils Teensy 3.5 et 3.6.

pjrc.comL'avenir: Teensy 3.6(Photo: pjrc.com)

Ces deux conseils amélioreront grandement les capacités du nouveau Teensy 3.2.

Ainsi, le Teensy-3,6 bord planifié contient un 180 MHz ARM Cortex-M4 ainsi que le processeur en virgule flottante, un mégaoctet Flash, 192 Koctets de RAM et 4 Ko de mémoire EEPROM. Il y a un port USB haut débit avec un débit de 480 Mbit / s. Sont disponibles d'autres 32 canaux DMA général, les deux ports de bus CAN, 4 unités de bus I2C 3 ports SPI, entrée audio numériques et des ports de sortie, 11 ports pour capteurs tactiles 62 broches d'E / S 25 entrées analogiques , 14 minuteries de matériel, une unité cryptographique, un générateur de nombres aléatoires, un composant pour le calcul du CRC, un lecteur de carte micro SD, un port Ethernet 100 Mbit / s, et une horloge en temps réel. Le seul un résumé incomplet.

Livraison des conseils des partisans de la campagne Kickstarter est prévue pour le 2016e Octobre

De plus Stoffregen veulent aussi quelques idées à mettre en œuvre à l'avenir vers les bibliothèques comme une bibliothèque audio puissante, une API Event Processing Arduino et la visualisation de la musique via LED, pour ne citer que quelques exemples.

résumé

Qui veut mener à bien ses propres projets sans réinventer constamment la roue a besoin des bibliothèques. Sur le site PJRC énumère un grand nombre de bibliothèques qui prennent en charge les conseils Teensy. Enfin, il est aussi le but déclaré de tissu de la pluie, de manière aussi transparente que possible d'insérer la carte Teensy actuelle et future dans l'écosystème Arduino. Maker de sorte que le conseil d'administration devrait être une option intéressante dans tous les cas.

Si cet article ou Teensy a éveillé votre intérêt 3.2, vous devriez maintenant aventurer sur leurs propres expériences. Autres informations utiles telles que des conseils & Astuces, exemples de projets et d'autres détails sur les différentes cartes se trouvent à cette page.

L'histoire jusqu'à présent:

  • Le grand spectacle laser Arduino
  • Nouvelles du service de la créativité
  • contrôle à distance
  • Des illuminations et des lumières
  • Analyseur logique
  • Faites votre propre ESP8266 WiFi Shield
  • Temporisateurs, compteurs et interruptions
  • Arduino va ESP8266
  • Bright Side de Arduino
  • Genuino ou débranché Arduino
  • mettre en œuvre les bibliothèques elles-mêmes - Arduino / IdO supplémentaire
  • Plus petit, plus profond, plus court ... le développement d'une station météorologique
  • RESTful avec CoAP
  • Communication via MQTT
  • téléphone à la maison ... avec l'Arduino
  • Pas à pas
  • Applications avec servo-moteurs
  • Bonne motorisé avec des moteurs à courant continu
  • Arduino pour les chauves-souris
  • La détection de mouvement par rayonnement infrarouge
  • Connexion d'écrans LCD sur le bus IIC
  • Écoutez avec capteurs
  • JavaScript pour Arduino Que la lumière soit
  • Connexion de nombreuses LED sur quelques sorties
  • Do-it-yourself projet: iXduino - Arduino sur une planche à pain
  • cours intensif "Electronique pour les applications IdO" (Partie 3 de 3)
  • cours intensif "Electronique pour les applications IdO" (Partie 2 de 3)
  • cours intensif "Electronique pour les applications IdO" (Partie 1 de 3)

Communication via MQTT

In the last episode we have generally considered the communication of an Arduino via the Ethernet Shield, both in terms of technical details and in terms of programming. low-level communication protocols, however, are only of limited use, which is why this episode looks at the application-oriented protocol MQTT for the Internet of things.

With low-level protocols we do not get very far because there arises the majority of the programming involved in translating between system and application level. Luckily, there are numerous application-oriented alternatives. One is MQTT.

MQTT once stood for mqtt and now defines an OASIS and ISO standard (ISO / IEC PRF 20922). Behind it a lightweight publish / subscribe solution, can set up at the user Topics providing messages via the clients (in the role of a publisher) and other clients (in the role of a Subscribers) refer messages hides. A topic can be interpreted as a bulletin board with a unique inventory number, which all need to login, want to publish the information on the board, as well as those who want to read the messages.

HiveMQ.comMQTT follows the publish / subscribe pattern(Picture: HiveMQ.com)

Clients can also have both roles. To the nature and content of the messages themselves MQTT not care. That is up to the applications.

The central component of MQTT is a called MQTT broker that manages the Topics positions, including messages and controls access to the topics. For data security are there appropriate mechanisms exist. This also applies to the Quality of Service (QoS).

QoS specifies the semantics of the message transfer.

Depends on the security protocols, a MQTT broker offers different access ports. This totally unsecured access is usually done via port 1,883th

Communication via the Ethernet Shield with MQTT Interaction with the MQTT-Broker in an IBM environment bluemix

Any compound with a MQTT broker made in the context of a session. Since occur not exactly rare on the internet connection failures, MQTT broker can also save the state from clients persistent and possibly, restore as soon as clients want to continue their original session. but MQTT also allowed to start each time with a fresh session.

Clients can also specify their last will. This is a message sent by the broker to a topic when the connection with the client in question has been canceled unexpectedly.

Furthermore, there is the retained messages (stored messages). These are messages with set Retain flag. a new subscriber logs on to the topic, he receives, first, the last message that has arrived with this flag in the topic. This also applies to subscriptions with wildcards that include the topic in question.

With MQTT-SN a MQTT solution for TCP / IP-free ZigBee protocol exists. Also an implementation of MQTT about Websockels, a component of HTML5 standards, is part of the specification. This allows the use of MQTT via browser and Web server is possible.

For convenience, I use unsecured communications for the examples below. Otherwise, you would see the forest for the trees more. In practice, however, this was not a good idea.

Mosquito offers

To use MQTT, you need therefore a broker who receives messages from publishers and passes on the topic to the appropriate subscribers or subscribers. Without MQTT broker we can not even send or receive messages.

As with message forums can be set up on a MQTT broker called Topics that ultimately as queues with a unique name behave add messages about the participants or can see. Upon receipt and delivery of a message, therefore, always the desired topic must be specified. Topics can be structured hierarchically. An example:

Lieschen.Müller / Flat / living room / LEDStreifen42

It's about a LED strip at the home of Lieschen Müller.

Desired Topics subscribe to clients even with wildcards. For example, an expression such as the following:

  • Lieschen.Müller / Flat / # => all topics of IoT devices in Lieschen Müller's apartment.
  • Lieschen.Müller / Flat / + / Temperature => all topics of temperature sensors in Lieschen Müller's apartment.

Example: MQTT test broker mosquitto

The test-broker is the address: test.mosquitto.org reachable.

Ports are offered:

  • 1883 : MQTT unencrypted
  • 8883 : Encrypts MQTT,
  • 8884 : MQTT, encrypted client certificate necessary
  • 8080 : MQTT over WebSockets, unencrypted
  • 8081 : MQTT, encrypted via WebSockets

The encrypted ports support TLS v1.2, v1.1 or v1.0 with x509 certificates and require cooperation of the client. In all cases, developers should the Trust Center file mosquitto.org.crt use to verify server connections. Port 8884 obliged clients to provide a certificate to authenticate their connection.

Certificates are available on direct request from mosquitto.org.

In addition to commercial MQTT broker solutions such HiveMQ there is also a free open source solution called Mosquitto. She's powerful, slim, and free. You can, of course, alternatively one of the available continuous current test MQTT broker in Internet use (see separate text box). However, it is then possible for anyone to read along your messages.

Installation files and notes for various operating systems can be found in the download area of ​​mosquitto. Once mosquitto running on your computer, you can teach the Arduino in the next step to send messages via MQTT or receive.

Arduino client

The Arduino Uno board is now to log in to MQTT broker using the Ethernet-Shields, where news about "outTopic" ship, and news about "inTopic" receive. To even having to develop any MQTT protocol for Arduino, we use the open source solution of Nick O'Leary. This is available as PubSubClient on his website. The library plus examples can be downloaded from GitHub. And as always, that we have the library of the Arduino IDE via the menu Sketch | Include Library | Add .ZIP Library must make known.

In the following sketch I have used uninhibited to Nick O'Leary. The demonstration program is based on a static address assignment. You can also use the dynamic address assignment via DHCP from the previous sketch (the final episode) for the Arduino but.

Do not forget to open the serial monitor the Arduino IDE when you run the Sketches, and to adjust the transmission rate to 57,600. This baud rate is the Arduino program in the method setup () in front.

#include // Serial Peripheral Interface
#include // Ethernet Library
#include // MQTT Library

// Enter here the parameters for your network:mac byte [] = {0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED};
IPAddress ip (192, 168, 178, 72);
IPAddress server (192, 168, 178, 40);/ *The following method is called when a message arrives for the specified topic:* /
void callback (char * topic, byte payload *, unsigned int length) {
Serial.print ("Message arrived [");
Serial.print (topic);
Serial.print ("]: ");
for (int i = 0; i
Serial.print ((char) payload [i]);
}
Serial.println ();
}

Ethernet Client ethClient;
PubSubClient client (ethClient);

void reconnect () {
// While repeat is restored to connect
while (! client.connected ()) {
Serial.print ("Attempt MQTT connection setup ...");
// connection attempt:
client.connect if (("arduinoClient")) {
Serial.println ("Successfully connected!");
// Now the Arduino sends a message in outTopic ...
client.publish ("outTopic"."calls Arduino home");
// and registers with inTopic incoming messages to:
client.subscribe ("inTopic");
} Else {// If an error occurs => Error message, and retrying
Serial.print ("Error, rc =");
Serial.print (client.state ());
Serial.println (" Next attempt in 5 seconds");
// 5 second pause before the next attempt
delay (5000);
}
}
}

void setup ()
{
Serial.begin (57600);
// Broker accessible via ip address = server, port = 1883
client.setServer (server, 1883); // address of MQTT broker
client.setCallback (callback); // handler for incoming messages
// build Ethernet connection
Ethernet.begin (mac, ip);
// Small break
delay (1500);
}

void loop ()
{ // While trying until it works:
if (! client.connected ()) {
reconnect ();
}
client.loop ();
}

MQTT.fx

When you start the top sketch, you see ... nothing! Because we have not yet developed a communication partner no wonder. At best monologues of the Arduino could currently lead.

To test it once without a separate program, there are several MQTT test clients. I have chosen for this purpose for the client MQTT.fx. The downloads for Windows, OS X, Linux can be found on this page.

Once after installation and startup of the window MQTT.fx appears, enter the desired MQTT broker with whom you want to work in our case the local Mosquitto broker. MQTT.fx automatically offers you the option "local mosquitto" in, so you only need to click on connect.

MQTT.fx, Arduino, and Mosquitto in action MQTT.fx, Arduino, and Mosquitto in action

In the menu bar of MQTT.fx You can initially via the menu item broker status data for connecting to the MQTT broker subscribe, sign up through the menu item Subscribe for messages from certain topics, or via the menu item Publish News in Topics publish. To enter Topic name and message you use the corresponding text box of the application. So publish either inTopic to send messages to Arduino. Or sign up to receive messages about outTopic so you can send messages to the Arduino on his part.

JavaScript is calling

Our first self-written MQTT client used as a base JavaScript. A corresponding packet MQTT for Node.js already exists. As always, we first install the MQTT support over the NPM.

npm install MQTT --save

In this way we have already overcome the most difficult hurdle. Now we can begin to exchange messages with the Arduino board. A simple script shows how easy it proceeds:

var = MQTT require ( 'MQTT');
var client = mqtt.connect ( 'MQTT: // localhost: 1883');

// build connection to the broker:
client.on ( 'connect', function () { // news from outTopic Subscribe:
client.subscribe ( 'outTopic'); // messages on inTopic publish:
client.publish ( 'inTopic', 'Hello Arduino, here is JavaScript!');
});
// client.on contains an event handler for incoming messages:client.on ( 'message', function (topic, message) { // Received message read:
console.log (message.toString ());
client.end (); Hat // connection
});

How to tell the communication between JavaScript and Arduino over MQTT is not a big problem, so we can turn to the next, slightly heavier hurdle.

Java is calling

At this point I would like to illustrate a rather more complex MQTT project. The idea is quite simple: a Java program determines the number of unread messages in my inbox. This number indicates it over MQTT to the Arduino on. The run there Sketch receives the message and

All messages should it be sent over the Topic inTopic or receive them from there by the Arduino.

As MQTT broker in turn comes mosquitto used. You should use again MQTT.fx as a test platform to test your sketch or the Java program.

Arduino Sketch

The code is derived primarily from the code from which we have already used above for encoding an Arduino MQTT clients. The differences are highlighted in bold and comments.

#include
#include
#include

// We include a green LED on digital pin 6
// and a red LED on to digital pin. 7

const int greenLED = 6;
const int redLED = 7;


// Adjust the following values ​​to your own system environment:
mac byte [] = {0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED};
IPAddress ip (192, 168, 178, 72);
IPAddress server (192, 168, 178, 40);


// The following method is called,
// as soon as a message arrives for the specified Topic

void callback (char * topic, byte payload *, unsigned int length) {
Serial.print ("Message arrived [");
Serial.print (topic);
Serial.print ("]: ");
for (int i = 0; i
Serial.print ((char) payload [i]);
}
Serial.println ();

// In addition to the output via the serial monitor
// we convert the message into a string
// and then to an integer:

char * buffer = (char *) malloc (length);
strcpy (buffer, (char *) payload);
int blinks = String (buffer) .toInt ();



// Kam than 0, there are no unread messages
// => We leave the green LED lights for 3 seconds:
if (blinks == 0) {
digital write (redLED, LOW);
digital write (greenLED, HIGH);
delay (3000);
digital write (greenLED, LOW);
}
// Kam as a value > 0, the red LED will blink as often
// as there are unread messages:
else {
digital write (greenLED, LOW);
for (int i = 0; i < blinks; i ++) {
digital write (redLED, HIGH);
delay (1000);
digital write (redLED, LOW);
delay (1000);
}
}

}

Ethernet Client ethClient;
PubSubClient client (ethClient);

void reconnect () {
// While repeat is restored to connect
while (! client.connected ()) {
Serial.print ("Attempt MQTT connection setup ...");
establish contact // attempt
client.connect if (("arduinoClient")) {
Serial.println ("Successfully connected!");
// Now the Arduino sends a message in outTopic ...
client.publish ("outTopic"."calls Arduino to hoe");
// and logs on for at inTopic for incoming messages
client.subscribe ("inTopic");
} Else {
Serial.print ("Error, rc =");
Serial.print (client.state ());
Serial.println (" Next attempt in 5 seconds");
// 5 second pause before the next attempt
delay (5000);
}
}
}

void setup ()
{
pinMode (redLED, OUTPUT); // red LED
pinMode (greenLED, OUTPUT); // green LED

Serial.begin (57600);
// broker = ip-address = ip and port = 1883
client.setServer (server, 1883);
client.setCallback (callback);

Ethernet.begin (mac, ip);
// Small break
delay (1500);
}

void loop ()
{
if (! client.connected ()) {
reconnect ();
}
client.loop ();
}

Download this sketch to the Arduino. You can MQTT.fx "fictitious" Messages to the Arduino. Do not forget: The Sketch expect an integer >= 0th

Java as a client MQTT

To create a MQTT-enabled Java client, we need an appropriate library. The best known solution is called Paho, is an Eclipse Incubator project and represents clients on all possible platforms and programming languages. The already introduced JavaScript extension for Node.js comes from this source.

To use Paho for Java, you need the JAR library

org.eclipse.paho.client.mqtt - .. jar

Tie a library as an external JAR in your Java Build Path. You are welcome to generate the code using Maven. Is more convenient to download the binaries from the release repository.

The client connects to the MQTT broker that tcp at the address: // localhost: 1883 ready for connection requests. We give the client arduinoSample the name. The variable persistence can temporarily store information in order to be able to continue on an old state with disconnections. However, the configuration option connOpts.setCleanSession (true) causes we work on every start with a fresh session.

(In the call UnreadMessages.getNoOfUnreadMessages"Inbox") We access the mailbox class and obtain the number of unread messages back. More on that later.

Since we as a quality-of-service parameters in message.setQos (qos) will use the qos = 2, we want to make sure that the message arrives exactly once in that topic.

We open then the connection and put our message together. Subsequently, the program sends the message (sampleClient.publish (topic, message)) and severs the connection to the broker (sampleClient.disconnect ()).

Everything worked, the message should now be taken off the Arduino in reception.

de.stal.mqttdemo package;

import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;

public class MqttPublishSample {

public static void main (String [] args) {

String topic = "inTopic";
int qos = 2;
String broker = "tcp: // localhost: 1883";
String clientId = "arduinoSample";
String msg = "";
MemoryPersistence persistence MemoryPersistence = new ();

try { // specify data of the compound: MqttClient javaclient = new MqttClient (broker, clientId, persistence); make // Setup:
MqttConnectOptions connOpts MqttConnectOptions = new ();
connOpts.setCleanSession (true);
System.out.println ("Connecting to MQTT broker: " + Broker); // Connect:
javaClient.connect (connOpts);
System.out.println ("Connected successfully!"); // Here, access to the inbox:
msg + = UnreadMessages.getNoOfUnreadMessages ("Inbox");
System.out.println ("Post a new message in topic: "+ Msg); // and here the message is composed:
MqttMessage = new message MqttMessage (msg.getBytes ());
message.setQos (QoS); // Publish the message:
javaClient.publish (topic, message);
System.out.println ("Message published"); // and connection Hat:
javaClient.disconnect ();
System.out.println ("Connection closed!");
System.exit (0); // success !! } catch (MqttException me) {
System.out.println ("reason "+ Me.getReasonCode ());
System.out.println ("msg "+ Me.getMessage ());
System.out.println ("loc "+ Me.getLocalizedMessage ());
System.out.println ("cause "+ Me.getCause ());
System.out.println ("excep "+ Me);
me.printStackTrace ();
}
}
}

Mail access in Java

For space reasons, I can not address all the details, how about Java is accessed your own mailbox. I have extracted from its own application the following code. To compile it, you need the external Java Mail library, which you can download from this page. These JAR library belongs to the Java Build Path.

de.stal.mqttdemo package;

import java.util.Properties;
import javax.mail.Folder;
import javax.mail.MessagingException;
import javax.mail.NoSuchProviderException;
import javax.mail.Session;
import javax.mail.Store;

public class Unreadmessages {

public static int getNoOfUnreadMessages (String folder name) {
// Insert here the data of your provider:
String host = "imap.gmail.com"; // At this point, you need your username (usually // with the e-mail address identical:
String username = "[email protected]"; // and here you enter your password:
String password = "password";
Folder folder = null;
Store store = null;

int count = 0; // message counter

// I use IMAP to access
Properties props = System.getProperties ();
props.setProperty ("mail.store.protocol". "imaps");
try {
Session session = Session.getDefaultInstance (props, null); // session and mailbox access create:
store session.getStore = ("imaps");
store.connect (host, user name, password); // Accessing the folder folder name:
folder = (Folder) store.getFolder (folder name);
if (! folder.isOpen ())
folder.open (Folder.READ_WRITE);
// Determine the number of unread messages:
count = folder.getUnreadMessageCount ();

} Catch (NoSuchProviderException exc) {
exc.printStackTrace ();
System.exit (1);
} Catch (Exception Messaging exc) {
exc.printStackTrace ();
System.exit (2);
} Catch (Exception exc) {
exc.printStackTrace ();
System.exit (2);
} Finally {
try {
folder if (! = null && folder.isOpen ()) {folder.Close (true); }
if (store = null) {store.close (); }
}
catch (Exception Messaging exc) {
exc.printStackTrace ();
System.exit (2); // Error message
}
} // Determined number of unread messages back:
return count;
}
}

The sample code terminates after one pass. You can also change the code so that the program every n seconds retrieves the mailbox and forwards the information about MQTT to the Arduino sketch.

The program is the way a good psychological help to determine how the input of mails to constant interruptions of your workflow may result.

MQTT Alternatives

of course, is not only MQTT to choose from for IoT developers. In addition, some other alternatives exist:

Conclusion

We met in this and the last episode a whole lot about Internet communication with IoT devices. The possibilities are numerous and range from operating a mini web server on the microcontroller to lightweight publish / subscribe communication with MQTT. What technology you use in practice depends entirely on your own needs and preferences.

Standards such MQTT are, however, a clear advantage as they offer a large amount of available implementations generally, and particularly also support named SETHR heterogeneous landscapes.

What happened until now:

  • Communication via MQTT
  • phone home ... with the Arduino
  • Step by step
  • Applications with servo motors
  • Good motorized with DC motors
  • Arduino for bats
  • Motion detection by infrared radiation
  • Connection of LCD displays on the IIC bus
  • Listen with sensors
  • JavaScript to Arduino Let there be light
  • Connecting many LEDs on a few outputs
  • Do-it-yourself project: iXduino - Arduino on a breadboard
  • crash course "Electronics for IoT applications" (Part 3 of 3)
  • crash course "Electronics for IoT applications" (Part 2 of 3)
  • crash course "Electronics for IoT applications" (Part 1 of 3)

Temporisateurs, compteurs et interruptions

Dans cette édition spéciale de la minuterie de sujet est abordé. Cela implique plus que la simple appel du retard () - fonction.

Le retard de la fonction () a été jusqu'ici notre compagnon fidèle et constant dans Chronométrage. Il est par défaut dans la bibliothèque Arduino disponible et permet une latence de milliseconde précise. Donc ce que vous voulez plus? Dans le développement des systèmes embarqués - et non seulement dans des positions d'interrogation en temps réel - joue un rôle central Chronométrage. Cependant, le retard () est un moyen pour le sale boulot, pas pour des applications sophistiquées.

Ce qui dérange concrètement aux fonctions simples à la temporisation () ou Millis ()?

Minuterie sur la puce

un processeur AVR avec ce genre de mesure du temps brut serait satisfait, nous devrions prendre plusieurs achats compromettante fonctionnelle cartes Arduino. Ainsi, la modulation de largeur d'impulsions exige une haute résolution de l'horloge de ports numériques pour être en mesure de régler les cycles d'activité précis (cycle de service). Exemple: vous avez besoin d'une tension de sortie moyenne de 2,765643 V à une sortie numérique, cela se fait que par exactitudes au-delà des moyens de retard () ou Millis ().

Dans les systèmes tels que I2C ou SPI sont des processus dans l'ordre de la microseconde typique et nécessaire. Est-ce un programme pour conduire les composants connectés via ces systèmes de bus, une résolution de millisecondes grossières serait un show-bouchon. Pas moins des conditions temporelles nécessaires qui seraient tout simplement pas mis en œuvre par la minuterie milliseconde déclenché pour activer le contrôle des servo-moteurs ou pour la génération de tonalité.

Comme nous le savons par expérience que les cartes Arduino font un très bon support pour PWM, systèmes de bus, d'asservissement et le ton, deux questions se posent:

  1. Comment un processeur AVR en interne pour mettre en œuvre les résolutions temporelles nécessaires pour cela?
  2. Peut-on se faire en est propriétaire en tant que développeurs de ces fonctions?

donner le ton

Pour les objets ci-dessus, le microcontrôleur AVR d'intégrer divers minuterie associée à des registres de comptage de 8 ou 16 bits de large. Ces registres commencent par une valeur initiale de 0. Votre incrémentées, donc le comptage réel, est automatique et périodique. Exécutez les registres respectifs via une interruption de dépassement de la minuterie est déclenchée.

Une idée fausse est la façon dont la CPU de l'Arduino entraîne la minuterie. La minuterie-Arduino ou un microcontrôleur AVR d'Atmel sont indépendants de la CPU ou MCU. Ce fait doit être conservé dans les discussions qui ont suivi à l'esprit.

Afin d'obtenir la résolution la plus élevée possible, la première approche pourrait résider dans le fait que les mises à jour du compteur (à savoir, l'incrémentation) pour mener à bien synchrone avec l'horloge du processeur. Cependant, cela a un défaut majeur. Avec une fréquence d'horloge de 16 MHz pris le trop-plein un temporisateur 8 bits serait atteint après 16 microsecondes, un registre de 16 bits d'environ 4,1 millisecondes.

Ceci est bien sûr avantageux pour des intervalles de temps courts. Mais si nous voulons couvrir de plus longues périodes de temps? Pour que cela soit possible, les micro-contrôleurs offrent ce qu'on appelle prédiviseur. Ces configurer après combien de cycles d'horloge du système un registre de comptage pour incrémenter. Les valeurs possibles sont 8, 64, 256 ou 1024. Un paramètre Prescale 1024 par exemple, conduit à une incrémentation du compteur après toutes les 64 microsecondes et 1024 cycles d'horloge à la fréquence d'horloge de 16 MHz, de telle sorte qu'un compteur 16 bits seulement après 4,2 secondes trop-pleins.

Pour programmer des intervalles précis peuvent être registre compte de la minuterie preassign au lieu de les laisser commence à 0. Une fois là-bas, nous aimerions éteindre et toutes les 0,5 secondes, une LED. La fréquence désirée de la minuterie 2 Hz serait ainsi. Une horloge consiste à déclencher un débordement de la minuterie. Comment exactement cela peut être réalisé?

Nous traitons avec les paramètres suivants:

Il est prescale / cpufreq * count = delta T

=> count = delta T * cpufreq / prescale

=> maxcount - nombre init = delta T * cpufreq / prescale

=> compter init = maxcount - delta T * cpufreq / prescale

Exemple de calcul: toutes les 0,5 secondes, le système a tenu une interruption de débordement de la minuterie.

La minuterie démarre au lieu de 0 avec le nombre de comptage initial d'initialisation suivante = 65.536 à 8.000.000 / 256 = 34286

Le registre de la minuterie doit d'abord commencer par 34286 pour dépassement de la minuterie - en cas de dépassement 65636 - va exactement un demi-seconde. Dans chaque itération de la routine de service interrrupt, le compteur est toujours à nouveau avec initialize 34286.

pourrait être aussi un croquis similaire suit. Le registre visé à y nous venons de parler plus tard.

#define ledPin 13

vide installation()
{
pinMode (ledPin, OUTPUT); // Régler la sortie LED

// minuterie 1
noInterrupts (); Désactiver // Toutes les interruptions temporairement
TCCR1A = 0;
TCCR1B = 0;

TCNT1 = 34286; preassign // minuterie après le calcul ci-dessus
TCCR1B | = (1 << CS12); // spécifier 256 en tant que valeur Prescale
TIMSK1 | = (1 << TOIE1); // activer la minuterie d'interruption de débordement
(interruptions); // tourner toutes les interruptions fortement
}
// Voici le gestionnaire d'interruption auto-défini
// pour le dépassement de la minuterie

ISR (TIMER1_OVF_vect)
{
TCNT1 = 34286; preassign // compteur à nouveau
écriture numérique (ledPin, lecture numérique (ledPin) ^ 1); // LED et hors
}

vide boucle()
{
// on peut incorporer un code supplémentaire ici
}

Monde de la minuterie

Un Arduino a non seulement une seule minuterie mais plusieurs minuteries. Pas étonnant que les minuteries sont néanmoins éléments de base essentiels pour différentes tâches d'un microcontrôleur.

trouver la minuterie a appelé à la mise en œuvre de "Pulse Width Modulation" Utilisez, les règles d'attribution suivantes.

Lorsque Arduino:

Lorsque Arduino Mega:

Il y a aussi plusieurs limites à prendre en compte:

Inscription minuterie

Comme dans le schéma ci-dessus contrôle apparent de la fonctionnalité de la minuterie par l'intermédiaire de différents registres se produit. Le symbole μ représente le nombre de la minuterie, ou 0, 1, 2, ...,. , TCNTμ est donc le registre de comptage de la minuterie μ. Le registre de comptage de la minuterie 1 est donc TCNT1, la minuterie 0 TCNT0.

Pour simplifier, la discussion qui suit, ainsi que les deux échantillons Sketches se réfèrent à la minuterie 1. En outre, je vous épargnerai une énumération de tous les détails mais en se concentrant avant les propriétés pertinentes.

TCCR1A (Registre Compteurs timers / contrôle), les drapeaux PWM10 et PWM11 permettent une détermination de la résolution dans le cas où la minuterie 1 est utilisé pour le contrôle PWM. Le point de départ est la TCCR1A = 0 accord;:

TCCR1B (Registre Compteurs timers / Contrôle): Configuration du prédiviseur.

D'autres combinaisons permettent un contrôle externe sur la broche T1.

TCNT1 (registre de minuterie / compteur): qui est, le compteur réel.

OCR1 (sortie registre de comparaison): Lorsque le compteur à TCNT1 égal au contenu du OCR1, puis une minuterie comparer interruption.

ICR1 (Input Capture d'enregistrer, seul registre de 16 bits): mesure de la durée entre deux fronts successifs des broches de capture d'entrée, qui viennent à l'être par un circuit externe. Peut aussi mesurer le nombre de tours d'un moteur en marche. Comportera également des paramètres TCCR1A avec touchés.

TIMSK1 (Masque de temporisation / compteur registre d'interruption): Ici, les interruptions de minuterie peuvent interdire ou autoriser.

TIFR1 (Timer / Compteur Interrompre Flag Register): Ici on observe encore des interruptions non traitées. Les bits correspondent à celles de TIMSK1.

Autre méthode CTC

déclencher au lieu d'une interruption en cas de débordement de la minuterie registre comme dans le croquis supérieur, il y a l'option alternative appelée CTC (Effacer l'horloge sur le match Compare). En cela, le microcontrôleur compare si le contenu du compteur registre identique au contenu de la minuterie associée à l'OCR (sortie registre de comparaison) est. Si oui, est déclenché une minuterie d'interruption et comparer le registre est remis à 0. Encore une fois, aura lieu une interruption toutes les demi-secondes.

Dans un pré-échelonnage de 256 et une fréquence d'horloge de 16 MHz, on peut appliquer la formule ci-dessus pour compter: count = delta T * cpufreq / prescale = 0,5 * 16000000/256 = 31.256.

Croquis ci-dessus serait donc dans ce cas:

#define ledPin 13

vide installation()
{
pinMode (ledPin, OUTPUT); // Régler la sortie LED

// minuterie 1
noInterrupts (); Désactiver // Toutes les interruptions temporairement
TCCR1A = 0;
TCCR1B = 0;
TCNT1 = 0; // Initialisation du registre 0
OCR1A = 31250 ;; // sortie registre de comparaison preassign
TCCR1B | = (1 << CS12); // spécifier 256 en tant que valeur Prescale
TIMSK1 | = (1 << OCIE1A); // Activer la minuterie d'interruption Comparer
(interruptions); // tourner toutes les interruptions fortement
}
// Voici le gestionnaire d'interruption auto-défini
// pour la minuterie d'interruption Comparer

ISR (TIMER1_COMPA_vect)
{
écriture numérique (ledPin, lecture numérique (ledPin) ^ 1); // LED et hors
}

vide boucle()
{
// on peut incorporer un code supplémentaire ici
}

résumé

Ce supplément, il est venu à traiter avec des fonctions de minuterie sophistiquées pour les processeurs Atmel famille (ATMega, ATtiny). Donc, vous devriez maintenant avoir une meilleure compréhension des questions. Vous voulez en savoir plus de détails, je vous renvoie aux documents du fabricant Atmel comme ici par exemple.

En savoir plus sur l'application pratique de cette fonctionnalité dans des applications avancées telles que la synthèse sonore, moteurs PWM ou servo. Une autre lecture utile cet article de Adafruit.

mais il est aussi une bonne idée d'approfondir ce qu'ils ont appris par leurs propres expériences.

L'histoire jusqu'à présent:

  • Arduino va ESP8266
  • Bright Side de Arduino
  • Genuino ou débranché Arduino
  • mettre en œuvre les bibliothèques elles-mêmes - Arduino / IdO supplémentaire
  • Plus petit, plus profond, plus court ... le développement d'une station météorologique
  • RESTful avec CoAP
  • Communication via MQTT
  • Pas à pas
  • Applications avec servo-moteurs
  • Bonne motorisé avec des moteurs à courant continu
  • Arduino pour les chauves-souris
  • La détection de mouvement par rayonnement infrarouge
  • Connexion d'écrans LCD sur le bus IIC
  • Écoutez avec capteurs
  • JavaScript pour Arduino Que la lumière soit
  • Connexion de nombreuses LED sur quelques sorties
  • Do-it-yourself projet: iXduino - Arduino sur une planche à pain
  • cours intensif "Electronique pour les applications IdO" (Partie 3 de 3)
  • cours intensif "Electronique pour les applications IdO" (Partie 2 de 3)
  • cours intensif "Electronique pour les applications IdO" (Partie 1 de 3)

C # ou Visual Basic? Le langage de programmation droit pour les développeurs .NET

contenu
  1. C # ou Visual Basic? Le langage de programmation droit pour les développeurs .NET
  2. différences
  3. principales différences
  4. lire sur un côté

Comme le titre de l'article exprime est presque une guerre religieuse dans la communauté des développeurs .NET pour choisir le "droit" Langage de programmation. C # ou Visual Basic est la question qui a déjà déplacé de nombreuses équipes de projet. De plus en plus souvent C # semble gagner, tandis que Visual Basic est pas moins puissant, mais seulement chargé de la mauvaise réputation du passé.

10 questions importantes à .NET

Dans cet expert .NET série en dix parties Holger Schwichtenberg apporte des réponses aux questions les plus fréquemment posées qui traitent avec les développeurs .NET.

  1. Assez .NET 2.0, ou vous devez utiliser .NET 3.5?
  2. C # ou Visual Basic? Le langage de programmation droit pour les développeurs .NET

Alors que le langage de programmation Java dans les années 1990 avec le principe directeur "Une langue pour toutes les plates-formes" a indiqué Microsoft visait initialement à plus "Une plate-forme pour toutes les langues" à partir. Dès le début de l'intégration des langages de programmation dans la mise au point .NET était. Pendant ce temps, les positions opposées de Java et .NET ramollir: Il environnements d'exécution .NET pour d'autres plates-formes, et il existe des compilateurs pour d'autres programmes qui peuvent également générer du code Java d'octets.

Dans l'ensemble, il y a maintenant plus de 50 langages de programmation pour .NET. Parmi eux sont non seulement langages orientés objet tels que C #, Java, C ++, Visual Basic (VB) et Delphi, mais aussi fonctionnelle et SML (Standard ML), Caml et Haskell et "vieilles tantes" représentée comme Fortran et COBOL. Il existe deux implémentations commerciales et libres. Une liste continuellement mise à jour des langages de programmation .NET se trouve à dotnetframework.de.

Vraiment important ne sont que C # et Visual Basic (.NET). De loin C ++ / CLI, le C ++ suit - variante pour .NET en particulier pour la migration C ++ - le code est important dans les projets .NET - code existant à l'intégration .NET et C ++. F #, nouveau langage multi-paradigme de Microsoft qui se démarque surtout par des constructions fonctionnelles de C # pourrait devenir plus important parce que Microsoft délivre à partir de Visual Studio 2010 avec l'environnement de développement.

Visual Basic .NET avec et sans

Visual Basic a une longue tradition dans le monde Windows Developer. La langue dans les versions 1.0 à 6.0 en tant que simple et très productive, mais a été mal vus en même temps que désordre et non structurées (en particulier pour les développeurs qui ont travaillé avec C ++, Delphi ou Java). Visual Basic 6.0 était au mieux un langage orienté objet. Il manquait des constructions particulières pour l'héritage de mise en œuvre.

Avec le changement de Visual Basic 6.0 vers la version 7.0, Microsoft a cependant subi un changement radical. La nouvelle version est un véritable langage orienté objet avec l'héritage, presque aussi puissant que le même nouvellement développé en C #. Pour la version actuelle 9.0, il y avait d'autres ajustements, tels que la surcharge des opérateurs. Une déclaration de COM et .NET gourou Don Box via VB 7.0, qui date de 2001 a été cité à ce stade: "Visual Basic .NET signifie que vous n'avez pas plus honte d'être les développeurs VB!" Microsoft a délibérément refrains avec une compatibilité avec la VB.NET VB 6.0 version précédente et a pris deux raisons d'incompatibilité sur:

  1. Vous avez réglé toutes les fonctions de VB 6.0 grande confusion a fait don aux développeurs.
  2. A été modifié ou supprimé toutes les fonctionnalités de Visual Basic 6.0 qui ne sont pas compatibles avec le .NET Framework.

Un peu confus est la dénomination. À partir de Visual Basic 6.0 Visual Basic .NET 7.0 a été. Cependant, Microsoft a renoncé depuis la version 8.0 dans .NET 2.0 Retour sur le .NET supplémentaire, de sorte que les versions depuis Visual Basic 8.0 (aka Visual Basic 2005) et Visual Basic 9.0 (aka Visual Basic 2008) chaud. était le motif officiel qu'il était bien connu que les nouvelles versions sont basées sur .NET. Pour suggérer, cependant, que cela est plus arrive à briser la résistance de certains développeurs qui ne voulaient pas mettre à niveau à partir de Visual Basic 6.0 à .NET. La peur peut être juste que - après Microsoft pendant un certain temps les lettres .NET collés sur tout, que .NET était ou non - que le gouvernail se tourne vers l'autre extrême déraisonnable.

Depuis l'élimination de la ".NET" au nom, il est pas facile, dans la langue écrite entre le "vieux" (1,0 à 6,0) versions pour distinguer Visual Basic et les nouvelles (versions 7.0). Il est logique de "classique Visual Basic" ou "COM basée sur Visual Basic" contrairement à la ".NET basée sur Visual Basic" de parler. Comme alternative, serait "Visual Basic (.NET)",

C # et C ++++

C # est un langage de programmation que Microsoft a développé à nouveau pour le .NET Framework. la "#" pourrait être divisé en un quadruple signe plus (par exemple C ++++). Par-dessus tout, C ++ et Java ont influencé le plan conceptuel C #; mais il peut aussi avec des parallèles Visual Basic et Delphi peut trouver.

C # est le résultat d'un projet qui a démarré Microsoft après Sun, Microsoft a la fin des années 1990, le développement de J ++, une adaptation propre de Microsoft de Java développée par Sun interdite. "père" C # est Anders Hejlsberg, qui a déjà développeur de Turbo Pascal et Delphi de Borland. Pendant ce temps, C # (TC39 / TG2 ECMA standard 334, Groupe de travail) et ISO (ISO / IEC 23270) et normalisées ECMA.

En ce qui concerne les numéros de version de C # il y a une certaine confusion. Il y a d'une part un comptage officiel avec le numéro de version (parallèle au .NET Framework), d'un autre côté avec des dates (parallèle à Visual Studio). En interne, les développeurs utilisent un troisième chef d'accusation pour le compilateur. La première version de C # dans le .NET Framework 1.0 en interne effectué le 7.0. .NET 1.1 il y avait C # 7.1, le .NET Framework 2.0 et 3.0, les rapports du compilateur C # avec la version 8.0. Le .NET Framework 3.5 inclut le compilateur dans la version 9.0. Officiellement, Microsoft est toujours l'un des numéros de version de C # semblables à ceux du cadre - sauf dans le .NET Framework 3.5. En C # 3.0 est inclus (également connu sous le nom C # 2008).

bild1.jpg Tableau 1: C # a trois numéros de version différentes

C ++: Le framework Qt a 20 ans

20 ans Qt

Qui utilise C ++ pour le développement multi-plateforme, rencontre généralement tôt ou tard sur Qt. Le C ++ - bibliothèque de classes fête son vingtième anniversaire cette semaine et malgré une histoire mouvementée comme un partenaire fiable.

Le développement de Qt a commencé en 1992, mais le 20 mai 1995 Lars Wirzenius a envoyé un e-mail avec le sujet "Beta de la bibliothèque de motifs ressemblant à C disponible" la liste de diffusion de comp.os.linux.announce. Dans ce document l'extrait de code suivant, qui devrait être familier même vingt ans après la première livraison de nombreux développeurs Qt trouvé:

#include
#include

int main (int argc, char ** argv)
{
QApplication un (argc, argv);
retour QMessageBox :: message ( "attention". "Bonjour, monde!" );
}

Cette annonce de Qt 0,90 est considéré comme la naissance du C ++ encore populaire - bibliothèque de classes.

Version back-et-vient jusqu'à aujourd'hui

Dans un premier temps, les développeurs se sont limités aux programmeurs pour éviter la manipulation fastidieuse du serveur X. Comme Trolltech, l'ancienne société était derrière Qt, est basé, le développeur d'une politique de licence relativement restrictive dans laquelle la société en effet présenté la bibliothèque développeurs open-source sont disponibles gratuitement prescrits, mais a exigé de l'argent dans un environnement commercial et les utilisateurs de Windows. Lorsqu'elles sont disponibles à partir de 2001 porté sur Mac OS X, l'ancienne société mis derrière Qt, Trolltech, une approche similaire: une variante open source suivie avant 2003.

Le système de bureau KDE généralisé, fondé en 1996, il fut bientôt comme une application de référence pour Qt. La disponibilité d'une variante open source inquiète les développeurs Qt Free Foundation, qui voulait assurer l'éternel fournissant une version open source du produit à base. Le contrat entre les développeurs de KDE et Trolltech ancien légitime pour délivrer une variante de BSD de Qt, Trolltech si nobles plus de douze mois aucune mise à jour de la version open source.

Avec la version 2.0, Trolltech a également ajouté sa propre open source Q Public License (QPL), mais classé la Free Software Foundation comme incompatible avec la GPL. Cela a conduit finalement au fait que Trolltech 2000 à poursuivre avec l'inclusion de la politique de double licence GPL. Ce contingent que des développeurs open source optent pour l'une des deux licences et devait la suivre. Le prochain développement de la GNU General Public License (2005: GPLv2) est allé avec les développeurs Qt.

Suite à l'acquisition de Trolltech par Nokia en 2008 le nouveau propriétaire, le logiciel a alors décidé sous la GPLv3 ou les LGPLv2.1 fournissent en open source. Le nouveau propriétaire a vu dans Qt un moyen d'unifier le système d'exploitation Chaos: Offrant trois plates-formes différentes, au moment où le non-problème si les développeurs utilisent tous les systèmes d'exploitation avec une base de code. Après réception du partenariat avec Microsoft, les actifs ont été Qt - vendus à la firme d'experts-conseils Digia - avec des pertes énormes. Étant donné que la présente Qt 5.4 actuelle, vous pouvez la façon dont le LGPLv3 utiliser comme une alternative à LGPLv2.1 et publié avec Qt Enterprise licence commerciale. La GPL est omis.

Même JavaScript ligne

iPhone d'Apple a fait en sorte que les utilisateurs attachent de l'importance d'élaborer des animations. Le module QtGui avait développé cette nouvelle situation plutôt mauvaise - comme une solution donnée avis à un système basé sur le framework GUI JavaScript.

La facilitation des ports est un autre objectif de conception: l'introduit avec Qt 4.7 QML (Qt langage de balisage) est limitée à fournir des primitives graphiques. Les contrôles RÉALISÉ causés par des composants tiers. Merci à l'excellente intégration dans le C ++ - QML de base pourrait surmonter les réserves initiales JavaScript rapidement. Qui programmé Qt, devrait donc traiter avec le cadre, d'autant plus que Qt malgré tout se tourmente de licence comme un partenaire fiable: Il n'y a pratiquement aucun système d'exploitation, qui ne peut pas répondre ainsi.

Voir Heise Développeur:

(Tam Hanna) /(ANE)

ATtiny: midgets très grand

les cartes Arduino sont disponibles dans différents facteurs de forme et des classes de performance. Pour les circuits plus compacts sont parfois les plus petites cartes Arduino "mini". "micro" ou "nano" à lourd. Qui il s'agit de petites dimensions et un bon rapport qualité-prix, devrait jeter un oeil à la famille ATtiny.

les cartes Arduino Arduino Uno, Mega, Mini, Nano ou Micro avec les puces puissantes ATmega conviennent à diverses applications. à côté de la MCU intégrer un certain nombre d'autres composants tels qu'un cristal, la logique de puissance, les LED, le bouton RESET et bien plus encore. Cependant, ils ont donc aussi une taille à laquelle ils ne peuvent pas facilement être utilisés pour les circuits compacts. Heureusement, il existe une alternative appelée ATtiny.

Près de 40 processeurs ont une famille ATtiny 8 bits. Votre mémoire flash se déplace dans une plage de 512 Ko à 16 Ko. Leur nombre de broches allant de 6 à 32. Les autres caractéristiques de performance varie d'une puce à puce. Par conséquent, les développeurs devraient être en mesure de trouver un représentant ATtiny facilement appropriés en fonction de l'application, et non seulement dans le cas où la compacité est l'une des exigences.

Le ATtiny85 est relativement souvent utilisé par les fabricants ArduinoLe ATtiny85 est relativement souvent utilisé par les fabricants Arduino(Photo: sparkfun.com)

Le processeur de ATtiny minuscule apporte à pas plus que sur des dimensions de 1,4 mm x 1,5 mm et sont à une tension de 0,7 V satisfaite, de sorte que l'alimentation est suffisante, une batterie de piles ou un bouton. Les broches individuelles d'un ATtiny se révéler très souple car les repères individuels Maker peut être utilisé pour l'entrée / sortie, la conversion analogique / numérique ou modulation d'impulsions en largeur en option. Même la broche RESET peut être reconfiguré (voir ci-dessous) pour I / O. Pour la fréquence d'horloge de l'oscillateur interne de la puce fournit. Pour le lecteur intéressé reconnaît haut à droite de l'image architecturale du imagée ATtiny25 / 45/85:

Architecture d'un ATtiny 25/45/85-chipArchitecture d'un ATtiny 25/45/85-chip(Photo: ATMEL)

ATtiny25, ATtiny45 & ATtiny85

pour discuter de toutes les puces ATtiny en détail, est compliqué et ennuyeux. Par conséquent, le présent article se concentre un exemple aux représentants fréquemment utilisés. Parmi les jetons ATtiny bénéficient des représentants ATtiny25, ATtiny45 et ATtiny85 particulièrement attrayante, car ils combinent compacité avec des performances élevées. En particulier, ce dernier ATtiny85 est particulièrement abondant dans la nature. Avec 8K Flash, 512 octets de EEPROM et 512 octets de SRAM car ils ont le potentiel pour les petits projets. Contrairement à son petit facteur de forme, il a mentionné les représentants ATtiny aussi en termes de puissance de calcul en elle-même. Ils sont basés sur une architecture RISC avec 120 commandes qui nécessitent presque toujours un seul cycle d'horloge. Comme pour les processeurs RISC est typiquement un grand ensemble de 32 registres généraux (8 bits).

Le fonctionnement de la puce peut être fait avec différentes fréquences et tensions:

ATtiny25V / 45V / 85V: 0 - 4 MHz @ 1,8 - 5,5 V, 0 - 10 MHz @ 2.7 - 5.5V
ATtiny25 / 45/85: 0 - 10 MHz @ 2,7 - 5,5 V, 0 - 20 MHz @ 4.5 - 5.5V

En mode actif, basse fréquence, basse tension (1 MHz, 1,8 V), la consommation d'énergie à 300 uA assez modeste.

Le ATtiny85 et ATtiny25 ou ATtiny45 ses frères ont 8 sorties. La photo montre l'option package DIP-8. Bien sûr, aussi les versions SMT sont disponibles.

Les 8 broches du ATtiny85 Les 8 broches du ATtiny85(Photo: sparkfun.com)

Pinbelcontours:

Dans l'ensemble, les broches des ATtiny85 sont donc utiles à bien des égards, ainsi que la figure suivante illustre:

Lorsque ATtiny85 toutes les broches peut fournir de multiples fonctions et rôles Lorsque ATtiny85 toutes les broches peut fournir de multiples fonctions et rôles

La communication avec le monde extérieur

Question de prix: Si un ATtiny un I2C ou SPI? La réponse est complexe, en fonction de votre point de vue, que ce soit "ni l'un ni l'autre" ou "à la fois ...", Le support de bus à thème est via un composant universel. Le ATtiny85, grâce à un module USI (Interface série universel) à la fois I2C (TWI) - ainsi que le support du protocole SPI. Ceux-ci se trouvent dans tous les ATtiny85 une normale et une minuterie supplémentaire à haute résolution pour fournir le moment précis requis

Le ATtiny25 / 45/85 par la voie ne pas de bus série, ce qui explique pourquoi la communication avec le moniteur de série sur l'Arduino IDE par défaut impossible. Comment la technologie logicielle de rencontre, décrit le site "La communication avec Tiny",

clignotant

Comme le firmware ou bootloader vient en fait à un ATtiny? représentants ATtiny sont programmables avec ISCP ou ISP (programmation série en circuit). PIDDC comprend ainsi six ports MOSI, MISO, SCK, RESET, VCC et GND. Soit dit en passant, les six pôles, port ISCP rectangulaire se trouve au pied des puces ATmega sur un Arduino.

Pour la programmation d'un ATtiny85 il existe de nombreux programmeur, à propos USBtiny ou USBasp. solutions correspondant est d'acheter le fabricant sur eBay pour une poignée d'euros.

Dans le menu Outils Arduino | Programmer trouvé un support pour plusieurs programmeur prédéfini. L'Arduino en option FAI est là sur l'offre. Dis: Une Uno Arduino ou d'une autre carte Arduino peuvent être utilisés en tant que programmeur. C'est la plus simple et la moins coûteuse solution, à part le câblage nécessaire. Les amateurs qui veulent programmer souvent un ATtiny, bien sûr, peuvent construire une solution simple mais durable basée sur une carte Arduino Uno.

Le circuit nécessaire est illustré dans le tableau Fritzing suivant:

Programmer un ATtiny85 avec l'Arduino Uno en tant que matériel de programmation Programmer un ATtiny85 avec l'Arduino Uno en tant que matériel de programmation

Le câblage des broches des deux composants est la suivante:

ATtiny85 Arduino
Pin 1 .................... broche 10 (reset)
Broche 2 .................... n / a
Broche 3 .................... n / a
Broche 4 GND ....................
Pin 5 Pin .................... 11
Broche 6 .................... 12 Pin
Broche 7 .................... 13 Pin
Pin 8 .................... 5V

Recommandé en outre à la solution d'auto-mesure décrit est un condensateur électrolytique vous à l'entrée RESET de la carte Arduino Uno (plus) et une sortie GND (moins) collé.

Ainsi, l'Arduino IDE prend également en charge ATtiny circuits intégrés, il a besoin d'un gestionnaire de conseil correspondant. Tapez Préférences (Arduino | Préférences) l'URL du Gestionnaire de conseil supplémentaires suivantes:

https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager
/package_damellis_attiny_index.json

Pour programmer la ATtiny85 Uno en utilisant l'IDE Arduino, vous devez maintenant encore dans les conseils Manager (Outils | Gestionnaire de cartes) à la recherche de ATtiny. Vous devriez trouver les conseils de bibliothèques suivantes et installer:

Installation ATtiny Soutenir Tung dans l'Arduino IDE Installation ATtiny Soutenir Tung dans l'Arduino IDE

Maintenant, sélectionnez le menu (Outils | Conseils) l'entry correspondante: ATtiny25 / 45 / 85e

Télécharger un croquis de l'échantillon dans lequel vous remplacez la DEL du 13 à 0 comme l'exemple clignotant obligatoire. Les clients doivent certainement être connectés à la sortie numérique 0 du ATtiny85 aussi une LED réelle.

En tant que programmeur vous donnez dans Outils | Programmeur un Arduino comme fournisseur d'accès Internet. Si une autre utilisation de matériel de programmation (voir ci-dessus), vous spécifiez les applications que vous programmeur à la place.

Maintenant, enfin, le fabricant peut charger le croquis sur le ATtiny85. Le flux contient de la puce sur l'ONU Arduino ou son programmateur ICSP / fournisseur de services Internet associé. Bien sûr, les ATtiny85 peuvent alors à partir Arduino ou séparé du programmateur et autrement fournir de l'énergie, ainsi, par exemple, une carte de batterie ou FTDI.

La broche RESET peut être, comme mentionné plus haut dans cet article, sur les attitudes de la soi-disant "fusibles" reconfigurer le ATtiny à une entrée normale. Cela se fait avec un programmeur ISP ordinaire. Cependant, cela signifie que l'utilisateur ne peut pas programmer avec le programmateur ISP, le MCU (Micro Controller), mais nécessite un programmeur avec une tension plus élevée.

Pour la configuration modifiée inversée, est également un "Programmer haute tension" nécessaire. Ce qui est disponible à l'achat ou peut au contraire créer un self-made, tel que décrit sur le site Web stocké. illustre un autre site comment les développeurs utilisent la broche RESET sans interventions supplémentaires en sortie.

Des options plus confortables

L'option la plus pratique et plus facile à utiliser un ATtiny sans trop d'effort, sont finis des mini-cartes comme le OLIMEXINO-85, qui peuvent être achetés soit prémontées pour quelques euros en kit de bricolage ou.

OLIMEXINO-85 comprend un ATtiny85 ainsi que tous les autres composants nécessairesOLIMEXINO-85 comprend un ATtiny85 ainsi que tous les autres composants nécessaires(Photo: olimex.com)

Le kit intègre une carte FTDI à la puissance, une ATtiny85 connectable, un bouton de réinitialisation et les voyants et des composants passifs. Le panneau fini est compatible carte de test et effectue toutes les sorties des ATtiny85 vers l'extérieur. Des démonstrations, des bibliothèques et firmware, le fabricant Olimex sur cette page GitHub disponibles.

Nous arrivons au sujet bootloader. Pour les processeurs ATtiny la communauté open source a créé son propre projet appelé micronoyau dans la vie. Son objectif principal de conception est compact. Le Conseil OLIMEXINO-85 comprend, par exemple, par défaut, le bootloader du micronoyau.

Pour utiliser la carte OLIMEXINO-85 sous l'IDE Arduino, les développeurs doivent ajouter le gestionnaire du conseil de l'IDE dans les préférences suivantes URL: http://digistump.com/package_digistump_index.json.

Entrée de l'URL dans les paramètres du Conseil de Gérance Arduino IDE Entrée de l'URL dans les paramètres du Conseil de Gérance Arduino IDE

Après cela, le menu Outils | Conseil | directeur des conseils ATtiny les conseils offerts pour l'installation:

Installation de panneaux ATtiny (Digistump) le Conseil directeur de l'Arduino IDE Installation de panneaux ATtiny (Digistump) le Conseil directeur de l'Arduino IDE

Il suffit de chercher les conseils Digistump AVR.

Sélectionnez le OLIMEXINO-85 la carte Digispark (par défaut - 16,5 mhz).

Une fois que vous voulez jouer un sketch sur la carte, retirez la carte du port USB de l'ordinateur hôte. Après avoir appuyé sur le bouton de téléchargement invite l'IDE pour connecter la carte via USB, puis micronoyau charge automatiquement le croquis sur le ATtiny.

Adafruit babiole & co

En plus Olimex aussi Adafruit a un conseil d'basé sur la ATtiny85 pour quelques euros. Le Conseil Trinket comprenait également l'utilisation en tout lieu et de micronoyau OLIMEXINO-85. Adafruit le conseil d'administration fournit dans un 3-V ou la version 5-V.

Adafruit Bijou bord avec Micro USB Adafruit Bijou bord avec Micro USB(Photo: adafruit.com)

Pour plus d'informations sur ses caractéristiques, l'utilisation et l'installation se trouvent sur le site Web de babiole.

Un autre conseil comparable est le Digistump:

digistumpUne autre carte ATtiny85 vient de Digistump(Photo: digistump)

Mais cela est loin d'être suffisant. Le Wattuino nanites 85 sont disponibles pour six euros à Watterott. Ce conseil fait suite à la conception nanites. En outre Watterott propose également un conseil basé sur la ATtiny841 qui a un paquet DIP-14 et donc plus de connexions:

Watterott nanites 86Watterott nanites 86(Photo: watterott.com)

Et il peut certainement retrouver quelques conseils plus abordables qui ont des fonctionnalités similaires sur Internet. Beaucoup trop de possibilités de différenciation n'existe pas de toute façon.

Par exemple le contrôle des feux de circulation

Pour illustrer le travail avec les processeurs ATtiny suit maintenant une simple esquisse d'exemple qui réalise une simple lumière de la circulation. Pour ce faire, nous devons d'abord comprendre comment fait un travail feu de circulation. Au total, il y a quatre phases de feux de circulation connue (voir figure):

Il y a quatre feux de circulation Il y a quatre feux de circulation(Photo: http://bascom-forum.de/mediawiki/index.php/Datei:Ampelphasen.png)

Bien sûr, peut faire les différentes phases de différentes longueurs aux feux de circulation. Le tout peut aussi compliquer arbitraire. Certains feux de signalisation sont éteints complètement dans le trafic lumineux ou un signal jaune clignotant. Dans le monde réel aussi la connexion simultanée et coordonnée de plusieurs feux de circulation a lieu aux intersections.

Cependant, un contrôle des feux de circulation trivial comme décrit ci-dessous un mini-projet ne nécessite que des efforts limités.

Un schéma Fritzing destiné à illustrer le circuit à base de carte de test trivial avec trois DEL (rouge, vert, jaune), trois résistances 220 ohms, et un fil de décalage de bit:

circuit de feux de circulation simple ayant OLIMEXINO-85 (Conseil représenté schématiquement) circuit de feux de circulation simple ayant OLIMEXINO-85 (Conseil représenté schématiquement)

Le code du contrôle des feux de circulation

Le code pour le contrôleur de feux de signalisation met en oeuvre les phases de ces quatre dans la forme d'une simple machine d'état (modèle d'état), dans lequel les méthodes les différents états (phaseOne, PhaseTwo, la troisième phase, phaseFour) représenter. Un changement d'état se produit selon la méthode simple appel, tel que l'appel PhaseTwo () dans le corps de boucle (). La liste est explicite.

////////////////////////////////////////////////// ///////////
//
// Esquisse pour ATtiny85 Simpler
// contrôle de la circulation de la lumière
//
////////////////////////////////////////////////// ///////////


const int RED = 4; // LED rouge
const int YEL = 2; // LED jaune
const int GRN = 0; // LED verte



// Déclarations auxiliaires:

// LED rouge on / off:

#define Redon () digitalWrite (ROUGE, HIGH)
#define RedOff () digitalWrite (ROUGE, LOW)
// LED jaune on / off:
#define YellowOn () d'écriture numérique (YEL, HIGH)
#define YellowOff () d'écriture numérique (YEL, LOW)
// LED verte on / off:
#define Greenon () écriture numérique (GRN, HIGH)
#define Greenoff () d'écriture numérique (GRN, LOW)
// minuterie phase rouge:
#define DelayOne () retard (5000)
// rouge de transition minuterie au vert:
délai #define DelayTwo () (2000)
// minuterie phase verte:
Délai #define délai de trois () (5000)
// vert transition minuterie rouge:
Délai #define délai de quatre () (2000)

void setup () {
// LED comme sorties:
pinMode (RED, OUTPUT);
pinMode (YEL, OUTPUT);
pinMode (GRN, OUTPUT);
// Une fois que tous les voyants sont éteints:
initialiser ();
}

// Tous les voyants sont éteints:
initialize void () {
RedOff ();
YellowOff ();
Greenoff ();
}

// phase rouge:
phaseOne vide () {
Redon ();
YellowOff ();
Greenoff ();
DelayOne ();
}

// RotNachGrünPhase:
PhaseTwo vide () {
Redon ();
YellowOn ();
Greenoff ();
DelayTwo ();
}

// phase verte:
phase de vide à trois () {
RedOff ();
YellowOff ();
Greenon ();
Trois Delay ();
}

// GrünNachRotPhase:
phaseFour vide () {
RedOff ();
YellowOn ();
Greenoff ();
Quatre Delay ();
}

// default => clignotement du signal jaune:
urgence void () {
RedOff ();
Greenoff ();
YellowOn ();
retard (500);
YellowOff ();
retard (500);
}

void loop () // Commencer par la phase verte:
trois phases ();
phaseFour ();
phaseOne ();
PhaseTwo (); }
}

amener à afficher

Certes, ce fut une application triviale. Un autre exemple est d'illustrer une application plus complexe. Dans cet exemple plus complexe, un 0.96 vient" OLED 128 x 64 pixels est utilisée (le type des OLEDs est SSD1306). Étant donné que cet affichage nécessite un port I2C, le croquis montre aussi un exemple de l'utilisation I2C sur le ATtiny85.

Le port 0 (PB0) des actes ATtiny85 (SDA) en tant que connexion de données, tandis que le port 2 (PB2) sert de ligne de SCL, le temps.

(Note: Port 0 ou PB0 est sur la broche 5, Port 2 et PB2 à la broche 7 de puces de ATtiny85).

Pour mettre l'écran OLED via I2C en marche ATtiny85, une bibliothèque spéciale est nécessaire, car la bibliothèque standard I2C représente fil pour ATtiny85 morsure trop luxuriante. Heureusement, il existe des remèdes:

Le circuit est le suivant:

Fil bleu: ATtiny85 GND GND avec SSD1306
Fil rouge: ATtiny85 3,3 V ou 5 V avec SSD1306 Vcc
Fil vert: ATtiny85 Port 0 (= Pin 5) avec SSD1306 SDA
Fil jaune: ATtiny85 Port 2 (= Pin 7) avec SCL SSD1306

qui montre aussi dans le Fritzing-diagramme suivant:

SSD1306 écran OLED à Adafruit Trinket 5VSSD1306 écran OLED à Adafruit Trinket 5V

Bien qu'un Conseil Adafruit-Trinket peut être vu sur le diagramme, mais ils peuvent le remplacer par ATtiny85 tout moment par OLIMEXINO-85, un Wattuino nanites 85 ou tout autre conseil d'évasion.

Tout ce que vous avez besoin est un code

L'utilisateur AndyB2 a mis sur instructables.com un très bon guide et le code source pour la connexion à un écran OLED aux ATtiny85 sont disponibles pour que vous référer deux exemples plus que matériel d'illustration et de l'utilisation. Trouvez fabricant les instructions à ce point. Je me suis orienté dans mon propre exemple AndyB2.

En raison de la mémoire de données limitée du ATtiny85 le schéma suivant les rejets de l'information ne change pas comme la configuration binaire des logos de thermomètre utilisés dans la mémoire du programme. Cela est évident à partir du PROGMEM d'attribut dans le code du programme.

Le scénario du programme de démonstration est rapidement dit.

#include "SSD1306_minimal.h" // pilote OLED

// stocker des données dans la mémoire de programme:
#include

#define ° "\ xa7" "C"

SSD1306_Mini oled; // un écran 128x64 OLED 0,97"

// image d'un petit thermomètre:
const unsigned char ThermometerIcon [] PROGMEM = {
0x00, 0xfe, 0x03, 0xfe, 0x50,
0x00, 0xff, 0x00, 0xff, 0x55,
0x60, 0x9f, 0x80, 0x9f, 0x65,
};


////////////////////////////////////////////////// /
//
// show écran de démarrage ()
// renvoie les informations initiales sur l'affichage
//
////////////////////////////////////////////////// /


show start void () {

oled.startScreen (); Commutateur // affichage
oled.clear (); // affichage clair

oled.cursorTo (0,7); // position du curseur
oled.printString ( "et fonctionnalités");

retard (3000);

oled.clear ();
oled.cursorTo (15.1);// position du curseur
oled.printString ( "ATtiny85 démo");
}

////////////////////////////////////////////////// /
//
// montrer la puissance indicateur ()
// Infos sorties d'exploitation
// logo (thermomètre)
// et une valeur de température
//
////////////////////////////////////////////////// /


vide montrent l'affichage de fonctionnement () {

oled.clear (); // affichage clair
oled.startScreen (); Commutateur // affichage


oled.cursorTo (0,0);
oled.printString ( "OLED de connexion");
oled.cursorTo (10.2);
oled.printString ( "température");
// affichage et même graphique:
oled.drawImage (ThermometerIcon, 20,4, 5, 3);
}



////////////////////////////////////////////////// /
//
mesure de la température //
// simule un thermomètre
//
////////////////////////////////////////////////// /
température de mesure char () {
retour 20 + aléatoire (-5,5);
}


////////////////////////////////////////////////// /
//
// configuration
// Initialiser OLED
Afficher // Écran de démarrage
Afficher // Indicateur d'alimentation
//
////////////////////////////////////////////////// /


void setup () {
pinMode (3, INPUT);

oled.init (0x3c); // OLED dépend de 0x3c IIC-Id
oled.clear (); // affichage clair

retard (1000);
voir start (); // écran de démarrage initial
retard (2000);
VITRINE d'exploitation (); // Indicateur d'alimentation
}



////////////////////////////////////////////////// /
//
// boucle
// la boucle de mesure réelle
// mesurer en continu et à l'affichage de fonctionnement
// sortie
//
////////////////////////////////////////////////// /


void loop () {

carbonisation buf [10];

// Déterminer la température:
température de carbonisation = mesure de température ();

// Création d'informations formatées:
sprintf (buf, "% + 0.2hd" DEG, température);

// position du curseur:
oled.cursorTo (30, 5);

// sortie de la valeur de la température:
oled.printString (BUF);
retard (500); // rupture entre les mesures
}

Comme toujours, l'exemple de la forme imprimée peut encore beaucoup à désirer. Si vous sentez que vous pouvez utiliser, par exemple, au lieu de la température simulée d'un mètre capteur réel et étendre le circuit en conformité avec un autre capteur ou bien sûr de votre choix. Bien sûr, un système mis à jour en conséquence ATtiny doit être transféré dans un ensemble de données de position par radio (RF). Libérez votre imagination tranquille gratuit.

résumé

Le voyage aux représentants de la famille ATtiny montre que nous ne devons pas nécessairement accès à une carte Arduino comme une panacée pour les projets. Qui aime compact, abordable et d'économie d'énergie, peut mettre en place avec l'aide d'un circuit de ATtiny. Ensuite, peut également atteint une batterie plus petite ou une opération de cellules solaires.

Cependant, cette approche a aussi des contraintes physiques en ce qui concerne l'épaisseur des mécanismes de communication disponibles, la taille de la mémoire ou le nombre d'entrées et de sorties. De plus, les bibliothèques ne fonctionnent que partiellement Arduino et souvent qu'après des changements majeurs aux systèmes ATtiny ensemble.

Une fois que les inconvénients ne sont pas importants et les avantages l'emportent, est l'utilisation de la famille ATtiny certainement rien de la manière.

la force Windows Update 10 anniversaire

L'utilisation d'un petit outil de Microsoft peut provoquer la mise à jour immédiate de Windows 10, même si aucune mise à jour est affichée dans les paramètres.

Même plus d'un mois après la publication de "mise à jour anniversaire" pour Windows 10 ne fonctionne toujours pas me offrir deux ordinateurs de la mise à jour complète via la fonction de mise à jour dans les paramètres Windows ("réglages") Sur. Ce ne jure que même après avoir cliqué répété "Check for Updates"Il n'y avait actuellement aucune mise à jour pour moi.

Windows 10 dit qu'il n'y a aucune mise à jour

La solution est de télécharger un petit programme d'installation de Microsoft que le téléchargement des principales forces de mises à jour (voir les captures d'écran).

L'outil de mise à jour reconnaîtra que j'ai besoin des mises à jourtest a réussiProgrès Télécharger

Dix langages de programmation que les développeurs doivent apprendre en 2017

Dix langages de programmation que les développeurs doivent apprendre en 2017contenu
  1. Dix langages de programmation que les développeurs doivent apprendre en 2017
  2. langages de programmation
  3. conclusion
  4. lire sur un côté

Chad Fowler a même conseillé d'apprendre un nouveau langage de programmation chaque année. surtout là où il existe une variété de nouveaux et anciens programmation avec le potentiel -. Seule la décision sur la langue que vous devriez apprendre à côté, certainement pas facile Cet article vous aidera à prendre des décisions.

La sélection des dix langues est subjective cours; aussi il est sur le point de faire une des priorités parmi ces langues. La lecture est de donner aux développeurs basés sur les tendances une idée sur la façon dont peuvent sécuriser leur emploi en tant que programmeur. Surtout pour les débutants, les indications d'intérêt peuvent être. Les langues répertoriées peuvent aider lors du démarrage d'une nouvelle carrière ou dans la nouvelle orientation.

Certes, les développeurs apporteront leurs priorités différentes dans leur propre évaluation. Mais quand il vient d'être sur l'apprentissage, il est important que le but est d'abord pour lui-même "fiables dessins" filtrer. Ne peut alors l'expertise voulue avec un maximum d'efficacité peut être atteint, et seulement un équilibre judicieux permet d'atteindre les objectifs. Que ce soit le motif de l'acquisition ou l'amélioration de la connaissance d'un langage de programmation est plus dans le domaine de la croissance personnelle ou si les développeurs veulent améliorer les chances de succès d'une application spécifique, ils doivent toujours choisir la langue, ce qui a évidemment une valeur future pour eux.

Apprendre une langue que personne ne mais "précieux" réputée ne convient pas d'être un bon choix pour le développement personnel ou professionnel, voire en améliorant les perspectives sur le marché du travail. Pour déterminer la valeur, les développeurs doivent d'abord reconnaître la valeur et les avantages du langage, de reconnaître l'importance de leur propre réussite et la motivation à apprendre, de sorte que la question de la "critères de sélection" répondre clairement dans le choix d'une langue.

L'argent ne doit pas toujours être le principal critère de sélection d'un langage de programmation. Le plus souvent, il est plus facile d'apprendre une langue lorsque les développeurs utilisent souvent, ont besoin ou s'y intéressent. Cela pourrait bien être un motif fiable pour la sélection.

L'apprentissage de la programmation de ce guide fournit non seulement une meilleure chance de réussir sur le marché du travail. Il permet également de se développer personnellement et d'en tirer satisfaction. Services personnels, le développement professionnel et les perspectives d'emploi sont des besoins différents, mais qui se concentre sur les langues que vous souhaitez utiliser ou si vous voulez utiliser avant de peser les avantages monétaires, est sur la bonne voie pour la sélection d'un langage de programmation.

Non seulement après l'indice TIOBE il y a beaucoup accessibles à tous les langages de programmation, d'autres sources telles que GitHut donnent un bon aperçu des tendances. Sur LiveEdu.tv, une plate-forme d'apprentissage pour les personnes qui veulent améliorer leurs compétences professionnelles dans les domaines de la programmation, le développement de jeux, la science des données, la conception, la réalité augmentée, réalité virtuelle et l'intelligence artificielle, cette observation est plus ou moins confirmée.

Cependant, peut aussi confondre tant de sources. Dans l'orientation de la liste suivante de dix langues de programmation pour aider. Les données sur le salaire moyen proviennent des services de recherche d'emploi et PayScale En effet, le revenu réel peut varier tout à fait de celui-ci.

.NET Framework 4.7.1 apporte de nombreuses nouvelles fonctionnalités

.NET Framework 4.7.1 apporte de nombreuses nouvelles fonctionnalités

Le .NET Framework 4.7.1 est non seulement une partie de la "mise à jour des cas créateurs" Windows 10, mais peut également être installé comme une installation séparée sur les anciennes versions. Malgré la petite étape de version, il contient des mises à jour intéressantes.

La nouvelle publication "mise à jour des cas créateurs" Windows 10 inclut une version mise à jour du .NET Framework classique avec de nombreuses petites innovations. La nouvelle version peut être installée 2008 R2 comme une installation séparée sur les versions plus anciennes de Windows à partir de Windows 7 et Server. qui que "mise à jour des cas créateurs" 10 ne veulent pas installer Windows, vous pouvez installer cette configuration .NET Framework 4.7.1 séparé, à condition qu'au moins la "mise à jour anniversaire" ou "mise à jour des créateurs" est disponible.

L'installation de 67 Mo du .NET Framework 4.7.1 est que son prédécesseur "En place mise à jour", Il a remplacé les installations existantes système de .NET Framework 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2 et 4.7. Pour l'utiliser, les développeurs Visual Studio 2017 nécessitent la version 5.15, qui depuis 10/11. état de prévisualisation est.

Prise en charge directe pour le Standard .NET 2.0

Le .NET Framework est compatible avec la version publiée le 10 Août standard depuis la version 2.0 .NET 4.6.1. Cependant, jusqu'à présent une référence d'un projet .NET Framework sur l'une des bibliothèques qui y conduira à de nombreux fichiers supplémentaires dans le répertoire / bin, les développeurs doivent fournir avec leur logiciel. Les fichiers contiennent de la norme Attaquants type depuis .NET 2.0 définit un ensemble différent de classes dans les assemblées (DLLs) lorsqu'il est présent dans l'ancien .NET Framework. Le nouveau 4.7.1 .NET Framework connaît la nouvelle compilation et contient en interne les attaquants de type, de sorte que les nombreux fichiers supplémentaires ne sont plus nécessaires.

L'amélioration de l'environnement d'exécution et le compilateur

La System.ValueTuple de classe, ce qui est la base pour les produits importés en C # 7.0 et Visual Basic 15 types de tuple est maintenant sérialisable, ce qui facilite le passage de l'ancienne classe System.Tuple. .NET Framework 4.7.1 prend déjà en charge les ReadOnly Références, qui veut introduire Microsoft C # Version 7.2 (public non avenue Method1 (ref int param1 en lecture seule) {...}). En plus du .NET Framework format Windows PDB 4.7.1 prend désormais en charge les PDB portables qui viennent avec la génération de code dynamique dans les scripts C # utilisé. (En appelant RuntimeFeature.IsSupported"featurename") Les développeurs peuvent maintenant déterminer si l'exécution prend en charge une fonction particulière.

En outre, l'exécution du .NET Framework contient 4.7.1 optimisations pour la gestion de la mémoire par le garbage collector. mais les améliorations Microsoft a récemment annoncé au compilateur juste à temps ne figurent pas.

Accessibilité dans WPF et Windows Forms

Microsoft a fait don également ses cadres de l'interface graphique de bureau Windows Presentation Foundation (WPF) et Windows Forms améliorations mineures âgées pour les personnes handicapées. Avec un contraste élevé activé dans le système d'exploitation des contrôles dans WPF et Windows Forms offrent maintenant une meilleure représentation. Les lecteurs d'écran peuvent lire maintenant mieux certains contrôles comme MonthCalendar, CheckedListBox, DataGridViewCell et ToolStripMenuItem dans Windows Forms ou extension DataGridCell, ComboBox et Mot de passe dans WPF. Une application WPF peut maintenant en apprendre davantage sur une zone en direct que l'on appelle un lecteur d'écran s'il y a eu des changements dans une zone d'écran qui ne dispose pas de la mise au point et est donc souvent ignorée par les lecteurs d'écran.

Hachant avec SHA-2

Microsoft prend en charge le .NET Framework 4.7.1 maintenant variantes SHA-2 à SHA256, SHA384 et SHA512 aussi bien pour vos mots de passe dans la configuration ASP.NET fichiers et messages dans Microsoft hachant Message Queuing (MSMQ), par exemple dans le message. HashAlgorithm = HashAlgorithm.Sha256.

Les développeurs ASP.NET obtiennent maintenant une chance d'attraper les 23 étapes de traitement de cadres Web par le biais d'un événement central et donc chaque code avant ou après l'événement. De plus, les développeurs peuvent désormais créer des objets cookie à partir de chaînes:

HttpCookie mon biscuit;
var lsValid = HttpCookie.TryParse ("Nom du cookie: Mon Cookie; path = /", Mon biscuit);

D'autres améliorations dans les fichiers de configuration, WPF Modèles de données et WPF fonctions de diagnostic répertorie une entrée de blog (Holger Schwichtenberg) /(RME)

Progressive Web Apps, Partie 1: Le web est en mode natif (s)

Progressive Web Apps (PWA) est le modèle d'application du futur. Faisant au moins Google et mis en place une base technologique que les magasins d'applications plus pourraient disparaître tôt ou tard.

L'idée: Apps ne viennent plus à l'avenir du magasin une plateforme à l'appareil, mais via le navigateur Web, qui est déjà installé sur un appareil mobile. Et parce que le web moderne est devenu si puissant, il a besoin aussi pas application native plus: le site multi-plateforme est de devenir un puits application multi-plateforme.

Ajouter des sites à l'écran d'accueil Ajouter des sites à l'écran d'accueil

Un regard rétrospectif sur l'histoire des applications mobiles: Il est possible que l'un ou l'autre des lecteurs rappelle encore Windows Mobile. Là-bas, il était commun des fichiers exécutables (EXE) ou des packages d'installation (CAB) de l'Internet pour télécharger et transférer sur votre appareil: Tout comme il est sur les ordinateurs de bureau (Windows 10 S exception possible) est commun aujourd'hui encore. En 2007, l'iPhone, ce qui est très différent apparu. Il a été présenté comme un mélange d'un iPod, un téléphone et un "dispositif Internet", Autochtones applications tierces ne sont pas fournis dans la première version de l'iPhone OS, ils devraient plutôt être gérées comme des applications Web dans Safari puissant mobile. Même dans les versions actuelles d'iOS vers des sites laisser de la méthode "Ajouter à l'écran d'accueil" adhérer à ces et éventuellement commencer sans la fenêtre du pansement du navigateur.

Quelques mois après la sortie d'Apple a changé d'avis, et natif des applications tierces se sont réunis avec le SDK et Store sur iOS. L'idée est que chaque application doit être signé, afin qu'ils puissent être affectés clairement à un développeur, Apple a repris à ce moment-là par la voie de Nokia. A partir de ce jour-là sur les magasins ont été mis sur les plates-formes mobiles comme canaux de distribution central (et parfois exclusifs): Google a ensuite déménagé à l'Android Market, Microsoft pour le Windows Store.

Les applications basées sur les technologies web modernes HTML5 et JavaScript sont en face de leurs homologues autochtones dans de nombreux aspects maintenant au niveau des yeux. Idée vient de Google, les applications Web qui fonctionneront dans le navigateur, facile à "App App" de faire sur l'appareil. Y compris les fonctions qui sont normalement des applications natives refusée que: y compris l'installation, la capacité hors-ligne ou les notifications push même lorsque l'application est fermée.

Apps qui ont ces propriétés et d'autres (par exemple, la livraison via HTTPS ou pour adapter aux dimensions de l'écran disponibles) sont appelés Progressive Web Apps. Quel cadre d'application plus native tels que Cordova ou électronique étaient nécessaires auparavant, il y a maintenant des interfaces Web natives:. Moyens techniques centraux pour mettre en œuvre la capacité hors ligne et les notifications push est le cours des travailleurs de service, l'icône sur l'écran d'accueil ne peut manquer ce utilise le manifeste Web App spécifié.

Auriez-vous cru? Cochez cette case HTML5 et JavaScript. Auriez-vous cru? Cochez cette case HTML5 et JavaScript.

Apple manque

Web Apps progressives sont alimentés par Google. Par conséquent, il est peu surprenant qu'ils peuvent être utilisés sur Android aujourd'hui. Mozilla et Microsoft sont l'une des parties - support dans Microsoft Edge peut être attendue dans les prochains mois. Un fournisseur de plate-forme, mais vous manquez plus: De tous l'ancien chef d'Apple, les signaux en faveur de Progressive Web Apps sont plutôt restreint. Et cela est compréhensible: Apple est probablement la plate-forme de distribution centrale et exclusive - dans l'Apple App avec chaque vente et mitverdient achat in-app - beaucoup trop lucratif pour les abandonner.

mais ce n'est pas nécessairement mauvais: Pour le progressiste PWA est la propriété de l'amélioration progressive, de sorte que l'augmentation progressive du soutien. Sur les plates-formes qui ne prennent pas en charge certaines fonctionnalités PWA, l'application à exécuter ainsi que encore possible. PWA sont donc rétrocompatible et de répondre à des plates-formes plus puissantes fonctionnalités plus de.

Un bon exemple d'une application Web progressive est offert sous https://mobile.twitter.com le client mobile Twitter: Une fois installé sur l'appareil, il est en cours d'exécution sans fenêtre du pansement du navigateur. Ses ressources stocke le client dans le cache du travailleur de service, de sorte que le cadre de l'application (App-shell) peut être chargé, même sans connexion Internet. Seulement pour l'envoi ou obtenir tweets une connexion Internet active est nécessaire.

Ce billet de blog est le début d'un petit nombre autour des Web Apps progressives. Dans la prochaine partie de la semaine à venir, nous traitons avec le travailleur de service mentionné ci-dessus qui est responsable de la capacité hors ligne et de recevoir les notifications push.

Arduino va ESP8266

WiFi Shields per Arduino erano fino a non molto tempo fa, solo uno, vale a dire costoso. Poi il chip Wi-Fi è venuto in agosto 2014 ESP8266 cinese produttore OEM expressif insieme a un completo stack TCP / IP sul mercato. L'integrazione del Arduino alla rete WLAN con l'ESP8266 è, il presente e il prossimo episodio.

L'ESP8266 la società con sede a Shanghai espressif implementa lo standard WiFi IEEE 802.11 b / g / n. AI Pensatore, un'altra azienda che ha avuto inizio alla fine del 2014, al fine di utilizzare il chip come base per le schede come l'ESP-01, che possono essere acquistati per pochi soldi. Dal momento che è possibile una scheda Arduino per un pugno di dollari (da 2 a 3 € / US $) dotati di connessione Wi-Fi. Cosa c'è dietro il blocco a basso costo?

Una scheda ESP-01 con a bordo esp8266 Una scheda ESP-01 con a bordo esp8266

Il chip ESP8266 contiene un 32-bit CPU Tensilica Xtensa LX106 80 MHz, 64 Kbyte memoria programmi e 96 kbyte di memoria di dati e una memoria flash di 512 Kbyte a 4 MByte. Gli altri dati di prestazione fanno un'impressione molto percorribile:

Questa performance eccellere in alcuni aspetti, un Arduino Uno o Mega. Pertanto, gli sviluppatori hanno integrato il supporto per la scheda nel Arduino IDE. Un ESP8266 di bordo può essere usato come una scheda di sviluppo autonomo per il fatto che ho ancora discuteremo più avanti. Questo è non da ultimo a causa della Espressif SDK per esp8266. In effetti, c'è l'SDK in due versioni, una per il traffico in tempo reale e un altro per la programmazione reattiva. A questo proposito la vista del lato sviluppatore di espressif vale la pena. Inoltre, esistono SDK alternativi come esp-open-sdk.

La scheda ESP-01 a prezzi accessibili da allora ha ricevuto grande apprezzamento. Le schede sono ormai contati ESP-01 a ESP-14 Inoltre, molti produttori offrono le proprie tavole, circa SparkFun, Adafruit, Olimex o Wemos.

La grande famiglia di schede ESP8266La grande famiglia di schede ESP8266(Immagine: esp8266.com)

Conosciuto come piattaforma open source IoT è il NodeMCU Consiglio che supporta il linguaggio scritto Lua tramite firmware seduti sul ESP8266 SDK. L'hardware è il modo in cui una base di bordo ESP-12 (ESP 12E o poi ESP 12F).

Sfida a livello logico

La simbiosi tra schede Arduino ed ESP promette un sistema degli oggetti ideali e soprattutto poco costoso. E 'comune il matrimonio finanziariamente nulla nel modo. Tuttavia, v'è un ostacolo tecnico. Come sappiamo, molte schede Arduino lavorano con logica 5-V. Tuttavia, l'ESP8266 e sulla base di queste schede operano a 3,3 V. E adesso?

Internet è i suggerimenti più avventurosi su come gli utenti dovrebbero gestirlo, per es.:

Rimanere tre varianti. Per si può costruire un divisore di tensione comprendente i resistori: Ciò che è importante è che si associano con il suo senza uscita a 5 V del Arduino con un ingresso da 3,3 V di esp8266 e quindi il bordo ESP inevitabilmente "frittura",

5 V segnali del Arduino (per esempio, Tx) è suddivisa dividendo la tensione in due componenti a 1,7 V e 3,3 V (vedi figura) e fornisce il 3.3V all'ingresso di esp8266 (ad esempio Rx).

Soluzione tramite partitore di tensione con 5V in ingresso ed uscita 3.3V Soluzione tramite partitore di tensione con 5V in ingresso ed uscita 3.3V

Per quanto riguarda la tolleranza di segnali, Arduino è relativamente di buon carattere. Tutto è superiore a 3 V, conta come HIGH (1), e tutto ciò che è sotto 1,5 V, come LOW (0). Specifica uno di un segnale ALTO ESP8266, cioè 3,3 V, ad un ingresso 5 V del Arduino, che non è un problema, almeno in teoria. Ampio margine tra 3,3 V e 3 V non è quindi disponibile in pratica. Anche i problemi minori potrebbero portare a fastidi. Sebbene questa variante protegge da danni collaterali, ma può portare ad errori di trasmissione frequenti. Un altro svantaggio di un partitore di tensione è il consumo di energia superiore rispetto al seguente opzione.

Per essere sul sicuro, riguardano un convertitore di livello logico o Logic Level Shifter con 5 V e 3,3 V, da un sull'altro lato. In modo che entrambe le direzioni di lavoro di conversione del segnale. La maggior parte dei prodotti forniscono più canali. Qui siete a tutti gli effetti sul sicuro.

Logic Level Shifter tra 3.3V e 5V logicaLogic Level Shifter tra 3.3V e 5V logica(Immagine: sparkfun.com)

Collegato al lato 5V del livello logico shifter 5 V e GND della Arduino Uno / Mega creare. Le porte RX e TX (Serial1 la serie Mega o software a Uno) va ad altri due canali del convertitore di livello logico. 3.3 V e GND sono quelli corrispondenti al esp8266 ei connettori RX / TX sui 3.3-V-porti del convertitore di livello logico. Si prega di notare che l'ingresso RX del Arduino deve essere collegato al convertitore di livello logico all'uscita del TX ESP8266 e l'uscita del TX Arduino tramite convertitore di livello logico all'ingresso RX di ESP8266. Essa sostiene quindi a livello logico Shifter con quattro canali.

L'opzione 3, tuttavia, facile da usare una scheda Arduino con 3.3V. Questi includono il Genuino / Arduino 101 e la Genuino / Arduino Due. Tuttavia, alcune librerie Arduino a causa dei suoi specificità hardware non eseguiti sul Due, in modo che il divertimento non si ferma lì entro limiti ristretti.

Mega Arduino o Arduino

Non è una cattiva notizia. Non tutti a bordo ESP-01 si armonizza bene con l'Uno. L'Arduino come minimalista professionista ha solo un canale di comunicazione seriale con RX (ricezione) e TX (Transmit). ma due canali seriali sono necessari per la cooperazione con l'ESP-01. Uno per il lavoro con il monitor di serie, un altro per la comunicazione tra Arduino e ESP bordo. C'è una via d'uscita di una porta del software di serie.

#include // porta seriale simulato
#define ESP_RX 2
#define ESP_TX 3
Software Serial1 seriale (ESP_RX, ESP_TX);

ma non sempre funziona. Alla velocità di trasmissione più elevate è il "virtuale" porta seriale semplicemente non avere più. Fortunatamente certo il problema si verifica in più recenti ESP-01 schede, che sono impostati fin dall'inizio a 9600. Almeno ho avuto in precedenza problemi.

Arduino Mega 2560, il socievole sotto Arduino Arduino Mega 2560, il socievole sotto Arduino(Immagine: arduino.cc)

è consigliato a questo punto del Arduino Mega 2560, che non solo è molto meglio attrezzata quando si tratta di modo seriale, ma generalmente più pin ha. Inoltre adattarsi quasi tutte le Shields compatibile delle Nazioni Unite sui Mega. Per acquisire è il consiglio per nove euro provenienti dalla Cina e da circa 12 euro da concessionari tedeschi. Esso comprende quattro porte seriali, che dovrebbe essere sufficiente per la maggior parte delle applicazioni.

Le connessioni di Arduino sul livello logico Converter Arduino Mega sono i seguenti:

ESP-01 Logic Level Shifter Arduino Mega
---------------------
Vcc (3.3V) ---- | Vcc (3.3V) Vcc (5V) | ---- Vcc (5V)
URX ---- | CH1H CH1L | ---- TX1
TRX ---- | CH2H CH2L | ---- RX1
GND ---- | GND GND | ---- GND
---------------------

Inoltre, deve avere i valori:

CH_PD a 3.3V => Pin per la programmazione della scheda
RST = 3.3V> Pin per il reset
GPIO00 a 3.3V => General Purpose IO Pin 0
GPIO01 a 3.3V => General Purpose IO pin 1

Per l'alimentazione del ESP-01 è un cosiddetto bordo di sblocco FTDI con porta USB e ponticello raccomanda una sorgente di alimentazione di 3.3V separato è migliore per la conversione tra 3,3 V e 5 V. Questo tipo di sblocco tavole avevamo già utilizzato il nostro self-made Arduino (=> Relazione sulla iXduino) vi invitano a uno scenette e fornire al Consiglio per l'altro con l'elettricità.

Esempio di un bordo di sblocco FTDI. Il ponticello è attualmente impostato a 5V. Esempio di un bordo di sblocco FTDI. Il ponticello è attualmente impostato a 5V.

Anche se questo può sembrare un po 'esagerato, ma poi veniamo a sapere nemmeno un'altra personalità di esp8266. Le schede ESP8266 possono essere usate come una scheda controller standalone tramite Arduino cioè.

Relay Station

Se tutto va bene, il LED rosso ESP-01 schede dovrebbe accendersi. All'avvio, il LED blu lampeggerà brevemente sinistra del rosso. Affinché l'ESP segnali di bordo pronto per il funzionamento.

Per comunicare realmente con l'ESP8266, abbiamo bisogno di uno schizzo. Suppongo che si utilizza un mega porto e le tavole ESP alla porta seriale 1 del Mega (pin RX1, TX1). Con questo non voglio dire di essere collegato direttamente, ma la via indiretta il livello logico Shifter.

void setup ()
{
Serial.begin (9600);
Serial1.begin (115200);
}
void loop ()
{
while (Serial1.available ()) {
Serial.write (Serial1.read ());
}
while (Serial.available ()) {
Serial1.write (Serial.read ());
}
}

Quello che sta accadendo nel disegno, è presto detta. Il Mega comunica con l'ESP-01 sopra Serial1 e via USB al monitor seriale (Serial). Ottenere senza senso sul monitor di serie, cambiare la velocità di trasmissione per il set di valore schizzo. Vedi un po 'senza senso e il testo quindi significativo, il mondo è in ordine.

Il disegno legge (nel primo ciclo while) i dati da Serial1 (bordo ESP) e scrive su seriale (Serial Monitor). Questo consente di leggere l'uscita seriale. Nel secondo ciclo while il disegno legge, inserire il monitor di serie nella casella di testo in alto si (serial), E lo passa al ESP8266 ulteriormente (via Serial1). Per questo è importante nella scatola semi-destra combo (a sinistra della velocità di trasmissione) Entrambi NL & set CR.

AT + CWLAP

+CWLAP: (4,"C1A1 KD-wireless", -92,"44: 32: c8: 9b: af: 5a", 1, -24)
+CWLAP: (3,"StalWLAN", -58,"08: 96: D7: 95: b2: ca", 7, -1)
...
bene AT + CIFSR

+CIFSR: STAIP,"192168178101"
+CIFSR: Stamac,"5c: CF: 7f: 0f: A8: 74"

bene

Una lista completa dei comandi AT si può trovare per esempio in SparkFun.

Finora abbiamo le tavole ESP8266 gestite come un client (STA = Station). Fondamentalmente, esso può essere utilizzato anche come punto di accesso (AP) per costruire una rete mesh locale di diverse schede, per esempio. Questi due ruoli ESP8266 possono anche assumere contemporaneamente (STA + AP).

ESP8266 utilizzare come un consiglio indipendente

Ora ci sono software da utilizzare una scheda ESP8266 nel Arduino IDE come un consiglio indipendente. Come interfaccia per ESP-01 abbiamo bisogno del citato bordo di sblocco di FTDI. In primo luogo abbiamo bisogno di collegare il modulo ESP-01 con la scheda FTDI.

collegamento FTDI e bordo ESP-01 collegamento FTDI e bordo ESP-01

Per il collegamento sono:

  • GND (ESP-01) a GND (FTDI)
  • GPIO0 (ESP-01) a GND (FTDI)
  • RX (ESP-01) con TX (FTDI)
  • TX (ESP-01) con RX (FTDI)
  • CH_PD (ESP-01) a Vcc (FTDI)
  • Vcc (ESP-01) a Vcc (FTDI)

Immaginate il collegamento al computer, assicurarsi di aver impostato i ponticelli sulla scheda FTDI a 3.3V. Ora chiudere la scheda FTDI tramite cavo USB al computer. Il LED a bordo della ESP-01 rosso dovrebbe accendersi.

Si potrebbe ora con un programma terminale come stucco (Windows) o ssh (OS X, Linux) tramite la porta seriale per il collegamento diretto con la scheda esp8266 per lì per controllare il modulo utilizzando i comandi AT.

Dopo di che, abbiamo bisogno di un manager Consiglio al fine di affrontare l'ESP 01 tramite Arduino IDE. Procedere allo Arduino e là nel menu Preferenze. Vedere la parte inferiore della finestra, una casella di testo dal titolo "schede aggiuntive URL Gestione", Ci si entra:

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Quindi è possibile inserire le schede di menu Strumenti la scheda ESP8266 utilizzato e la porta su cui l'adattatore FTDI è. Questo consente di utilizzare la scheda come una scheda Arduino - lavorare solo nei traduttori backend altri strumenti. ma che rimane trasparente per gli sviluppatori.

Dal menu File | Esempi | ESP8266 c'è il programma di flash che si può caricare sul bordo ora, per verificare la configurazione. Mentre il programma viene caricato sulla scheda, si vedrà qualcosa di simile nella finestra Sketch:

Il programma di Blink è caricato al ESP-01 Il programma di Blink è caricato al ESP-01

Dietro le quinte, avete portato sulla ESP8266 un nuovo firmware. Come si può un giorno tornare a AT firmware, si discute lo stesso.

lampeggiatore

Se si desidera aggiornare o sostituire il firmware del ESP-01, un giorno, avete bisogno di un lampeggiatore. Arum si consiglia di farlo? Forse si vuole installare una versione più recente o una versione alternativa del firmware. Su Internet per una vasta gamma di opzioni di esistere.

Inoltre, si è già giocato nuovo firmware alla scheda ESP8266, senza saperlo. Almeno se avete l'Arduino IDE utilizzato per programmare gli schizzi per la scheda di ESP, come descritto sopra. Ogni programma Arduino caricato finisce come firmware sulla scheda di ESP.

Ecco una piccola selezione:

Disegno di circuito con pulsanti normalmente aperti per il ripristino e la GPIO0. premere per preparare il GPIO0 processo flash e premuto mentre si preme RESET. Disegno di circuito con pulsanti normalmente aperti per il ripristino e la GPIO0.(Immagine: http://www.allaboutcircuits.com/)

Per impostazione predefinita, un firmware AT è installata sulla scheda di ESP di AI Pensatore. Questo è il software che abbiamo incontrato in combinazione con i codici di comando AT. La scheda Nodemcu (sulla base della ESP-12E) ha un ambiente Lua. ESPEasy converte una scheda ESP (preferibilmente ESP-12) per un controllo sensore per l'automazione domestica.

Prima di poter caricare un nuovo firmware per una scheda ESP8266, si deve a) collegare la porta GPIO0 del GND bordo e b) eseguire un reset della scheda. Quest'ultimo può essere raggiunto separando la scheda brevemente da ingresso di tensione, per esempio. Per rendere confortevole, si poteva controllare le GPIO0- e RST pin della scheda con gli interruttori. Nella foto da questo sito è possibile ottenere maggiori dettagli, come ad esempio l'ambiente flash hardware dovrebbe essere simile. Nella stessa pagina web fornisce informazioni dettagliate per lo strumento espressi Flash per Windows.

Sebbene lo strumento espressif per lampeggiante firmware appare disordinato, ma ha un sacco di aiuto.Sebbene lo strumento espressif per lampeggiante firmware appare disordinato, ma ha un sacco di aiuto.

Attenzione: C'è schede ESP con caratteristiche differenti, come la memoria Flash diversa grandezza con 512KB, 1MB, 4MB, che di solito sono divisi in due metà: 2 x 256 KB, 2 x 512 KB, 2 x 1 MB, 2 x 2 MB. Quando lampeggia, c'è il cosiddetto "formato flash" Nota circa 2 Mbit, 4 Mbit, 8 Mbit, 16 Mbps o 32 Mbps.

sommario

In questo episodio abbiamo guardato più vicino al ESP8266 blocco, la coppia, sia con l'Arduino come può essere azionato anche da solo, anche utilizzando l'Arduino. Per disponibili in molte versioni e livelli di prestazione ESP8266 tavole ci sono una vasta gamma di versioni del firmware, con conseguente molte applicazioni. Attualmente espressif ha appena svelato il successore del ESP8266 chiamato ESP32 che integra anche Bluetooth. Un futuro episodio affronta l'ESP32 una volta che è effettivamente disponibile.

Nel prossimo episodio risale principalmente al Arduino. E la domanda è: come fa l'ESP8266 per la connettività wireless del Arduino può usare?

La storia finora:

  • Bright Side di Arduino
  • Genuino o Arduino staccato
  • implementare librerie stessi - Arduino / IoT Extra
  • Più piccolo, più profondo, più breve ... lo sviluppo di una stazione meteo
  • Riposante con COAP
  • Comunicazione tramite MQTT
  • Passo dopo passo
  • Le applicazioni con servomotori
  • Buona motorizzato con motori a corrente continua
  • Arduino per i pipistrelli
  • Rilevamento del movimento da radiazione infrarossa
  • Collegamento del display LCD sul bus IIC
  • Ascolta con sensori
  • JavaScript per Arduino Sia la luce!
  • Collegamento molti LED su alcune uscite
  • Fai-da-te progetto: iXduino - Arduino su un tagliere
  • corso accelerato "Elettronica per applicazioni dell'internet degli oggetti" (Parte 3 di 3)
  • corso accelerato "Elettronica per applicazioni dell'internet degli oggetti" (Parte 2 di 3)
  • corso accelerato "Elettronica per applicazioni dell'internet degli oggetti" (Parte 1 di 3)