.. note::

    Hello, welcome to the SunFounder Raspberry Pi & Arduino & ESP32 Enthusiasts Community on Facebook! Dive deeper into Raspberry Pi, Arduino, and ESP32 with fellow enthusiasts.

    **Why Join?**

    - **Expert Support**: Solve post-sale issues and technical challenges with help from our community and team.
    - **Learn & Share**: Exchange tips and tutorials to enhance your skills.
    - **Exclusive Previews**: Get early access to new product announcements and sneak peeks.
    - **Special Discounts**: Enjoy exclusive discounts on our newest products.
    - **Festive Promotions and Giveaways**: Take part in giveaways and holiday promotions.

    👉 Ready to explore and create with us? Click [|link_sf_facebook|] and join today!

3.1.10 Alarm Bell
=====================

Introduction
-----------------

In this course, we will make a manual alarm device. You can replace the
toggle switch with a thermistor or a photosensitive sensor to make a
temperature alarm or a light alarm.

Components
---------------

.. image:: img/list_Alarm_Bell.png
    :align: center

Schematic Diagram
-------------------------

============ ======== ======== ===
T-Board Name physical wiringPi BCM
GPIO17       Pin 11   0        17
GPIO18       Pin 12   1        18
GPIO27       Pin 13   2        27
GPIO22       Pin 15   3        22
============ ======== ======== ===

.. image:: img/Schematic_three_one10.png
   :align: center

Experimental Procedures
-----------------------------

**Step 1**: Build the circuit.

.. image:: img/image266.png
   :width: 800

**For C Language Users**
^^^^^^^^^^^^^^^^^^^^^^^^^^

**Step 2**: Change directory.

.. raw:: html

   <run></run>

.. code-block:: 

    cd ~/davinci-kit-for-raspberry-pi/c/3.1.10/

**Step 3**: Compile.

.. raw:: html

   <run></run>

.. code-block::

    gcc 3.1.10_AlarmBell.c -lwiringPi -lpthread

**Step 4**: Run.

.. raw:: html

   <run></run>

.. code-block::

    sudo ./a.out

After the program starts, the toggle switch will be toggled to the
right, and the buzzer will give out alarm sounds. At the same time, the
red and green LEDs will flash at a certain frequency.

.. note::

    If it does not work after running, or there is an error prompt: \"wiringPi.h: No such file or directory\", please refer to :ref:`C code is not working?`.


**Code Explanation**

.. code-block:: c

    #include <pthread.h>

In this code, you'll use a new library, pthread.h, which is a set of
common thread libraries and can realize multithreading. We add the
**-lpthread** parameter at compile time for the independent working of
the LED and the buzzer.

.. code-block:: c

    void *ledWork(void *arg){       
        while(1)    
        {   
            if(flag==0){
                pthread_exit(NULL);
            }
            digitalWrite(ALedPin,HIGH);
            delay(500);
            digitalWrite(ALedPin,LOW);
            digitalWrite(BLedPin,HIGH);
            delay(500);
            digitalWrite(BLedPin,LOW);
        }
    }

The function ledWork() helps to set the working state of these 2 LEDs:
it keeps the green LED lighting up for 0.5s and then turns off;
similarly, keeps the red LED lighting up for 0.5s and then turns off.

.. code-block:: c

    void *buzzWork(void *arg){
        while(1)
        {
            if(flag==0){
                pthread_exit(NULL);
            }
            if((note>=800)||(note<=130)){
                pitch = -pitch;
            }
            note=note+pitch;
            softToneWrite(BeepPin,note);
            delay(10);
        }
    }

The function buzzWork() is used to set the working state of the buzzer.
Here we set the frequency as between 130 and 800, to accumulate or decay
at an interval of 20.

.. code-block:: c

    void on(){
        flag = 1;
        if(softToneCreate(BeepPin) == -1){
            printf("setup softTone failed !");
            return; 
        }    
        pthread_t tLed;     
        pthread_create(&tLed,NULL,ledWork,NULL);    
        pthread_t tBuzz;  
        pthread_create(&tBuzz,NULL,buzzWork,NULL);      
    }

In the function on():

1) Define the mark \"flag=1\", indicating the ending of the control
   thread.

2) Create a software-controlled tone pin **BeepPin**.

3) Create two separate threads so that the LED and the buzzer can work
   at the same time.

**pthread_t tLed:** Declare a thread **tLed**.

**pthread_create(&tLed,NULL,ledWork,NULL)：** Create the thread and its
prototype is as follows:

int pthread_create(pthread_t \*restrict tidp,const pthread_attr_t
\*restrict_attr,void*（*start_rtn)(void*),void \*restrict arg);

**Return the Value**

If successful, return \"**0**\"；otherwise, return the **fall number**
\"**-1**\".

**Parameter**

| The first parameter is a pointer to the thread identifier.
| The second one is used to set the thread attribute.
| The third one is the starting address of the thread running function.
| The last one is the one that runs the function.

.. code-block:: c

    void off(){
        flag = 0;
        softToneStop(BeepPin);
        digitalWrite(ALedPin,LOW);
        digitalWrite(BLedPin,LOW);
    }


The function Off() defines \"flag=0\" so as to exit the threads
**ledWork** and **BuzzWork** and then turn off the buzzer and the LED.

.. code-block:: c

    int main(){       
        setup(); 
        int lastState = 0;
        while(1){
            int currentState = digitalRead(switchPin);
            if ((currentState == 1)&&(lastState==0)){
                on();
            }
            else if((currentState == 0)&&(lastState==1)){
                off();
            }
            lastState=currentState;
        }
        return 0;
    }

Main() contains the whole process of the program: firstly read the value
of the slide switch; if the toggle switch is toggled to the right (the
reading is 1), the function on() is called, the buzzer is driven to emit
sounds and the the red and the green LEDs blink. Otherwise, the buzzer
and the LED don’t work.

**For Python Language Users**
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

**Step 2:** Change directory.

.. raw:: html

   <run></run>

.. code-block::

    cd ~/davinci-kit-for-raspberry-pi/python/

**Step 3:** Run.

.. raw:: html

   <run></run>

.. code-block::

    sudo python3 3.1.10_AlarmBell.py

After the program starts, the toggle switch will be toggled to the
right, and the buzzer will give out alarm sounds. At the same time, the
red and green LEDs will flash at a certain frequency.

**Code**

.. note::

    You can **Modify/Reset/Copy/Run/Stop** the code below. But before that, you need to go to  source code path like ``davinci-kit-for-raspberry-pi/python``. 
    
.. raw:: html

    <run></run>

.. code-block:: python

    import RPi.GPIO as GPIO
    import time
    import threading

    BeepPin=22
    ALedPin=17
    BLedPin=27
    switchPin=18

    Buzz=0
    flag =0
    note=150
    pitch=20

    def setup():
        GPIO.setmode(GPIO.BCM)
        GPIO.setup(BeepPin, GPIO.OUT)
        GPIO.setup(ALedPin,GPIO.OUT,initial=GPIO.LOW)
        GPIO.setup(BLedPin,GPIO.OUT,initial=GPIO.LOW)
        GPIO.setup(switchPin,GPIO.IN)
        global Buzz
        Buzz=GPIO.PWM(BeepPin,note)

    def ledWork():
        while flag:
            GPIO.output(ALedPin,GPIO.HIGH)
            time.sleep(0.5)
            GPIO.output(ALedPin,GPIO.LOW)
            GPIO.output(BLedPin,GPIO.HIGH)
            time.sleep(0.5)
            GPIO.output(BLedPin,GPIO.LOW)

    def buzzerWork():
        global pitch
        global note
        while flag:
            if note >= 800 or note <=130:
                pitch = -pitch
            note = note + pitch 
            Buzz.ChangeFrequency(note)
            time.sleep(0.01)


    def on():
        global flag
        flag = 1
        Buzz.start(50)
        tBuzz = threading.Thread(target=buzzerWork) 
        tBuzz.start()
        tLed = threading.Thread(target=ledWork) 
        tLed.start()    

    def off():
        global flag
        flag = 0
        Buzz.stop()
        GPIO.output(ALedPin,GPIO.LOW)
        GPIO.output(BLedPin,GPIO.LOW)      


    def main():
        lastState=0
        while True:
            currentState =GPIO.input(switchPin)
            if currentState == 1 and lastState == 0:
                on()
            elif currentState == 0 and lastState == 1:
                off()
            lastState=currentState

    
    def destroy():
        off()
        GPIO.cleanup()


    if __name__ == '__main__':
        setup()
        try:
            main()
        except KeyboardInterrupt:
            destroy()

**Code Explanation**

.. code-block:: python

    import threading

Here, we import the **Threading** module and it allows you to do
multiple things at once, while normal programs can only execute code
from top to bottom. With **Threading** modules, the LED and the buzzer
can work separately.

.. code-block:: python

    def ledWork():
        while flag:
            GPIO.output(ALedPin,GPIO.HIGH)
            time.sleep(0.5)
            GPIO.output(ALedPin,GPIO.LOW)
            GPIO.output(BLedPin,GPIO.HIGH)
            time.sleep(0.5)
            GPIO.output(BLedPin,GPIO.LOW)

The function ledWork() helps to set the working state of these 2 LEDs:
it keeps the green LED lighting up for 0.5s and then turns off;
similarly, keeps the red LED lighting up for 0.5s and then turns off.

.. code-block:: python

    def buzzerWork():
        global pitch
        global note
        while flag:
            if note >= 800 or note <=130:
                pitch = -pitch
            note = note + pitch 
            Buzz.ChangeFrequency(note)
            time.sleep(0.01)

The function buzzWork() is used to set the working state of the buzzer.
Here we set the frequency as between 130 and 800, to accumulate or decay
at an interval of 20.

.. code-block:: python

    def on():
        global flag
        flag = 1
        Buzz.start(50)
        tBuzz = threading.Thread(target=buzzerWork) 
        tBuzz.start()
        tLed = threading.Thread(target=ledWork) 
        tLed.start()  

In the function on():

1) Define the mark \"flag=1\", indicating the ending of the control
   thread.

2) Start the Buzz, and set the duty cycle to 50%.

3) Create **2** separate threads so that the LED and the buzzer can work
   at the same time.

   tBuzz = threading.Thread(target=buzzerWork) **:** Create the
   thread and its prototype is as follows:


class threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, \*, daemon=None)

Among the construction methods, the principal parameter is **target**,
we need to assign a callable object (here are the functions **ledWork**
and **BuzzWork** ) to **target**.

Next **start()** is called to start the thread object, ex.,
tBuzz.start() is used to start the newly installed tBuzz thread.

.. code-block:: python

    def off():
        global flag
        flag = 0
        Buzz.stop()
        GPIO.output(ALedPin,GPIO.LOW)
        GPIO.output(BLedPin,GPIO.LOW)

The function Off() defines \"flag=0\" so as to exit the threads
**ledWork** and **BuzzWork** and then turn off the buzzer and the LED.

.. code-block:: python

    def main():
        lastState=0
        while True:
            currentState =GPIO.input(switchPin)
            if currentState == 1 and lastState == 0:
                on()
            elif currentState == 0 and lastState == 1:
                off()
            lastState=currentState

Main() contains the whole process of the program: firstly read the value
of the slide switch; if the toggle switch is toggled to the right (the
reading is 1), the function on() is called, the buzzer is driven to emit
sounds and the the red and the green LEDs blink. Otherwise, the buzzer
and the LED don’t work.

Phenomenon Picture
------------------------

.. image:: img/image267.jpeg
   :align: center