UND ÜBERTRAGUNG DES GÖTTLICHEN WILLENS VON GENAUEN ZEITSIGNALEN DURCH ESP8266 .
VIERTER TEIL
Also stimmte alles überein. Zuerst sah ich einen Artikel über Gytayms über Vorhänge, die von einem Schrittmotor gesteuert werden. Ich erinnerte mich, dass ich das zweite Jahr den gleichen Motor im Leerlauf hatte. Dann fiel mein Blick auf die
Klangschale , die seit fünf Jahren im Regal verstaubt war. Und dann kamen mir verschiedene kluge Gedanken in den Sinn ...
Nein, natürlich, manchmal, je nach Stimmung, nahm ich diese Tasse in die Hand und extrahierte einige Zeit verschiedene Arten von bezaubernden Geräuschen daraus, aber das war nicht ganz das, was ich wollte. Und ich wollte etwas parallel machen und die Tasse selbst zu dieser Zeit klingen lassen. Es ist klar, dass dies vor tausend Jahren einen separaten
Sklavenmann erfordert hätte, vor dreihundert Jahren wäre es ein ausgeklügeltes Uhrwerk gewesen, und jetzt ... Nun, jetzt haben wir einen Schrittmotor und ein Arduino ProMini-Board und andere
nicht ausgefeilte Elektronik. Es bleibt nur ein wenig auf
Vieh zu codieren. Und stellen Sie gleichzeitig sicher, dass dieser tibetische Meißel gleichzeitig die genaue Zeit abwehrt - vergebens oder etwas, das so viele genaue Zeitserver hervorgebracht hat. Und lassen Sie ESP8266 mit ihnen kommunizieren, sie weiß wie.
Also ...
Es gibt eine Klangschale mit einem Klöppel.
Es ist notwendig, den Hammer gegen den Rand der Schüssel schlagen zu lassen. Automatisch. Auch mit der Möglichkeit der Fernbedienung (und Neuprogrammierung!). Und nur um die Zeit wie eine alte Uhr zu schlagen, aber mit moderner Präzision.
Mit Blick auf die Zukunft werde ich zeigen, was am Ende passiert ist. Mit Ton besser zuschauen.
Aber fangen wir in der richtigen Reihenfolge an. Zuerst musste ich verstehen, wie die Mechanik aussehen und funktionieren würde. Für Elektronik und Software war ich ruhig - hinter
drei Artikeln über den Umgang mit Arduinki aus der Ferne.
Das Hauptbewegungselement sollte ein einfacher 28YBJ-48-Schrittmotor sein, und ich musste verstehen, ob er mit dem Hammer umgehen konnte.
Die Verbindung der Dvigun mit dem Arduino ist nicht schwierig, zum Glück wurde sie mit einem vorgefertigten ULN2003-Treiber verkauft. Es war nur notwendig, eine separate Stromversorgung für 5 Volt und eine Reserve von 200-300 mA bereitzustellen, da Sie definitiv nicht genug Konverter am Arduino selbst haben werden. Dann übertragen wir an vier beliebigen digitalen Ports (ich habe PB1, PB2, PB3, PB4 genommen) die folgenden Bit-Notebooks in der Menge von acht Teilen.
PORTB=0b00000010;
Bei Drehung in die entgegengesetzte Richtung übertragen wir dieselben Notebooks, jedoch in umgekehrter Reihenfolge.
PORTB=0b00010010; PORTB=0b00010000; PORTB=0b00011000; PORTB=0b00001000; PORTB=0b00001100; PORTB=0b00000100; PORTB=0b00000110; PORTB=0b00000010;
Das einzige, was entsteht, ist die Geschwindigkeit, mit der Daten übertragen werden. Es ist klar, dass sich die Motorwelle umso schneller dreht, je öfter, aber bis zu welcher Grenze? Die Beschreibung enthält eine mysteriöse Frequenz von 100 Hz, aber was genau bedeutet das - die Periode eines vollständigen Zyklus oder jedes Knabbern einzeln?
Im Verlauf der Experimente stellte sich heraus, dass anscheinend die Häufigkeit der Änderung von genau Tetraden gemeint war. Bis zum Maximum gelang es mir, diese Frequenz auf 147 Hz zu beschleunigen, bei der sich die Motorwelle in ein oder zwei Sekunden drehte. Ich habe es nicht genau gemessen, aber Sie können selbst beurteilen, dass sich dieses Modell mit diesem Getriebe nicht in besonderer Agilität unterscheidet. Aber für meinen Hammer schien es im Prinzip geeignet zu sein.
Schließlich ist uns nicht nur die Geschwindigkeit wichtig (oder vielmehr nicht einmal sehr wichtig), sondern auch die Kraft, mit der der Motor das Arbeitsmedium beeinflussen kann. In Beiträgen zu diesem Motor wurde argumentiert, dass sie nicht mit einer Hand anhalten könnten. Wie sich herausstellte, wird der Schaft selbst, ja, Sie werden nicht anhalten, aber bereits ein kleiner Hebel (und ich habe mich für ein Hebelsystem entschieden), der buchstäblich 10 cm lang ist, stoppt und bleibt auch bei einem kleinen lokalen Aufprall sehr leicht stehen.
Daher passierte die anfänglich einfachste Option, wenn der mit der Welle verschraubte Hebel den Schläger auf die Aufhängung drückt, die dementsprechend die Schüssel schlägt, nicht. Der Ton war zu schwach. Also beschloss ich, die Schwerkraft um Hilfe zu bitten (die sehr „herzlose Schlampe“ in den Worten von Sheldon Cooper). In dieser Ausführungsform zog der Hebel eine Klappe bis zu einem Winkel von ungefähr 30 Grad relativ zur Richtung zum Erdmittelpunkt und löste sich dann von dieser und schickte sie auf ihren Weg zur Schüssel. Ich mochte den Sound sehr, sowohl von unten als auch von meinen Nachbarn. Der Entriegelungsmechanismus wurde an einem Magneten hergestellt, der am Ende des Hebels angebracht war. Als sie aufstiegen, besiegte die Schwerkraft die magnetische und das Schloss wurde gelöst. Dann machte ich einen helfenden mechanischen Stopp - eine Querstange, mit der sich der Hammer nahe dem äußersten Anstiegspunkt traf. Der Motor drehte sich weiter, der Hebel zog und löste die Magnetverriegelung gewaltsam. Hier wurde der Motor durch die Schwerkraft unterstützt, so dass der Aufwand zum Ausrücken sehr gering war.
Das Design selbst wurde auf Basis der Details des Eiffelturm-Kinderdesigners zusammengestellt. Ich kaufte es für eine lange Zeit und benutzte seine Teile regelmäßig für mein Handwerk. Der Turm stellte sich natürlich nicht als Eiffel heraus, aber meiner Meinung nach ist es keineswegs schlimmer :)
Alles hat perfekt funktioniert, aber mit einem Minus - der Sound war immer die gleiche Leistung. Dies ist normal für das Schlagen der Zeit, aber im freien Modus möchte ich nicht nur verschiedene Pausen in der Zeit hören, sondern auch Geräusche unterschiedlicher Stärke. Daher war es notwendig, einen Elektromagneten anzulegen, was ebenfalls sehr nützlich war. Herkömmliche Magnete waren ebenfalls nützlich - eine Säule mit fünf kleinen Magneten, die ich als Dämpfer verwendete, um die Vibrationen des Schlägers nach dem Auftreffen auf die Schüssel zu zähmen.
Zuerst habe ich es am Ende des Hebels installiert, aber das Design war umständlich, fadenscheinig und unzuverlässig. Daher bewegte sich der Elektromagnet zu einem Hammer. Er verbrauchte ungefähr 300 mA und natürlich war es unmöglich, es vom Hafen von Arduino aus zu kontrollieren. Ich musste einen einfachen Transistorschlüssel auf ein kleines Steckbrett legen.
R1 - 560 Ohm, VD1 - 1N4007, VT1 - BD139
Ich habe das elektronische Hauptteil auf dem „Arduino ProMini“ und dem ESP8266-07-Modul zusammengebaut, dessen Firmware ich gemäß meinem
alten Artikel Schritt für Schritt vollständig fertiggestellt habe. Infolgedessen hatte ich wie üblich die Möglichkeit, das Arduino drahtlos zu programmieren und auch remote mit ihm zu kommunizieren und Daten auszutauschen, die ich schließlich erfolgreich nutzte. Das Diagramm zeigt jedoch den Arduino Nano aus historischen Gründen, aber seine Verbindung ist nicht anders.
Also, was habe ich mir gewünscht und dann im Programmcode verkörpert.
- Wenn Sie das System einschalten, muss es unabhängig in den Überwachungsmodus wechseln.
- Auf dem Computer (Smartphone) sollte eine Anwendung zum Ändern der Betriebsmodi und zum Übertragen der erforderlichen Daten vorhanden sein.
- Die Modi sollten einfach sein - eine Uhr, zufälliges Murmeln und manuelle Steuerung.
Ich begann, wie es schien, mit der einfachsten Sache - Stunden. In der Tat sammelt jeder Amateurfunk-Anfänger zuerst eine Sonde und dann eine elektronische Uhr. Und dann wundert er sich jedoch, warum diese Uhr um eine Minute pro Stunde zurückbleibt - es scheint, dass er theoretisch alles richtig berechnet hat.
Ich hatte bereits die zusammengebaute elektronische Uhr.
Und ihr Hauptmerkmal, das mir jetzt nützlich war, war ihre Fähigkeit, die genaue Zeit von NTP-Servern mit demselben ESP8266-Mikroschaltkreis in der Person seiner allerersten und einfachsten Inkarnation zu ziehen.
Ich wollte vor ein paar Jahren sogar einen Artikel zu diesem Thema einreichen, aber nachdem ich gesehen hatte, wie oft dies bereits getan wurde, änderte ich meine Meinung. Sie werden doch lachen. Aber im Rahmen dieses Beitrags ist eine Analyse ihrer Arbeit durchaus angebracht. Wie ich bereits in den Artikeln erwähnt habe, schreibe ich Programme für ESP8266 in der LUA-Sprache. Es hat sich so ergeben.
Daher war der in dieses ESP-Modul geladene Code so. uart.setup(0,9600,8,0,1,0) timezone = 3
Das Endergebnis ist einfach. Einmal (oder nicht) wird die Funktion aufgerufen, die den UDP-Client einrichtet, der den genauen Zeitserver aufruft und die genaue Zeit entsprechend abfragt. Als Antwort gibt der Server zweiunddreißig Bytes aus, von denen die gewünschten vier Datenbytes abgerufen werden müssen. Leider sind dies nicht Minuten und Stunden, sondern die Anzahl der Sekunden, die seit dem 1. Januar 1900 vergangen sind. Daher müssen Sie dann die aktuelle Zeit aus den vier Bytes dieser Sekunden mit verschiedenen komplexen Manipulationen berechnen.
Außerdem ist alles einfacher. Starten Sie den UART-Sender und lassen Sie die berechnete Zeit um drei Bytes fallen - Stunden, Minuten und Sekunden.
Und ich habe diesen Code erneut in meinen LUA-Bootloader (Link) eingefügt, genau an der Stelle, an der die Verbindung zum WI-FI-Netzwerk bereits hergestellt wurde, aber die weiteren Arbeiten haben noch nicht begonnen.
In voller Sicht sieht es so aus. function InstrProgrammingEnable ()
Dies widerspricht natürlich meinem Konzept, bei dem der ESP8266 eine saubere drahtlose Brücke ist und der ATMEL-Mikrocontroller den Rest erledigt, aber wie sie sagen: "einmal, nicht ...".
Wir haben also die anfängliche genaue Zeit erhalten (direkt vom NTP-Server oder indirekt über die Anwendung auf dem Computer, es spielt keine Rolle), dann möchten wir die Zeit selbst berücksichtigen. Erstens muss das Netzwerk nicht geladen werden, und zweitens können Sie mit ATMEL theoretisch Sekunden mit guter Genauigkeit zählen. Theoretisch ja. In der Praxis gibt es jedoch Fallstricke.
Ein kleiner Exkurs über die Echtzeituhr am AVR.Theoretisch ist es nicht kompliziert, eine Uhr auf dem AVR-Mikrocontroller aufzubauen. Die tollwütigsten Designer haben dafür sogar einen Taktquarz mit 32768 Hz in die Schaltung geschoben. Tatsächlich ist dies jedoch nicht erforderlich. Tatsächlich ist ein Taktquarz erforderlich, um ein Interrupt-Vielfaches einer Sekunde zu bilden und einen
schlafenden (Noten-) Mikrocontroller zu wecken. Wenn Ihr Gerät ständig arbeitet und die Uhr normalerweise funktioniert, ist es rücksichtslos, zusätzlichen Quarz auf den vorhandenen zu setzen und zwei Eingabe- / Ausgabezweige darunter zu nehmen. Es ist möglich, einen Quarzresonator zu verwenden, der bereits vorhanden ist, acht oder sechzehn Megahertz. Die Quantisierungsgenauigkeit reicht für Ihre Augen aus, und das Zählen einer Sekunde als Timer-Zähler ist ebenfalls einfach.
Tatsächlich hat der AVR-Mikrocontroller bereits alles dafür. Wie Sie wissen, kommt das Eingangstaktsignal (z. B. 8 MHz) im Chip (z. B. AVRmega328P als das für Arduino am häufigsten verwendete) auf dem sogenannten Pre-Splitter an, wo es durch den Wunsch des Programmierers weiter unterteilt werden kann (normalerweise durch 8, 64, 256, 1024). Und dann kommt er zu einer Art Zeitzähler (z. B. T1), der sofort zu erhöhen beginnt.
Nehmen wir also 8 MHz und dividieren durch 256. Wir erhalten jeweils die Taktfrequenz des Zählers 31250 Hz. Da der T1-Zähler sechzehnstellig ist und entsprechend bis zu 65535 zählen kann, hat er dementsprechend nur Zeit, in einer Sekunde bis zu 31250 zu zählen. Was wir brauchen. Darüber hinaus verfügt unser Timer über ein weiteres sehr nützliches Vergleichsregister. Wenn wir dort die Nummer 31250 notieren, wird sie unter bestimmten Bedingungen ständig mit dem Inhalt des T1-Zählers verglichen, und schließlich erzeugt der Zähler, wenn er gleich ist, ein Interrupt-Signal, z. B. behalten Sie Ihr zweites.
Es stellt sich als bequem heraus, aber leider nicht ganz genau. Denn unser Zähler wird mit einem Quantisierungsfehler von 256 / 8.000.000 gezählt, was einen ziemlich großen Fehler bei der Berechnung einer Sekunde in bis zu 32 Mikrosekunden ergibt. Dies führt zu einem Fehler von 2,8 Sekunden pro Tag (0,000032 * 3600 * 24).
Wenn wir jedoch die ursprünglichen 8 MHz durch einen kleineren Betrag teilen, beispielsweise durch 64, erhöht sich die Quantisierungsgenauigkeit um das Vierfache auf 8 μs und verringert den resultierenden Fehler auf 0,33 Sekunden pro Tag. In diesem Fall muss der Zähler jedoch leider bis zu 125.000 gezählt werden, und eine solche Nummer im 16-Bit-Register wird nicht eingegeben. Wir müssen eine kleinere Zahl in das Vergleichsregister schreiben (62500 kann noch passen) und eine Schleife im Programm selbst hinzufügen, wobei eine Sekunde nicht von einem, sondern von zwei Interrupts gezählt wird.
Aber wir haben einen Idealfall angenommen, und ein echter Quarzresonator, der speziell auf einer „Made in China“ -Platte installiert ist, kann Ihnen viele Überraschungen bringen. Nein, wenn Sie sich Standardquarz auf
Datenblättern ansehen, ist theoretisch nicht alles so schlecht.
Wie wir sehen können, verhält sich Quarz im mittleren Bereich ziemlich gut. Es hat eine eigene Instabilität bei 25 ppm (oder mit anderen Worten 25 ppm), dh es schwingt bei einer Frequenz von nicht 8 MHz mit, aber beispielsweise bei einer Frequenz von 8 0002 MHz, was zu einem Fehler von bis zu 2,1 Sekunden führt pro Tag. Dies ist jedoch ein ständiger Fehler und kann berücksichtigt werden. Ein solcher Quarz kann auch bei einer Temperatur von 5 bis 10 ppm pro Grad schweben, aber unter Raumbetriebsbedingungen der Vorrichtung ist der Fehler ebenfalls gering. Es gibt immer noch einen Faktor wie das Altern, aber es ist sehr spärlich und verändert die Eigenschaften von Quarz in einen Zustand von mindestens einer gewissen Auffälligkeit, also vielleicht fünf Jahren. Oder zehn.
Und hier freuen wir uns, einen chinesischen Arduino-Klon zu nehmen, zum Beispiel ARDUINO UNO.
Wir führen darauf ein Testprogramm zum Zählen der Zeit aus und legen los. Rückstand pro Stunde für eine Minute? Einfach! Zweites Arduino UNO Board? Nicht besser.
Nimm den Arduino ProMini.
Und hier ist besser, ja. Der Fehler verringerte sich auf zwanzig Sekunden pro Stunde. Na ja, schon vergleichbar mit einer mechanischen Kuckucksuhr.
Das letzte Board, das ich zur Hand hatte, war das Arduino Nano.
Und sie war die einzige, die mehr oder weniger gesunde Ergebnisse zeigte.
Aber selbst mit einem solchen Board, das nur theoretische Konstrukte verwendet, verstehen Sie selbst, dass Sie keine exakte Uhr machen. Das Board muss konfiguriert werden und ich stieg seufzend hinter das Oszilloskop.
Wie sich herausstellte, haben Arduino-Platinen eine unangenehme Eigenschaft: Der Ausgang, an den der Quarzresonator angeschlossen ist, hat keinen Ausgang zum Stiftkamm, obwohl er Port PB7 entspricht. Da der Hafen von Quarz besetzt ist, klammern Sie sich nicht daran. Und genau am Fuß des Mikrocontrollers ist es sehr schwierig, die Oszilloskopsonde für die Oberflächenmontage und einen Abstand von 0,5 mm zwischen den Anschlüssen aufzunehmen. Aber selbst das rechte Bein zu verbinden, gab mir nichts. Entweder weil ich falsch gestochert habe oder weil ich an der falschen Stelle gestochert habe, weil der Ausgang des Quarzresonators möglicherweise nicht der Ausgang des Taktgenerators ist und sich im Allgemeinen im Mikrocontroller selbst befindet. Daher musste ich Problemumgehungen umgehen - den Vorteiler auf den minimalen Teilungskoeffizienten setzen - eins, Null in das Vergleichsregister schreiben, damit der Interrupt sofort ruckelte, und in einem speziellen Modus in den Mikrocontroller eintreten, in dem der Portabschnitt PB1 mit jedem solchen Interrupt seinen logischen Zustand ändert.
Wenn Sie die Arduino Nano 16-MHz-Karte einschalten, sollte logischerweise ein 8-MHz-Mäander am Ausgang dieses Ports erscheinen.
Welches ist passiert. Das Oszilloskop zeigte eine Frequenz von 8,002 bis 31 MHz. Darüber hinaus lebte die letzte Entladung ihr eigenes Leben und ich verstand immer noch nicht, ob die Genauigkeit des Oszilloskops fehlt oder ob die Frequenz des Kristalloszillators so schwebt. Eher wie eine Sekunde.
Auch dort roch eine gute thermische Stabilität nicht. Wenn Sie auf dem Brett atmen (vielleicht kommen die Behälter übrigens immer noch aus Feuchtigkeit?) Oder einen Lötkolben (von weit her) mitbringen, kann sich der Quarz sofort um fünfzig Hertz entfernen. Und diese Messungen sind immer noch ungefähr verdoppelt, da die Anfangsfrequenz 16 MHz beträgt.
Daher ist es bei Arduino-Boards (zumindest solchen chinesischen Ursprungs) unmöglich, eine Genauigkeit von mehr als 200 Hz bei einer Taktfrequenz von 16 MHz zu erreichen. Dies gibt uns die ultimative Genauigkeit der auf solchen Brettern montierten Uhren nicht mehr als eine Sekunde pro Tag. Und das ist gut so.
Weil es chinesische Klone von Arduino UNO gibt, die ich bereits erwähnt habe und bei denen im Allgemeinen alles schlecht ist. Und sie sind sehr verbreitet, weil sie billig und bequem sind.
Ihre Frequenz kann also um mehr als hundert Kilohertz von der angegebenen abweichen! Das ist sogar für den schlimmsten chinesischen Quarz untypisch.
Das Rätsel beginnt damit, dass 12 MHz auf den Quarz selbst geschrieben sind! Und auch in den Beschreibungen der Verkäufer.
Aber es gibt keine 12 MHz, das ist sicher. Wenn Sie die serielle UART-Schnittstelle auf der Karte aktivieren, werden Sie es selbst sehen. Da der UART auf diese Frequenz eingestellt ist, werden Sie nicht arbeiten. Und auf eine Frequenz von 16 MHz abgestimmt - wird sein. Außerdem habe ich mir die Wellenformen auf beiden meiner Arduino Uno-Boards persönlich angesehen. Die erste Karte hatte eine Generatorfrequenz von 15,8784 MHz und die zweite 15,8661 MHz.
Aber plötzlich stellte sich heraus, dass 12-MHz-Quarz nicht direkt mit dem AVR-Mikrocontroller zusammenhängt, sondern dafür ausgelegt ist, die serielle Schnittstelle mit einem Computer über USB zu betreiben (um Skizzen herunterzuladen). Daher kam die Annahme, dass sich kein Quarz im Inneren befand, sondern eine schlecht abgestimmte RC-Kette, nicht zustande. Und der Quarz, den wir brauchen, ist viel kleiner und befindet sich neben dem Mikrocontroller-Chip. Aber es ist sehr klein und es gibt keine Inschrift darauf.
Infolgedessen konnte ich immer noch nicht verstehen, wie und wo man Quarzresonatoren von solch schrecklicher Qualität findet. Aber anscheinend ist in China alles möglich. Und irgendwie dachte ich an die Draufgänger, die Arduinki für ernsthafte Geschäfte benutzten. Nun, Software kann und sollte selbst geschrieben werden, aber was tun mit der Qualität der Module selbst? Anscheinend schieben die Chinesen von den elektronischen Bauteilen die billigsten und abgelehnten in sie hinein.Das Singing Bowl Programm für AVR.Nachdem ich alle Schwierigkeiten mit genauem Timing überwunden hatte, schrieb ich am Ende den folgenden Code für meinen Arduino ProMiniC-Programm für den Mikrocontroller AVRmega328P #define F_CPU 8000000 #include <avr/io.h> #include <avr/interrupt.h> #include <stdint.h>// #include <math.h> // #include <stdio.h> // - #include <avr/eeprom.h> #include <stdbool.h> #include <setjmp.h> #include <stdlib.h> volatile bool change_mode = false; volatile bool boom =false; volatile bool go_ahead=true; volatile bool go_back=false; volatile bool gerkon=false; volatile uint8_t latency=2;// latency = 1 volatile uint8_t hour=12; volatile uint8_t hour24=12;// 12 volatile uint8_t minute=0; volatile uint8_t secund=0; volatile uint8_t power=0; volatile uint8_t pause_between_boom=0; volatile uint8_t first_byte=0; volatile uint8_t second_byte=0; volatile uint8_t third_byte=0; volatile uint8_t firth_byte=0; volatile uint8_t fifth_byte=0; volatile uint8_t cSREG; ISR(USART_RX_vect) { // , // – , . if (first_byte==0) { first_byte=UDR0; change_mode=true; goto ret; } if (second_byte==0) { second_byte=UDR0; goto ret; } if (third_byte==0) { third_byte=UDR0; goto ret; } if (firth_byte==0) { firth_byte=UDR0; goto ret; } if (fifth_byte==0) { fifth_byte=UDR0; goto ret; } cSREG=UDR0; ret: return; } ISR(PCINT1_vect )//PC2 int 10 // { if (go_ahead) { UDR0=44; // 44 } if (go_back) { gerkon=true; } } ISR(TIMER1_COMPA_vect) { // secund++; if (secund ==60) { secund=0; minute++; if(minute==60) { minute=0; hour++; if(hour==12) { hour=1;// 12 } hour24++; if(hour24==24) { hour24=1; } boom=true; } } } void time_delay(long dell)// { long i; dell=dell*796;// 8 for(i=0;i<dell;i++){;;}; sei();// , - .WTF ?????????????????????? } void turn_onkward()// { uint8_t legnth=170;// ( 0 170) for(uint16_t i =0;i<=legnth;i++) { go_ahead=true; PORTB=0b00000010;// time_delay(latency); PORTB=0b00000110; time_delay(latency); PORTB=0b00000100; time_delay(latency); PORTB=0b00001100; time_delay(latency); PORTB=0b00001000; time_delay(latency); PORTB=0b00011000; time_delay(latency); PORTB=0b00010000; time_delay(latency); PORTB=0b00010010; time_delay(latency); if (i>140) { PORTD |=(1<<PORTD2);// , 1 - } } time_delay(100); go_ahead=false; } void turn_backward(uint8_t pause, uint8_t force_of_sound)// // // { uint8_t legnth=170;// ( 0 170) for(uint16_t i =0;i<=legnth;i++) { go_back=true; PORTB=0b00010010; time_delay(latency); PORTB=0b00010000; time_delay(latency); PORTB=0b00011000; time_delay(latency); PORTB=0b00001000; time_delay(latency); PORTB=0b00001100; time_delay(latency); PORTB=0b00000100; time_delay(latency); PORTB=0b00000110; time_delay(latency); PORTB=0b00000010;//16 ms , latency = 2 time_delay(latency); if (i==force_of_sound*17) { PORTD &=~(1<<PORTD2);// , 0 - } if (gerkon) { gerkon=false; break; } } time_delay(50); time_delay(pause*1000);// go_back=false; } void sound(uint8_t force,uint8_t pause) // 1 10 { turn_onkward(); turn_backward(pause,force); } int main(void) { sei(); // UART 9600 8 time_delay(2000);// , esp - UCSR0A=0; UCSR0B=0b10011000;// a UART UCSR0C=0b00000110; UBRR0L=51;// 8 9600 UART UBRR0H=0; // INT0 2 10 // PCICR|=(1<<PCIE1);// 14-8 PCMSK1|=(1<<PCINT10);// INT10 DDRC&=~(1<<PORTC2); DDRB=0b00111110;//PB1-PB4 , PB5 DDRD=0b00000100; // PD2 //SET INTERRUPT FROM TIMER1 AND SET TIMER1 GTCCR=0;//RESET PRESCALER TCCR1A=0;//I/O NORMAL WORK TCCR1C=0; TCCR1B=0B00001100;//1/256 PRESCALING AND CTC MODE TCNT1H=0;//RESET TIMER1 TCNT1L=0; TIMSK1=0B00000010;//SET COMPARE A INTERRUPT ENABLED OCR1AH=0x79;//SET TIME CONSTANT IN COMPARE REGISTER OCR1AL=0xa7;// 31143 7 972 608 TCCR0B=0b00000010;// 8 0 255 while (1) { begining: time_delay(1000); if (first_byte!=0) { UDR0=first_byte;// . (100,101,102) } if (first_byte==100)// ( NTP { hour=second_byte;// if (hour>12)// 12 (24 ) { hour=hour-12; } if (hour==0) { hour=12; } minute=third_byte;// secund=firth_byte;// power=fifth_byte;// first_byte=0;// second_byte=0; third_byte=0; firth_byte=0; fifth_byte=0; change_mode=false; goto clock_mode; } if (first_byte==101)// { power=second_byte; pause_between_boom=third_byte; first_byte=0; second_byte=0; third_byte=0; firth_byte=0; fifth_byte=0; change_mode=false; goto random_mode; } if (first_byte==102)// { power=second_byte; first_byte=0; second_byte=0; third_byte=0; firth_byte=0; fifth_byte=0; change_mode=false; goto hand_mode; } // , first_byte=0; second_byte=0; third_byte=0; firth_byte=0; fifth_byte=0; goto begining; clock_mode: while(change_mode==false) { if (boom)// { for(uint8_t i =0;i<hour;i++) { if ((hour24>21)|(hour24<10))// { sound(3,0);// 10 (), 0 boom=false; } else { sound(power,0);// 10 (), 0 boom=false; } } } } goto begining; random_mode: while(change_mode==false) { uint8_t random_power = TCNT0;// 1 uint8_t random_pause = TCNT1L;// 1 random_pause=TCNT0;// 1 random_power=random_power/25; if (random_power<5) { random_power=random_power+2;// } random_pause=(random_pause/25)+pause_between_boom; UDR0=random_pause; time_delay(100); sound(random_power,random_pause); } goto begining; hand_mode: sound(power,0); goto begining; } }
Alles funktioniert einfach. Nach der Initialisierung der Peripheriegeräte geht der Mikrocontroller in eine Endlosschleife und wartet auf einen UART-Befehl. Die Befehlscodes lauten wie folgt:100-Takt-Modus 101 Zufallsmodus102 Manueller Modus.Da der AVR keine Rolle spielt, woher der Befehl stammt, wird der erste Befehl von ESP8266 nach dem Einschalten ausgelöst. Wie bereits erwähnt, klammert sich das ESP-Modul an das Netzwerk, zieht die genaue Zeit vom NTP-Server und sendet sie an den Mikrocontroller. Somit tritt die Arduinka zuerst in den Taktschlagmodus ein. Durch Unterbrechen des T1-Zeitzählers werden Sekunden, Minuten und Stunden gezählt und bei Bedarf Funktionen aufgerufen, um den Schrittmotor hin und her zu stellen, um die Zeit zu verkürzen.Die Unterbrechung durch den Reed-Schalter setzt den gleichen Nullpunkt, wenn sich der Hebel, der an der Klappe zieht, im Laufe der Zeit relativ zur Motorwelle zu bewegen beginnt.Die Anwendung für den Computer.Es basiert trotzdem auf denselben alten Programmen , nur die visuelle Darstellung ändert sich hier.
Trotzdem steigt der Kommunikationskanal mit AVR über HTTP- und UDP-Verbindungen an. Bei Bedarf werden dann der erforderliche Steuerbefehl und die zugehörigen Daten in Form von UDP-Paketen gesendet. Natürlich wäre es korrekter, die Steuerung und die Daten auf verschiedenen Kanälen zu trennen, aber erstens müssen Sie den LUA-Code im Bootloader bearbeiten, und zweitens macht dies keinen Sinn, da der Mikrocontroller und die Befehle und Daten einzeln und empfangen werden der gleiche UART. Und doch verwirrt AVR sie manchmal (selten). Dies ist jedoch nicht beängstigend, denn wenn der Mikrocontroller den Befehl nicht erkennt, führt er ihn nicht aus und wird auch in der Computeranwendung darüber informiert, wodurch Sie aufgefordert werden, die Eingabe zu wiederholen.Der Code ist bei Github erhältlich.PSIm Allgemeinen schlagen tibetische Mönche nicht nur mit Klatschern in Klangschalen. Wenn Sie den Hammer vorsichtig am Rand der Schüssel entlang fahren, entsteht ohne Klopfen ein wunderbarer Klang, der die göttliche Natur der Resonanz unter sich hat. Aber das ist eine wirklich ernsthafte Herausforderung für Arduino.