Circuito campanello chiamata ufficio wireless

In questo post costruiremo un campanello di chiamata wireless per ufficio che può essere utilizzato per chiamare 6 diversi membri del personale dalla scrivania del capo / capo o qualche altro progetto divertente tipo campanello di chiamata per la tua casa.

Utilizzando il modulo nRF24L01 da 2,4 GHz

Costruiremo un semplice campanello per chiamate wireless utilizzando il modulo Arduino e nRF24L01 da 2,4 GHz, che può funzionare in casa o in ufficio senza intoppi o problemi di copertura.

Il circuito proposto può essere alimentato da un adattatore per smartphone da 5 V o da qualsiasi adattatore da 5 V economico che mantiene il circuito vivo e pronto a sentire la tua chiamata.

Diamo un'occhiata a una panoramica di Modulo nRF24L01 2,4 GHz .

Il chip sopra è chiamato modulo nRF24L01. È un circuito di comunicazione duplex (bidirezionale) progettato per microcontrollori e computer a scheda singola come Raspberry Pi.

Utilizza la frequenza di 2,4 GHz che è la banda ISM (banda industriale, scientifica e medica) è la stessa frequenza utilizzata nelle comunicazioni Wi-Fi.

Può trasmettere o ricevere dati alla velocità di 2 Mbps, ma in questo progetto la trasmissione e la ricezione sono limitate a 250 Kbps a causa dei requisiti di dati inferiori e l'abbassamento della velocità dei dati si tradurrà in una maggiore portata complessiva.

Consuma solo 12,3 mA al picco di trasmissione dei dati, il che rende il dispositivo adatto alla batteria. Utilizza il protocollo SPI per comunicare con il microcontrollore.

Ha un raggio di trasmissione / ricezione di 100 metri senza ostacoli intermedi e di circa 30 metri con qualche ostacolo.

Puoi trovare questo modulo su popolari siti di e-commerce, anche presso il tuo negozio di elettronica locale.

Nota: il modulo può funzionare da 1,9 a 3,6 V, il regolatore di bordo su Arduino può fornire 3,3 V per il modulo. Se colleghi il terminale Vcc di nRF24L01 a 5V dell'uscita di Arduino, ciò provocherà un malfunzionamento del modulo. Quindi bisogna fare attenzione.

Questa è la breve introduzione al modulo nRF24L01.

Esaminiamo i dettagli dello schema del circuito:

Il circuito del telecomando:

Il telecomando sarà con il capo o il capo dell'ufficio.

Il telecomando è costituito da Arduino nano tra l'altro è possibile utilizzare qualsiasi scheda Arduino, 6 pulsanti per far squillare sei diversi ricevitori, modulo nRF24L01 e un LED per riconoscere la pressione di un pulsante.

È possibile alimentarlo utilizzando una batteria da 9 V o un adattatore da 5 V. In caso di batteria, spegnere questo telecomando dopo la chiamata.

Ora diamo un'occhiata al codice. Prima di ciò è necessario scaricare il file della libreria solo dopo che il codice viene compilato.

Collegamento: github.com/nRF24/RF24.git

Codice per telecomando:

// --------- Program Developed by R.GIRISH / homemade-circuits. com -------//
#include
#include
RF24 radio(9, 10)
const byte address_1[6] = '00001'
const byte address_2[6] = '00002'
const byte address_3[6] = '00003'
const byte address_4[6] = '00004'
const byte address_5[6] = '00005'
const byte address_6[6] = '00006'
const int input_1 = A0
const int input_2 = A1
const int input_3 = A2
const int input_4 = A3
const int input_5 = A4
const int input_6 = A5
const int LED = 2
const char text[] = 'call'
void setup()
{
pinMode(input_1, INPUT)
pinMode(input_2, INPUT)
pinMode(input_3, INPUT)
pinMode(input_4, INPUT)
pinMode(input_5, INPUT)
pinMode(input_6, INPUT)
pinMode(LED, OUTPUT)
digitalWrite(input_1, HIGH)
digitalWrite(input_2, HIGH)
digitalWrite(input_3, HIGH)
digitalWrite(input_4, HIGH)
digitalWrite(input_5, HIGH)
digitalWrite(input_6, HIGH)
radio.begin()
radio.setChannel(100)
radio.setDataRate(RF24_250KBPS)
radio.setPALevel(RF24_PA_MAX)
radio.stopListening()
}
void loop()
{
if (digitalRead(input_1) == LOW)
{
radio.openWritingPipe(address_1)
radio.write(&text, sizeof(text))
digitalWrite(LED, HIGH)
delay(400)
digitalWrite(LED, LOW)
}
if (digitalRead(input_2) == LOW)
{
radio.openWritingPipe(address_2)
radio.write(&text, sizeof(text))
digitalWrite(LED, HIGH)
delay(400)
digitalWrite(LED, LOW)
}
if (digitalRead(input_3) == LOW)
{
radio.openWritingPipe(address_3)
radio.write(&text, sizeof(text))
digitalWrite(LED, HIGH)
delay(400)
digitalWrite(LED, LOW)
}
if (digitalRead(input_4) == LOW)
{
radio.openWritingPipe(address_4)
radio.write(&text, sizeof(text))
digitalWrite(LED, HIGH)
delay(400)
digitalWrite(LED, LOW)
}
if (digitalRead(input_5) == LOW)
{
radio.openWritingPipe(address_5)
radio.write(&text, sizeof(text))
digitalWrite(LED, HIGH)
delay(400)
digitalWrite(LED, LOW)
}
if (digitalRead(input_6) == LOW)
{
radio.openWritingPipe(address_6)
radio.write(&text, sizeof(text))
digitalWrite(LED, HIGH)
delay(400)
digitalWrite(LED, LOW)
}
}
// --------- Program Developed by R.GIRISH / homemade-circuits. com -------//

Questo conclude il telecomando / trasmettitore.

Ora guardiamo il ricevitore.

Il circuito del ricevitore:

NOTA: è possibile creare uno o sei ricevitori a seconda delle proprie esigenze.

Il ricevitore è costituito dalla scheda Arduino, dal modulo nRF24L01 e da un buzzer. A differenza del telecomando, il ricevitore dovrebbe essere alimentato da un adattatore 5V, in modo da non dipendere dalle batterie che si scaricheranno entro un paio di giorni.

Ora diamo un'occhiata al codice per il ricevitore:

Codice di programma per il ricevitore

// --------- Program Developed by R.GIRISH / homemade-circuits. com -------//
#include
#include
RF24 radio(9, 10)
const int buzzer = 2
char text[32] = ''
// ------- Change this ------- //
const byte address[6] = '00001'
// ------------- ------------ //
void setup()
{
Serial.begin(9600)
pinMode(buzzer, OUTPUT)
radio.begin()
radio.openReadingPipe(0, address)
radio.setChannel(100)
radio.setDataRate(RF24_250KBPS)
radio.setPALevel(RF24_PA_MAX)
radio.startListening()
}
void loop()
{
if (radio.available())
{
radio.read(&text, sizeof(text))
digitalWrite(buzzer, HIGH)
delay(1000)
digitalWrite(buzzer, LOW)
}
}
// --------- Program Developed by R.GIRISH / homemade-circuits. com -------//

NOTA:

Se hai intenzione di costruire più di un ricevitore per questo sistema di campanello di chiamata dell'ufficio, dovresti cambiare il valore menzionato nella successiva build del ricevitore e caricare il codice.

Per il primo ricevitore (non è necessario modificare nulla):

// ------- Cambia questo ------- //
const byte address [6] = '00001' e carica il codice.
// ------------- ------------ //

Per il secondo ricevitore (devi cambiare):
const byte address [6] = '00002' e carica il codice.

Per il terzo ricevitore (devi cambiare):
const byte address [6] = '00003' e carica il codice.

E così via …… .. fino a “00006” ovvero il sesto ricevitore.

Quando si preme 'S1' sul telecomando, il ricevitore con indirizzo '00001' risponderà / emetterà un ronzio.

Quando si preme 'S2' sul telecomando, il ricevitore con indirizzo '00002' risponderà / emetterà un ronzio.
E così via……

Questo conclude i dettagli del circuito del ricevitore.

Se hai altre domande, sentiti libero di esprimerle nella sezione commenti, proveremo a risponderti presto con una risposta