- Werkende uitleg:
- Vereiste componenten:
- Schakelschema:
- Werken met nRF24L01 + draadloze zendontvangermodule:
- Programmeren van de Arduinos:
- Verwerkingsprogramma:
- Testen:
Het creëren van een lokaal netwerk om personeel en vertrouwelijke gegevens te delen is bijna onmogelijk geworden voor een gewone man in onze moderne wereld. Dit komt vooral omdat alle gangbare chatmethoden zoals Whatsapp, Facebook, Hangout en bijna alles een internetverbinding hebben.
Wat als we gegevens zouden kunnen delen zonder het medium internet ?
Hoe gaaf zou het zijn als u zou kunnen communiceren met mensen in uw huis of op het werk zonder een netpack of internetverbinding?
Wat als we ons chatscherm zouden kunnen aanpassen met onze eigen verbeeldingskracht?
Dit alles is mogelijk met een microcontroller en een draadloos transmissiemedium. Deze Arduino Chat Room met behulp van het nRF24L01 Project zal u begeleiden bij het opzetten van een goedkope Chat Room in uw omgeving.
Dus laten we erin springen en kijken hoe het werkt.
Werkende uitleg:
Om dit ding te laten werken, hebben we in principe een paar Arduino-kaarten en goedkope draadloze modules nodig. De draadloze modules die we hier zullen gebruiken, zijn nRF24L01. De reden om voor deze modules te kiezen is dat dit de opvolgers zijn van Zigbee en gemakkelijk te werken is met een opgezette verbinding. Ook werken deze modules op 2,4 GHz (ISM-band) met frequentieverspringing gespreid spectrum en shock burst-opties waardoor we ons ontspannen voelen bij interferentieproblemen.
Onze Arduino en NRF24L01 zijn met elkaar verbonden om een seriële communicatie tot stand te brengen zodat ze met elkaar kunnen praten. De NRF24L01 zijn half duplex transceiver modules, dus ze kunnen data versturen en ontvangen. De gegevens worden verzameld van de gebruiker en verzonden. Deze gegevens kunnen door elke (of een bepaalde) module worden ontvangen en op hun scherm worden weergegeven.
Maar!!!!! Gaan we chatten met behulp van het Debug-scherm van Arduino? Natuurlijk niet. We gaan ons eigen chatscherm bouwen en aanpassen met behulp van 'Processing'. Processing is een software die kan communiceren met de Arduino met behulp van UART. We maken een.exe-bestand met Processing-taal, dat op elke computer met Java Runtime kan worden uitgevoerd. Om te chatten hoeven we alleen maar onze Arduino in te pluggen en dit.exe-bestand te openen, en Booooom !! we zijn in onze eigen geprivatiseerde volledig gratis chatroom.
Dit project is beperkt tot het toevoegen van slechts twee leden aan de chatroom, maar de nRF24L01 heeft 6 pijplijnen, en dus kunnen er maximaal 6 leden in onze chatroom zijn. Deze char room kan werken binnen het bereik van 100 meter, afhankelijk van de nRF24L01 modules.
Dus laten we gaan winkelen !!!!
Vereiste componenten:
- Arduino (elke versie of model) - 2Nos
- nRF24L01 + draadloze zendontvangermodule - 2 nrs
- 3.3 Spanningsregelaar - 2 nrs. (Niet verplicht)
- Draden aansluiten
- Interesse (Lolz)
Schakelschema:
Arduino Mega met nRF24L01:
Arduino Nano met nRF24L01:
Ons project kent geen complexe verbindingen. Ik heb een Arduino Mega en een Arduino Nano gebruikt en hun verbindingen met nRF24L01 zijn hierboven weergegeven. U kunt alle Arduino-modellen gebruiken.
Werken met nRF24L01 + draadloze zendontvangermodule:
Om ervoor te zorgen dat onze nRF24L01 ruisvrij werkt, willen we misschien de volgende dingen overwegen. Ik heb lang aan deze nRF24L01 + gewerkt en heb geleerd dat de volgende punten je kunnen helpen om tegen een muur te worden geslagen.
1. De meeste nRF24L01 + -modules op de markt zijn nep. De goedkope die we kunnen vinden op Ebay en Amazon zijn de ergste (maak je geen zorgen, met enkele aanpassingen kunnen we ze laten werken)
2. Het grootste probleem is de stroomvoorziening, niet uw code. De meeste codes online zullen naar behoren werken, ik heb zelf een werkende code die ik persoonlijk heb getest, laat me weten of je ze nodig hebt.
3. Let op want de modules die geprint zijn als NRF24L01 + zijn eigenlijk Si24Ri (ja een Chinees product).
4. De kloon- en nepmodules zullen meer stroom verbruiken, dus ontwikkel uw stroomcircuit niet op basis van de nRF24L01 + datasheet, omdat Si24Ri een hoog stroomverbruik zal hebben van ongeveer 250mA.
5. Pas op voor spanningsrimpelingen en stroompieken, deze modules zijn erg gevoelig en kunnen gemakkelijk verbranden. (;-(tot nu toe 2 modules gefrituurd)
6. Het toevoegen van een paar condensatoren (10uF en 0.1uF) over Vcc en Gnd van de module helpt om uw toevoer zuiver te maken en dit werkt voor de meeste modules.
Als je nog steeds problemen hebt, meld je dan in het commentaargedeelte of lees dit door.
Programmeren van de Arduinos:
Het programma voor zowel Arduino Nano als Mega zal vergelijkbaar zijn voor de verandering in CE- en CS-pinnen. Ik zal het programma uitleggen door het op te splitsen in kleine segmenten.
Omdat de Arduino en nRF24L01 communiceren via de SPI, hebben we de SPI-bibliotheek opgeroepen. We hebben ook onze Maniacbug RF24-lib toegevoegd om onze RF-modules te laten werken. Download het bestand vanaf hier en voeg ze toe aan uw IDE.
# omvatten
Onze NRF-modules zijn aangesloten op pin 8 en 10 op respectievelijk CE en CS.
RF24 myRadio (8, 10);
We creëren een gestructureerd datapakket genaamd pakket . De variabele tekst wordt gebruikt om gegevens in de ether te verzenden.
struct pakket {char text; // Tekst om via de ether te verzenden}; typedef struct pakket Pakket; Pakketgegevens;
In de void setup () functie initialiseren we de baudrate naar 9600 en stellen we onze modules in op 115 met MIN stroomverbruik en 250KBPS snelheid. U kunt later met deze waarden spelen.
void setup () {Serial.begin (9600); vertraging (1000); //Serial.print("Setup Initialized "); myRadio.begin (); myRadio.setChannel (115); // 115 band boven WIFI-signalen myRadio.setPALevel (RF24_PA_MIN); // MIN vermogen lage woede myRadio.setDataRate (RF24_250KBPS); // Minimumsnelheid}
De module is gemaakt om te werken in de verzendmodus als gegevens worden ontvangen via een seriële buffer, anders zal het in de ontvangermodus zijn om gegevens in de lucht te zoeken. De gegevens van de gebruiker worden opgeslagen in een char Array en naar WriteData () gestuurd om ze te verzenden.
void loop () {while (Serial.available ()> 0) // Haal waarden op van gebruiker {val = Serial.peek (); if (index <19) // Een kleiner dan de grootte van de array {inChar = Serial.read (); // Lees een karakter inData = inChar; // Bewaar het index ++; // Verhogen waar vervolgens moet worden geschreven inData = '\ 0'; // Null beëindigt de string} if (val == '#') {strcpy (data.text, inData); WriteData (); // Zet module in Transmit-modus while (index! = 0) {inData = ''; inhoudsopgave--; }}} ReadData (); // Put module ontvangstmodus}
void WriteData () functie schrijft de data op 0xF0F0F0F0AA adres, dit adres wordt gebruikt als schrijfpijp op een andere module.
void WriteData () {myRadio.stopListening (); // Stop met ontvangen en start met het verzenden van myRadio.openWritingPipe (0xF0F0F0F066); // Verzendt gegevens op dit 40-bits adres myRadio.write (& data, sizeof (data)); vertraging (300); }
void ReadData () functie schrijft de data op 0xF0F0F0F066 dit adres, dit adres wordt gebruikt als leespijp op een andere module.
leegte ReadData () {myRadio.openReadingPipe (1, 0xF0F0F0F0AA); // Welke pijp te lezen, 40 bit adres myRadio.startListening (); // Stop met verzenden en start Reveicing if (myRadio.available ()) {while (myRadio.available ()) {myRadio.read (& data, sizeof (data)); } Serial.println (data.text); }}
Dat is het, ons programmeergedeelte is voorbij. Als je hier een paar dingen niet begrijpt, bekijk dan de twee programma's voor beide Arduino's, die in de sectie Code hieronder worden gegeven. Ik heb commentaarregels toegevoegd om de dingen veel beter uit te leggen.
Verwerkingsprogramma:
'Processing' is open source software die door kunstenaars wordt gebruikt voor grafisch ontwerpen. Deze software wordt gebruikt om software en Android-applicaties te ontwikkelen. Het is vrij eenvoudig te ontwikkelen en lijkt veel op de Android Development IDE. Daarom heb ik de uitleg ingekort.
De verwerkingscode voor beide chatschermen wordt hier gegeven:
- Chatscherm 1 Verwerkingscode
- Chatscherm 2 Verwerkingscode
Klik er met de rechtermuisknop op en klik op 'Link opslaan als…' om ze te downloaden en op uw computer te openen na het instellen van de Arduinos. U moet 'verwerkingssoftware' installeren om deze *.pde-bestanden te openen en ze vervolgens 'uitvoeren' om de chatboxen te openen. Het commentaargedeelte is open voor vragen. De verwerkingsschets voor zender- en ontvangermodule zijn identiek.
In het onderstaande codegedeelte is de "port = new Serial (this, Serial.list (), 9600); // Leest de 4e POORT met 9600 baudrate" belangrijk omdat het beslist van welke poort de gegevens vandaan komen.
leegte setup () {grootte (510.500); port = new Serial (this, Serial.list (), 9600); // Leest de 4e POORT op 9600 baudrate println (Serial.list ()); achtergrond (0); }
Hier heb ik gegevens van de 4e poort van mijn Arduino gelezen.
Dus bijvoorbeeld als je COM COM COM COM COM hebt
Vervolgens leest de bovenstaande code gegevens van COM.
Testen:
Nu onze Processing en Arduino-schets klaar is, uploadt u het programma naar Arduino en laat u het aangesloten op uw laptop. Open uw verwerkingsschets en begin met typen en druk op "Enter". Uw bericht wordt verzonden naar de andere Arduino die de ontvangen tekst zal weergeven op een andere verwerkingsapplicatie die is aangesloten op een andere computer. Bekijk de video hieronder verder voor een volledige demonstratie.
Dus dit is hoe u met uw vrienden en familie in uw omgeving kunt praten zonder enige internetverbinding, met behulp van deze goedkope Arduino Chat Room.