Thank you for being here for today's tutorial of our in-depth Raspberry Pi programming tutorial. The previous tutorial demonstrated the proper wiring of the photoresistor sensor to the GPIO pins. Finally, we learned how it might be included in a Python script for data collection and analysis needs. We also looked at the functions of each component in the circuit. However, I'll walk you through installing a Pi 4 Print Server in this guide. While installing the program is straightforward, setting it up so that a Windows network can locate the print server requires a little more effort. Rather than spending hundreds of dollars upgrading to a laser printer, you may easily upgrade your current USB printer to laser quality by installing a print server.
Because of this software, you no longer have to have the printer physically linked to a single computer, and you may place it wherever you choose and share it with as many computers as you like. In addition, it's a fantastic method of printer sharing that eliminates the need for a pricey tower computer to be on and active all the time. CUPS is the program we'll be using to make this happen. Common Unix Printing System, or CUPS, is the foundation of Linux printing applications. But, the program facilitates communication between your computer and printer. It would help if you visited available printing to verify that the CUPS printing software supports your printer model.
| Where To Buy? | ||||
|---|---|---|---|---|
| No. | Components | Distributor | Link To Buy | |
| 1 | Raspberry Pi 4 | Amazon | Buy Now | |
Raspberry Pi 4
Wi-Fi
USB Printer
Since the Raspberry Pi print server is included in the Debian Jessie distribution, setting it up is a breeze. In this lesson, I'll be using Raspbian, so if you're unfamiliar with it and would like to learn how to set it up, check out my guide on how to do so.
We must ensure the Raspberry Pi is up-to-date with the most recent software to get started. Just type in the appropriate instructions into the terminal to accomplish this.
sudo apt update
sudo apt upgrade
We can begin setting up the print software after the Pi 4 has been upgraded. Here, we will be setting up CUPS.
CUPS, short for Common Unix Printing System, is a printing system designed for computers running UNIX-like operating systems. The software transforms the host computer into a print server. A CUPS-enabled server may receive print jobs from various client devices, sort them, and send them to the correct printer for output. Conveniently, this program can handle the administration of your printers, whether they're linked locally through USB or remotely via the network. Using the terminal, enter the following command to install the software. Considering HP has CUPS that support its open source project, HP printers, in particular. Even if your specific printer model isn't listed as being directly supported by CUPS, you may still be able to find a compatible generic driver online that will get the job done. These links will take you to a list of CUPS-compatible printers.
sudo apt install cups
We still have some work to do after CUPS's installation is complete. The first step is to include the pi user in the lpadmin set of users. With this group, the pi user can manage CUPS settings without logging in as the superuser.
sudo usermod -a -G lpadmin pi
To make sure it functions properly on your home network, there is one more thing we must do to CUPS: make it available to every computer on your network. At this time, Cups is configured to refuse connections from addresses outside the local network. By entering the following two commands, we can make it listen to all incoming connections:
sudo cupsctl --remote-any
sudo systemctl restart cups
After this, any machine on the network can send prints to the Pi 4 print server. The following command can be used if you need to know your Raspberry Pi's local IP Address.
hostname -I
If you know your Raspberry Pi's IP address, you can use it to access the website at the address below. Be sure to replace "192.168.1.105" with your IP address.
We'll examine how to configure SAMBA so that Windows can find the Raspberry Pi print server. Furthermore, we will demonstrate how to install a printer using the CUPS interface.
A proper SAMBA configuration is required if you use your print server in conjunction with Windows. To get SAMBA up and running with the CUPS print drivers, we'll have to install it and tweak its settings.
First, check that SAMBA is installed; to do so, we can use the terminal's built-in install command. Just by typing this into the terminal, we can accomplish our goal.
sudo apt install samba
Now that SAMBA is installed on our Pi 4, we can access its config file and make some changes. The following command will cause the file to be opened in the nano text editor:
Sudo nano /etc/samba/smb.conf
Once the file has been opened, it must be scrolled to the end. To do this quickly, press the Control key plus the V key. The following lines should be added or edited once you reach the very end of the file. The file already contained the "[printers]" and "[print$]" sections; all I had to do was update the values to reflect the following.
[printers]
comment = All Printers
browseable = no
path = /var/spool/samba
printable = yes
guest ok = yes
read only = yes
create mask = 0700
[print$]
comment = Printer Drivers
path = /var/lib/samba/printers
browseable = yes
read only = no
guest ok = no
To save the file, hit CTRL+X, Y, and ENTER. SAMBA needs to be restarted to pick up the updated settings. The following command, when entered into the terminal, will restart SAMBA.
sudo systemctl restart smbd
It's easy to set up a printer using CUPS, but first, we need to open the program's graphical user interface. For the IP address of your Raspberry Pi, enter "hostname" into the terminal.
hostname -I
To access the IP configuration page for your Raspberry Pi, type the following into your web browser and enter the IP address you just jotted down. Replace "192.168.1.105" with your IP address when entering this address.
The following homepage is what you should see. Here, we'll go to "Administration" on the main menu.
You'll be directed to Cups's control panel when you click here. On this page, select the "Add Printer" option.
The "Add Printer" screen has been brought up, allowing us to choose the printer we wish to configure Cups with. That printer is a Canon MG2500 series machine. When you've made your print choices, click the "Continue" button.
Ensure the printer is turned on and plugged into the Raspberry Pi through a USB connection if it does not appear here. If your Raspberry Pi still doesn't show up, try restarting it while ensuring your printer is on and connected.
Choose your printer's model from the dropdown menu here. CUPS will automatically identify the printer model and install the appropriate driver when possible. However, this may only sometimes work, so you may need to sift through the list to locate the proper driver manually. Once you've double-checked everything and are pleased, click the "Add Printer" button.
After completing the steps on this screen, the printer will have been added successfully. Here, you can give it a name and a summary that mean whatever you choose. If you have more than one printer in your residence, specifying its location will make your life easier. If you want other computers to be able to use the printer, you must also turn on "Share This Printer." If everything looks good, hit the "Continue" button.
After finishing the printer setup process, you will see the screen shown in the image below. Several of the printer's more nuanced settings are accessible through this panel—the number of pages printed, the quality of the printout, and so forth.
Having finished setting up our Raspberry Pi print server, we will now discuss how to add it to Windows. Having SAMBA set up earlier in the course should make this step less painless.
Installing a CUPS printer on Windows requires selecting the driver that will allow Windows to communicate with and comprehend the printer. Launching "My Computer" or "This PC" and then clicking "network" in the left-hand navigation pane is a quick method to get to Windows' network page, where you can get started. When you get there, you should see a screen like the one below, where your Raspberry Pi's hostname (in my instance, RASPBERRYPI) is displayed. If you double-click your Raspberry Pi's share, it may prompt you to log in. If entering anything other than "enter" fails to log you in, try "pi."
The printers used with your Pi 4 print server should now be displayed on the screen. Select the printer you wish to use by double-clicking on it.
You'll see the cautionary message below if you try to double-click this. Select "OK" to proceed with the tutorial.
Select your printer brand on the left, and then select your printer model from the available drivers for that brand on the right. If your printer isn't listed here, you can identify its model online and install the necessary drivers. For me, that meant tracking down the Canon MG2500 series. When you've decided which printer to use, you may move forward by clicking the "Ok" button.
The procedure will now initiate a link to your printer. Select "Printer" > "Set as Default Printer" to make this the system's default printer.
Now that the printer has been installed on your computer, you can use it with any application that supports printing. By printing a test page, you may verify that the printer is configured correctly.
If you're having trouble printing a file, check to see if you've picked the correct printer driver in CUPS and Windows. Ensure the printer is turned on as well; the Canon MG2500 series, for example, do not immediately restart when a print job is delivered. Adding Apple AirPrint capability to your Pi 4 print server is a great way to expand its capabilities.
Apple's AirPrint printing technology eliminates the requirement for users of Apple products to acquire and install the separate printing software. By adding AirPrint functionality, you may quickly and effortlessly print from your iOS smartphone to any nearby printer. You can run an AirPrint server from your Raspberry Pi, and Cups is the software that will power it. It will take care of talking to your printer on your Raspberry Pi's behalf.
The "Avahi daemon" must be set up before AirPrint may be used on your computer. The following command will install the package onto your Raspberry Pi.
sudo apt install avahi-daemon
Using this package, you can make Apple's Zeroconf design a reality. Bonjour has become widely used to refer to this type of network architecture. Using Bonjour, AirPrint can link disparate gadgets like an iPhone and a Raspberry Pi. Once you've selected the files you'd like to print, the Bonjour daemon will forward them to the designated printer.
Let's restart the machine to see whether the AirPrint server has worked appropriately, and everything is ready. Execute this command to force the Raspberry Pi to restart.
sudo reboot
After rebooting your Raspberry Pi, you can check to see if anything went wrong. This should get you to the point where you can print from any AirPrint-enabled device.
Have you succeeded in following this guide and setting up a Pi 4 network print server? If you've followed these steps carefully, your Raspberry Pi should be ready to function as a network AirPrint server. We were able to accomplish this by putting the Avahi daemon in place. This daemon implements the bonjour protocol used by AirPrint. Feel free to leave a message below if you have any thoughts, suggestions, or problems you'd want to discuss. The following tutorial will review the steps for monitoring a patient's heart rate with a Raspberry Pi 4.
Hello students! Welcome to the new tutorial on Python. We all know that Python is one of the most popular programming languages, and there are hundreds or thousands of developers that are earning a handsome amount with the help of this easy programming language. In the previous lecture, we studied the range in the sequence, and in the present class, our concern is having the command on the sets in Python. We know you are curious about the set's details, but before this, I want to share the list of topics that will be covered in this class.
What is a set in the Python programming language?
What are some properties that distinguish the set from other data types?
What is the mutable data type, and how is it related to the set?
Introduction of the Jupyter notebook.
Can we have duplicate elements in the set?
How to add, remove, and update the elements in the set while using the Jupyter notebook.
How can we access the elements using a loop?
Give an example of how to use the length function with sets and why it is important.
All of these are important interview questions, and we will not only find the answer to them but also elaborate on them with the help of simple but understandable examples taken from daily life routines. Your duty is to perform each and every code, not only by copying it from the lecture but also test your knowledge and practising more and more by making your own examples.
Since the last few tutorials on Python, we have been studying a lot about the sequence, which is basically the representation of a collection of data types with homogeneity or heterogeneity in the elements. If we talk about the sets, these have the same properties and procedures as their other group, such as list and range, but a slight difference in their property makes them a different data type. This can be elaborated with the help of its basic definition:
“The set is the type of sequence that contains the group of different data types, and it is the collection of unordered or unindexed data types together.”
Until now, the sequence discussed had been represented exactly as it was written by the programmers in the code. Yet, in the sets, the order is not exactly the same all the time. If you are thinking it is strange, then you must know, in the higher level of programming, this property of the set works great because we get the elements in random orders.
Another difference between the set and the other sequences is the usage of the bracket, or, in other words, the declaration of the sequences. To tell the compiler that we want a set in the sequence, the programmers use curly brackets. You must have noticed that it is very rare to use curly brackets in Python, and therefore we can say that the representation of the set in Python is unique.
As we have a lot of information about the sequences, we can openly discuss the properties of the set, and the reader will easily understand them by comparing them with others. So, here are some of the properties that can be compared:
Sets are represented with curly brackets.
The elements of the set can not be duplicated; that is, all the elements are uniquely defined, and no element should be repeated; otherwise, the compiler will show the output in which the duplicate values are shown only once.
The set is a heterogeneous collection of elements, and therefore, the programmers can add one or more data types to a single set according to their choice.
The set can be empty, that is, declared with zero elements.
The set can be updated after its formation if the programmer wants to make some changes to it afterwards.
There are certain built-in functions of the set that, when used with the sets, have great applications in Python programming.
Each of these properties can be explained well with the help of TensorFlow. We have been using the Jupyter lab of TensorFlow since the start of this tutorial, and now, I want to tell you a better and more professional way to run the code with the help of TensorFlow. For this, you do not have to install any other software but the Jupter notebook already installed on your PC. Simply go to your search bar and run the Jupyter notebook. It will add a new tab with the label "home." Here, go to the “New” dialogue box and select Python 3. This will add the new project to a new tab. You can name it, but by default, it is named "untitled."
If you are practising all the codes with us by hand, you will observe that the Jupyter notebook has a better user experience, and it adds the ending of common syntaxes such as the double quotation and parentheses by itself when the programmer starts them. We will talk more about it in later lectures, but for now, we are moving towards the codes and properties.
The first thing that we want to revise here is the definition of mutable elements:
“In programming languages, mutable objects are those that are used to group different items and can change their value according to the instruction of the programmer.”
We have learned many mutable sequences, such as lists, and here, the point is to revise it to a set and not use the mutable sequences as the elements. Only data types such as strings, integers, etc. can be used as the elements in the set; otherwise, the programmer will face an error. This can be explained with the help of the code given below:
#Starting new list
myList=["Physics", "chemistry", "biology"]
#declaring a new set
mySet={myList,'a','e','i','o','u'}
print(mySet)
As a result, it is demonstrated that programmers can combine simple data types into sets, but it is not possible to create collections of mutable objects or collections of collections within sets.
In the properties, we have mentioned that the process of feeding the duplicate elements into the set is not useful because it checks for each and every element while providing the output, and if the element is being repeated, the sets ignore them. As a result, if we have the element more than once in our input, the number of elements in the input and output are not the same.
#Declaring the set
MySet={21,23.6,55,'Peach', 'Almond', 23.6,21,'Almond'}
#using iteration to print the set
for item in MySet:
print(item, end=" ")
print()
#calculating the length
length=len(MySet)
print('Numbers of elements = ',length)
This property will be more clear with the help of the following screenshot:
Hence, out of eight elements, the two duplicate elements are removed by the compiler, and we only get five elements that were calculated by the length function.
This is an interesting method that is compatible with the set in Python. Consider the situation where the programmer has declared a set and then needs to add an element to the same pre-defined set. In such cases, the addition method is useful, with the help of which the programmer simply uses the syntax of the add method and there is no need to recreate the whole set again.
NameOfSet.add(element to be added)
If the question arises about the position of the element, this will be clear with the help of an example that we are going to check:
#Initializing the set
mySet={'eggs', 'bread', 'jam',23,67,132,55}
print('Elements of my set is= ', mySet)
#adding a new element
mySet.add("oats")
#printing the set with the added element
print('Elements of my set with new element= ', mySet)
Keep the scenario in your mind that we have discussed above, but this time, there is a need to remove the lament from the set, and for this, Python has another method that simply searches for the required element from the set and removes it. Afterwards, the results can be printed on the screen to check whether the task is complete or not. The keyword to remove the element is "discard,” and it is used in the same way as the add keyword.
#Initializing the set
mySet={'eggs', 'bread', 'oat','jam',23,67,132,55}
print('Elements of my set is= ', mySet)
#removing the element "oat"
removeValue=mySet.discard('oat')
#printing the set with the removed element
print('Elements of my set with discarded element= ', mySet)
So, the removal process is also very simple and understandable but the syntax must be kept in mind and before using the final set in this case, always check for the results by printing the elements on the screen as we are doing here because a little mistake on the syntax results in no removal and it may cause the problem in the code. So it is a good practice to have an eye on the elements.
The updating process of the set may include different types of updates, such as increasing the size or changing the elements' sizes. For a better understanding, the best way is to learn how two or more sets can be merged into one large set. In the previous lectures, we have seen this type of process where merging is done with the help of a method. To discuss a new method with you, here we are using the update method. The process and syntax are the same as we have seen in the previous two methods.
setToBeAdded.update(setToBeUpdated)
As a result, the final set has elements from both of these sets. But it is important to notice that both sets have to be declared first, and in the third step, we get the merged or updated search with the help of the command given above.
#Initializing the first set
myFirstSet={'eggs', 'bread', 'oat', 'jam',23,67,132,55}
print('Elements of first set is= ', myFirstSet)
#Initializing the second set
mySecondSet={'Python', 'Java', 'C++'}
print('Elements of second set is= ', mySecondSet)
#Updating the sets
myFirstSet.update(mySecondSet)
#printing the final set
print('Elements of final set= ', myFirstSet)
Hence both of these are merged together and as we are using the sets, the order of the final set is different and unarranged. Well, it is a good practice to check for the numbers of elements using the length function all the time.
We hope by now you have an idea of the for loop and how we use it with different data types in Python. Similar to the list, the programmers can access each and every element with the help of iterations (loops). So, let us review the elements of a set with the help of the for loop.
#declaring our set with the name to-do list.
ToDoList={'assignment', 'coding', 'prayer', 'washing cloths', 'doing dishes'}
#starting for loop
for work in ToDoList:
print(work, end=" ")
If we look at the output, we get the following results:
Hence, it was an interesting tutorial on the sets where we learned a lot about the topic and the details were interesting and related to our daily life. At the start, we saw the basic definition and a brief introduction to the topic. We have seen some properties of the sets that were resembling the types of sequences but these were also different in many ways and we not only studied them in detail but practically proved them in the Jupyter notebook. It was nice to use the Jupyter notebook that we are going to use onward in this series. In the next tutorial, we will put light on some other features so stay tuned with us because we are preparing our next lecture on Python.
Hey peeps! Welcome to the new lecture on the sequence data type, where we are discussing the range data type. We are interested in working on deep learning, and for this, we are learning the Python programming language from scratch. If we talk about the previous episode, we saw the byte and byte array methods that were amazing for converting the different data types into bytes. The current lecture will discuss the range data type, which is slightly different from the other types of sequences, so students will learn new and interesting concepts in the lecture; however, before we get into the details of our topic, take a look at today's highlights:
What is the range function?
How can you elaborate on the syntax of the range function in detail?
What are the three types of range functions?
Give us some examples of range functions in Python.
What are some basic questions the answer of which should be kept in mind while using the range function?
The answer to each question above will be provided before the end of this lecture. All the examples will be tried on TensorFlow for better understanding.
The range is a type of sequence in the data type that also represents the group or collection of the items together in different ways, just like other types of sequences. It is also the built-in function in Python, and while using it, the programmer gets the range object. The range is one of my favorite data types because it is easy to use and, in just a few simple steps, it provides us with the sequence of the integers according to our choice. Usually, the loops play an important role while dealing with the range function. Right now, as we have not learned about loops, you will simply have an idea of the workings and output of this data type.
The good thing about using the range function is that, unlike loops, the programmer does not have to use the logic behind the series but just has to put the values in the range function, and the results are great. Keep in mind that the range function is used with the loops, and there is less versatility in the range function when compared with the simple logical loops, but for basic workings, it is important to learn about the range, and this function is great.
The syntax of the range function is also easy, just like its group mates. You have to know about the three parameters and will determine all of them according to your requirements:
MyRange=range(start,stop,step):
for i in range(MyRange)
print(i)
Here, the semicolon at the end indicates that the syntax of the range function is complete, and the compiler now has to calculate the range arguments. Furthermore, if the programmer wants the result to appear on the same line as the interval, he can add end=" " at the end of the print. In this way, the compiler will not jump to the next line, but the results will be printed on the same line with a space between each element. Of course, the programmer has to save the result of the range function into a variable so that it can be used in the other functions. But here, it is important to mention that all of these parameters are not compulsory, but the range function gives you the independence to use one, two, or three of them.
The for loop is the iteration in the programming languages and you will learn them in detail in the coming lectures but for now, keep in mind that the range function alone can not do anything but it is fed into the for loop so that compiler can work on the iterations. The variable (usually i) is used in this loop and the results of the range function are input in this loop.
Another thing that must be mentioned here is the programmer has to choose the number of arguments according to the complexity of the series of numbers he or she wants. So here are the details of each case:
This is the most basic type of range function, in which the programmer simply specifies the point where the compiler has to stop making the range series. In all types of range functions, there is always a need for a stop parameter. Three things are to be mentioned here:
By default, the range starts at zero, and if the user does not have any particular choice for the start, the range function can be used with the only stop parameter.
Only whole numbers are printed on the screen.
The stop number, which is the limit of the range function, will not be printed on the screen.
When you put this value equal to zero, the result will be an empty range and you will get nothing.
for i in range(3):
print(i,end=" ")
Just think about the case where the default value, which is zero, is not to be used. Instead, the programmer has the option of printing the series of numbers without missing any of them and then specifying the start and stop ranges in the range function. But, as in the previous case, the stop number will not be printed on the screen, so you have to give the range of stops that you do not want on the screen, but the number before it is required there.
for i in range(3,34):
print(i,end=" ")
The third function, as expected, is the complete range function, into which the programmer feeds another step parameter. With the help of this, the programmers are able to get the series of numbers that starts from the point they want and have uniform intervals between the numbers and the ending point that is expected by the number. In short, the whole series is under the control of the programmer, but you have to notice that the steps are always uniform. The step function must not be zero and you will get the reason for this statement soon in this lecture. We can put the step value in the code discussed above and in this way, if 2 is the step value, the programmers will have half of the series as given above.
for i in range(3,34,2):
print(i,end=" ")
Here comes the action because, till now, the examples you have seen are simple examples with a simple series, but now, we are dealing with some exceptional cases that will clear some related concepts in your mind. We have divided the examples into some questions, and we will try to get the answers with the help of codes:
Till now, integers are being used in the range function but we know that integers and floats are the two most related data types and will try to attempt the range function with the help of floating values as the parameters.
for i in range(3.5,77):
print(i,end=" ")
As you can see, the compiler is throwing the error that it is not possible to use the float in the range function because it is designed only for integers. The same program will run when you remove the decimal part from the first value, which is the starting point.
Let me tell you the interesting way to get the range series with the help of inter tool chain method. But before this, you have to look at the basic definition of this tool.
“The iter-tool iterator is the pre-define module in python that provides the complex applications of the iteration in simple ways. The methods are defined in this module, and the programmers have to import them before using them.”
So, the chain method is also saved in this method, and when the programmers need to use them in a different way, they simply use the import keyword and use it in programs. As we are dealing with the range function, the iter-tool chain function is used to connect the results of two or more results in the form of a single series. Have a look at the code given next, and then read this paragraph again to get the point.
#import the chain method from the iter-tool library
from itertools import chain
# Printing two methods in a row
print("Concatenating the result")
MyChain = chain(range(4,7), range(34,55,2))
#using the method in the range
for i in MyChain:
print(i, end=" ")
The extraction of the concepts used in this program:
We can import the chain method from the library of itertools that have the iteration tools in it.
To import the method, we use from and import keywords that are represented with the green bold colour in the program.
Concatenation is the process of connecting two or more data types into a single line.
When using concatenation, the for loop is used by making a variable and saving the results of two connected ranges together in the variable.
The independence to use the number of arguments between one to three is the same in the concatenation as in all cases.
In the for loop, when using concatenation, only a variable is used.
The other way to get the same results is by using both ranges with the for loop, but the code will not be very clear in that case.
If the programmer wants to get the results in column form, he or she can simply delete the “end” part in the code.
The simple answer to the question is yes, and when we go into the details, the range function simply gets the indexes the programmer wants and can provide them with the single values they require. In simple words, the programmer tells the range function its stop value, and it assumes the whole series and picks the one number demanded by the programmer. The stop range is described in parentheses when the index to be picked is mentioned in the square bracelets.
#Give the range and pick the element through the index
MyRange = range(5)[2]
print("3rd element out of 5 =", MyRange)
print()
MyRange = range(3,34)[23]
print("23rd element of this range with start and stop value =", MyRange)
print()
MyRange = range(28)[5]
print("5th element of this range with start, stop, and step value =", MyRange)
Hence, the programmer can make a range of choices and then pick one element.
During the discussion of step, we saw the basic discussion of the step argument but keep in mind, if the programmer does not want the step function, he can simply ignore it. There is not need to input the step function as zero because, in such cases, the error will be shown on the screen.
for i in range(3,23,0):
print(i,end=" ")
Hence, from the above code, it is clear that the range of the stop argument is always greater than zero. Moreover, in the same code, if the value of the step argument is greater than the stop argument, it just shows the starting point of the range and does not give the other values or any errors because logically, it is true.
Truss, in this lecture, we saw many interesting concepts about the type of sequence called range function. This is a pre-defined function that is used to represent the group of numbers, and we can control the starting, ending, and interval values between the series of this number according to our wishes. This is always used with the for loop, and different cases of range functions were discussed in this lecture. Stay with us for more Python tutorials.
Hello friends, I hope you all are doing great. Today, we are going to start Section-III of our Raspberry Pi 4 Programming Course. In this section, we will interface different Embedded Sensors with Raspberry Pi 4. Today's our first lecture in Section-III, so I am going to interface a simple LDR sensor with RPi4.
So, let's get started:
The following items are required to finish this Raspberry Pi photoresistor module guide. You don't need a breadboard to accomplish this, but having one would be helpful.
It is a common practice to employ photoresistors to determine the presence or absence of visible light or to quantify the amount of light hitting a particular surface. Their resistance is exceptionally high in the dark, reaching up to 1M ohm, but when subjected to light, the LDR sensor's resistance reduces rapidly, often to only a few ohms. Light-dependent resistors (LDRs) are nonlinear devices whose sensitivity shifts depending on the incident wavelength of light. To protect their ecosystems, some nations have outlawed the use of lead and cadmium in LDRs.
By analyzing the electromagnetic radiation in the "Infrared", "Visible" and "Ultraviolet" regions of the electromagnetic spectrum, Light Sensors can produce an output signal indicative of the brightness of the surrounding light. A passive device called a light sensor transforms this "light energy," which can come from either the visible or infrared regions of the spectrum, into an electrical signal. Because they convert the energy of light (photons) into a usable form of electricity, light sensors are also referred to as photoelectric devices or photo sensors (electrons).
There are two primary types of photoelectric devices: those that produce electricity when exposed to light (photovoltaics, photoemissive, etc.) and those that modify their electrical properties when exposed to light (photoresistors, photoconductors, etc.).
The light-dependent resistor (LDR) sensor is used to detect the intensity of light in the surroundings. The LDR is a device constructed from a sensitive semiconductor material i.e. cadmium sulfide, which undergoes a dramatic shift in electrical resistance when exposed to light, going from several 1000 Ohms in the dark to just a few Ohms, when illuminated.
Most photoresistive light sensors employ cadmium sulfide(CdS). However, other semiconductor substrate materials like lead sulfide (PbS), lead selenide (PbSe), and indium antimony (InSb) can detect light intensity as well. Since cadmium sulfide has a spectral response curve similar to the human eye's and can be modulated with a handheld torch, it is utilized to create photoconductive cells. The peak wavelength at which it is most sensitive is typically between 560-600nm (nanometers), making it part of the visible spectrum.
The ORP12 cadmium sulfide photoconductive cell is the most widely used photoresistive light sensor. This photosensitive resistor's spectral response is concentrated around 610 nm in the yellow-to-orange part of the spectrum. When the cell is in the dark, its resistance is extremely high at around 10M's, but it drops to about 100's when illuminated (lit resistance). As the resistive path zigzags across the ceramic substrate, the dark resistance increases and the dark current drops. Because of its low price and wide range of possible applications, the CdS photocell is frequently used in auto-dimming systems, light- and dark-sensing controls for streetlights, and photographic exposure meters.
Below is an illustration of how a light-dependent resistor can be used as a light-sensitive switch.
This simple circuit for detecting light consists of a relay activated by exposure to sunlight. The photoresistor LDR and the resistor R1 make up a potential divider circuit. In the absence of light, the LDR's resistance rises into the Megaohm (M) range, and as a result, the transistor TR1 receives zero base bias, turning the relay off. The LDR's resistance drops in response to more light, elevating the base bias voltage at V1. When the base bias voltage of transistor TR1 reaches a certain threshold, as defined by the resistance R1 in a potential divider network, the transistor turns "ON," activating the relay, which controls some external circuitry. With a return to darkness, the LDR's resistance rises, reducing the transistor's base voltage and turning "OFF" the transistor and relay at a predetermined level of illumination established by the potentiometer circuit.
Changing the relay's "ON" or "OFF" point to a custom brightness is as simple as swapping out the fixed resistor R1 for a potentiometer VR1. The switching end of a simple circuit like the one depicted above may need to be more consistent owing to fluctuations in temperature or supply voltage. Using the LDR in a "Wheatstone Bridge" configuration and substituting an Operational Amplifier for the transistor makes it simple to construct a light-activated circuit with increased sensitivity.
To build the circuit of the LDR sensor with RPi4, follow these instructions. You can also refer to the
below
circuit diagram:
Now is the time to start writing Python code for LDR:
This project's code is simple and will let us know whether it's bright outside, partly cloudy, or overcast. The lack of analog inputs on the Pi is the primary limitation of this device. So far, we have only worked on the digital modules, but here we need an analog pin to get a reliable reading of the input resistance variation. So, we'll count how long the capacitor takes to recharge and then set the pin high. This is a quick but unreliable way to gauge the ambient light level.
Here I will quickly go over the code for the LDR sensor with Raspberry Pi. As a first step toward establishing a connection with the GPIO pins, we import the necessary GPIO package. The time package is also imported, allowing us to schedule script inactivity.
#!/user/local/bin/python
import RPi.GPIO as GPIO
import time
Next, we change the GPIO modes to GPIO.BOARD so that the pins used in the script match the hardware. One variable only needs to be set because there is just one input/output pin. If you use a specific GPIO pin, assign its number to this variable.
GPIO.setmode(GPIO.BOARD)
#define the pin that goes to the circuit
pin_to_circuit = 7
The following function we'll look at is RC time, and it takes a single input: the circuit's PIN. In this code, we set the value of a variable named count to zero, and then, when the pin is set to high, we return that number. Our pin is then configured as an output before being brought low. Then we let the program rest for ten milliseconds. When this is done, the pin is converted to an input, and a while loop is started. In this loop, the capacitor is charged until it is around 3/4 full, at which point the pin swings high. Once the pin is set to high, we send the count back to the primary method. This number can be used to toggle an LED, trigger an action, or be stored to compile data on brightness fluctuations.
def rc_time (pin_to_circuit):
count = 0
#Output on the pin for
GPIO.setup(pin_to_circuit, GPIO.OUT)
GPIO.output(pin_to_circuit, GPIO.LOW)
time.sleep(0.1)
#Change the pin back to the input
GPIO.setup(pin_to_circuit, GPIO.IN)
#Count until the pin goes high
while (GPIO.input(pin_to_circuit) == GPIO.LOW):
count += 1
return count
#Catch when the script is interrupted, clean it up correctly
Try:
# Main loop
while True:
print(rc_time(pin_to_circuit))
except KeyboardInterrupt:
pass
finally:
GPIO.cleanup()
Even though this is a trivial procedure, I'll run through it fast so you can get it up and work on your Pi without any hiccups. I am employing Raspbian, the operating system used in all the guides here. Read my Raspbian installation instructions if you need assistance. In most circumstances, all the necessary software will already be installed. Using git clone, the source code can be downloaded. Here's a command that will carry out your request.
git clone https://github.com/pimylifeup/Light_Sensor/
cd ./Light_Sensor
The code can also be copied and pasted, but only into a Python script. When working with Python code, my preferred text editor is nano.
sudo nano light_sensor.py
To save your changes and leave the file, press CTRL+X then Y. Finally, the following command will execute the code.
sudo python light_sensor.py
Hopefully, you've fixed the script and are now getting readings that accurately reflect the light levels on the sensor. Be bold about posting a comment if you need help.
A light sensor can be implemented in a variety of circuitry contexts. Some that sprang to mind when I was penning this guide are as follows:
An LDR can detect the onset of daylight, allowing for the activation of an alarm to rouse you from sleep. With a reliable program and sensor, you may set the alarm to increase in volume as daylight fades gradually. One way to keep tabs on your garden is to use a light sensor to measure how much sun each section of your garden is getting. This could be helpful knowledge if you're planting anything that needs a lot of sun or vice versa. Using the Room Monitor, you can ensure the lights in a particular room are switched off whenever no one is there. This might be set up to send you an alert if the light is found in an unexpected place.
This fantastic sensor has a wide variety of applications. However, if you need something more precise than a photocell, consider the Adafruit dynamic range sensor. You had no trouble installing this light sensor on your Raspberry Pi. Please comment below if you have any issues or suggestions or think I need to include something. In the next section, we'll see how to interface a Soil Moisture Sensor with Raspberry Pi 4. Till then, take care. Have fun!!!
Modern digital business needs reliable feature flag management. You probably already know that since you're here reading this article. Read it in full, then, and discover what to expect from a real-deal feature management software your company can most certainly benefit from.
Feature flags, also known as feature toggles, are a software development best practice that enables developers to safely and rapidly roll out new features in production. Feature flags provide teams with the ability to easily turn features on or off without having to deploy new code. This allows teams to quickly develop, deploy, and run experiments on their application while minimizing the risk of an unstable deployment. Feature flags can also be used to enable A/B testing and canary releases.
Releasing new features confidently is a goal. Many development companies aim at it, but at the same time they want to avoid a crisis that usually comes from bad execution of new ideas. Any software can be ruined by a single update, you know. What's more, modern consumers will not hesitate to ditch a product with faulty functionality. Restoring confidence is sometimes more difficult than building an app from the scratch. That's why the digital industry must be cautious. Luckily, a pro feature management tool can reduce the risk by providing means for delivering new features available to users selectively and with a certain amount of subtlety.
The above allows test execution, including A and B testing. Different user segments provide responds that are often negative, but they are valuable. Smart feature deployment is all about getting the data from the user-side, making adjustments without a massive crisis in case of a failure. This is why a good feature management software is an essential investment for any serious company from the digital industry.
There are many feature management tools out there, but not all of them are actually worth their price tags. The thing is, it must be a comprehensive product. Feature releases can become a complicated process, especially when software development teams work on large projects that consist of layers upon layers of code. It is not unusual these days that a digital endeavor is, in fact, a cluster of products cooperating with each other. Therefore, truly the best feature management software ought to provide an ability to control all these processes. A surprisingly cheap or even free feature flagging platform will be limited to basics only. Basics, however, are not enough nowadays.
Reliability is crucial, of course. Complex feature release management mustn't be based on unstable solutions. An experimental feature itself has a right to be faulty, but a tool that delivers it must be tough as nails. So, where to find professionally complete and reliable feature flagging software? Try this address for starters: https://www.getunleash.io/feature-management.
If you plan to run a start-up, it helps to have some basic understanding of IT management. Here are some key pointers on how best to manage your business IT systems:
You should know how your IT systems work and how they can be managed. This will help you keep them working well, which is especially important if your business depends on them for important functions like payroll or customer service. The earlier in the process that someone understands their role and responsibilities in running the company's technology, the better off they'll be when troubleshooting problems arise later on down the road.
Make sure your hardware and software are secure.
Ensure that you have the right licenses for your software.
Use cloud storage for your data security and recovery.
Conduct regular backups using your cloud system or external hard drive
Use a firewall to protect your network from unauthorized access.
Install antivirus, anti-spyware and anti-malware software on each computer (and smartphone) in the organization so that all data can be protected from outside threats.
Cloud storage is one of the best ways to store your data in a secure, accessible and reliable way. Further, Cloud storage makes it easy to access your files from anywhere and at any time. It reduces costs because you don’t need to buy or maintain expensive hard drives, which means that you can save up money for other things like marketing materials or new equipment.
Cloud storage also has some great benefits: like It keeps your information safe from hackers who might want access to it so that they can steal it or sell it on black market sites.
It's important to have a backup of your company's data , which is why you'll need to take steps to ensure that it doesn't get lost or damaged. The most basic way of backing up your files is by using an external hard drive or USB. If you're using the cloud system provided by your hosting provider, then there is also an option for automatic backups (but this might not be suitable for all businesses).
You should also keep in mind that not all kinds of information will fit onto one computer file—for example, some documents contain links between multiple pages; others have embedded images that could be lost if they weren't backed up before being deleted from their original source material.
If you need help with an IT issue or have technical questions, it is essential to get it resolved quickly. This can be a time-consuming process and require specialist skills that many startups don't have in-house.
It's also important to keep your business running smoothly as well as making sure that any problems are dealt with promptly by the right people at the right time (and not just left until later). While hiring an IT expert may seem like a great idea at first glance—especially if they're willing to offer their services for free—it's more likely that you will end up spending more money than you would have had by using other options.
It's important to understand how your IT systems work, so that you know what services you need from providers and how to keep them working well. This will allow you to make informed decisions about what kind of support is required in the future. If a provider offers a specific service or product, then it might be worth considering whether this meets your needs rather than buying something else that does not meet those needs directly. For this purpose you can use different IP for different locations to get best advantages from expertise. You can also use IP from Saudi Arabia to check
any issue regarding IT management if your clients are based in UK or USA. You can also hire expertise from these locations too.
Because If there are any areas where an expert could help with advice or training then this would also be beneficial for both parties involved - especially if there are technical problems with one part of the system which could be fixed by someone who has experience with similar systems elsewhere.
If you are planning to run a start-up, it helps to have a basic understanding of IT management. Make sure your hardware and software are secure, use cloud storage for your data security and recovery, get IT support when you need it - both for advice and for technical issues. This is absolutely essential if you’re not an IT expert yourself.
Hey pupils! Welcome to the new tutorial on deep learning, where we are in the section on Python learning. In the previous lecture, we were discussing the tuple data type, which is a sub-class of sequences. In the present lecture, the discussion will be about the byte sequence and byte array. The whole discussion is cleared with the help of practical implementation in TensorFlow by using simple and easy codes. If you understand the concepts of list and tuple, then this lecture will be easy for you. Yet, before going into the details of this topic, you must know the highlights of the content discussed in this lecture:
What is the byte method in Python?
How can you use byte in TensorFlow?
What are some examples of bytes?
Give examples of error handling in bytes.
How can you convert integers into bytes?
What is a byte array?
What is the difference between bytes and byte array methods?
Moving towards our next sequence is the byte method which has interesting applications in Python programming. A byte is the collection or group of byte numbers and it can hold multiple values. The interesting thing about the byte is, these can not hold the negative numbers that are, the values in a byte can not have the minus sign with them. One must keep in mind that these have a range between 0 and 255 only and you can not store more or fewer values than this range. For example, if you want to add 267 or -56 in a byte, this is not possible in it. The main purpose of using this function is to convert an object into an immutable byte-represented object of which, the data and size are specified by the programmer.
To make sure you are getting the whole concept, let us practice it on TensorFlow. To start, have a look at the instructions:
Search for the “Anaconda Navigator” in your windows search panel.
In the environment section, search for the Jupyter Lab.
Launch the lab and wait for the browser to show you the local host on your browser.
Go to the new cell and start coding.
You have seen we made a byte with the different types of elements in it. Now, what if we made the byte with values that exceed its values? Let us check it with the help of the following code:
The byte is a method and to use it well, the syntax must be known. For using it, there must be three parameters that have to be decided before starting, the detail of syntax and the parameters is given next:
byte(src,enc,err)
Here, the three parameters are defined:
src=The object that has to be converted. It is the source object and has superficial characteristics.
enc= it is the encoding that is used only when the case object used in the formula is in the form of a string.
err=If the error occurs during the conversion of the string is not done properly in the step mentioned before then, the logic given here will be used to overcome this error.
Now, using the information given above, we are going to discuss the example to elaborate on the whole process. The bytes when displayed on the output have a small be with them to show it is a byte. Just look at the code below and we are going to tell you the detail after that.
msg = "We are learning Python"
string = bytes(msg, 'utf-8')
print(string)
Here, in the first line, the message is declared and stored in the variable with the name ‘msg’.
The byte function is used in the second line and as the two parameters, we are using the message declared first as the source and the encoding technique is the utf-8.
The result of this function is then stored in the variable ‘string’.
The results are printed at the end. The small b at the start of this message indicates that it is a byte and single quotation marks are the indication that our result is a string.
Here, utf-8 is the indication of the Unicode transformation format, and it is encoding the string into an 8-bit character. So, in conclusion, we can say that a byte is used to convert the string message into an 8-bit character string. The application of the byte function is at a higher level of programming.
Now moving towards the next example, let us check for a relatively large code. This code gives us a demonstration of how we can use different cases of coding in a single piece of code and we will use here the empty byte, number-to-byte conversion, and list-to-byte conversion using single lines.
num = 4
list = [23,76,23,78,34]
#conversion with no argument
print ("Byte conversion with no arguments : ", (bytes()))
# conversion of number into string
print ("The integer conversion results in : ", (bytes(num)))
# conversion of list into string
print ("The iterable conversion results in : " , (bytes(list)))
The number is converted into bytes as expected, and when we try the same method for the list, where a group of numbers are to be converted into bytes, this function is capable of doing so. The output is strange for the non-programmers but the conversion is perfect here.
As we have mentioned earlier, the string is converted with the help of the byte function, but error correction is important in this case. There are some keywords that are suggested as error correction techniques. All of these will be discussed in the next section.
The second parameter of the byte tells us that we have to provide the encoding scheme, but what if the encoding process is not completed due to some error? The method parameter specifies the way to handle that error, and there is more than one way to handle it; therefore, here are the details of each way to handle the error for you. Keep in mind, coding is a vast field and the whole control is in the hand of programmers. Thus, not all errors are handled with the same kind of solution, so you must know all the ways.
The first error handler on the list is the "strict" keyword. It is used when the programmer wants to get the Unicode decoder error when the compiler is not able to convert the string into a byte.
The second error handler in the list is the keyword “ignore." What do you do when any procedure is not under your control and you are not able to do your duty? In the case of the compiler's workings, when it is faced with the same situation, it ignores the part with the error and moves towards the next line. In this way, the result obtained is not complete, but you get the answer to other parts of the code. It works great in many situations, and sometimes, you get interesting outputs.
The third one has a nice implementation of error handling. With the help of this handler, the error that occurred in the string will be replaced by a question mark, and then the compiler will move towards the next character. In short, the error will be gone, and instead of skipping the error, there will be a question mark that will indicate the error.
All the discussions above will be cleared up with the help of the code given in the next line. The error in all the problems is the same, but the outputs—or, in short, the way the compiler deals with the error—are changed.
#Declaring the variable with the string having the error in it.
MyString = 'PythonfÖrDeepLearning'
# using replace error Handling
print("Byte conversion with replace error : " +
str(bytes(MyString, 'ascii', errors='replace')))
# Giving ascii encoding and ignore error
print("Byte conversion with ignore error : " +
str(bytes(MyString, 'ascii', errors='ignore')))
#using strict error Handling
print("Byte conversion with strict error : " +
(bytes(MyString, 'ascii', errors='strict')))
Here, when we talk about the “strict” error handler, we get this error with the pink box because it is just like a simple error, as we are calling it, and we want strict action behind the error. Moreover, in the other two lines of code, the output is a little bit different, as the description tells us.
The conversion of bytes does not end here; instead, it has other conversion techniques as well. Python gives programmers the ease of converting integers into bytes, but it is, somehow, a little bit easier than string conversion because it is a pre-defined function and you just have to insert the values accordingly.
int.from_bytes(bytes, byteorder, *, signed=False)
In the syntax given above, three things are to be noticed;
It is the byte object that has to be converted into an integer.
This function determines the order in which the integer value is represented. The value of byte order can be "little," which stores the most significant bit at the end and the least significant bit at the beginning, or "big," which stores the MSB at the beginning and the LSB at the end. Big byte ordering computes an integer's value in base 256.
By default, the value of this parameter is false, and it indicates whether you want to get the 2’s complement of the value or not.
To understand the bytes well, you have to know first that Python is an object-oriented programming language; therefore, it works by creating objects from different pieces of code. While working with the byte function, an immutable byte object is formed. The size of this immutable sequence is just as large as an integer that ranges from 0 to 254, and it prints the ASCII characters. It is a Python built-in function that has many interesting applications in a simple manner. As with the other types of sequences, tuples also contain a number of items, but they can also be empty. The only conditions are that the data should be enclosed in parentheses and the elements should be separated with commas. Another important piece of information about this data type is that it cannot be changed once you have declared it.
As the name of this data type resembles the previous one, both structure and information are also similar. Byte arrays also have the parentheses representation, and you can use different data types in them, but the only difference between the byte array and the simple byte in the sequence is that the former is immutable, and you can change the size of the byte array after you declare it in Python. It makes the byte arrays more useful than the simple bytes in the sequence.
The reason why we are discussing both of these data types here is, there is only a slight difference between the byte and the byte array. You can modify the byteArray and that is not possible in the byte. So, have a look at the code below where we are modifying the array declared by
ourselves.
MyArray=[99,5,1,34,89]
print('The byteArray is: ', MyArray)
#Modifying the ByteArray
MyArray[2]=56
print('The modified array is: ',MyArray)
But for this, you must keep in mind that you can only use values between 0 and 255. All the other conditions are the same as the bytes.
Hence, today we have seen a piece of great information about a special type of method that converts different types of data into bytes in a specific manner. We have seen the details of methods that must be known to a Python programmer. The whole discussion was put into TensorFlow in the form of codes, and we get the outputs as expected. The next lecture is also related to this, so stay with us for more information.
Hello everyone, I hope you all are doing great. Today, we are going to share the second chapter of Section-III in our Raspberry Pi programming course. The previous guide covered how to interface an LDR Sensor with Raspberry Pi 4. This tutorial will cover the basics of hooking up a soil humidity sensor to a Raspberry Pi 4 to get accurate readings. Next, we'll write a Python script to collect the data from the sensors and display it on a Serial monitor.
Are you aware that you can utilize a Raspberry Pi 4 to track the water absorbed by the soil around your houseplants or garden? This helpful guide will show you how to install a soil humidity sensor that will send you a text message when your plant needs watering. A Pi 4, a soil humidity sensor, and a few low-priced components are required. All right, let's get going!
Today, we are going to interface Soil Moisture with Raspberry Pi 4. We will design a simple irrigation system, where we will measure the moisture of the soil and depending on its value, will turn ON or OFF the water pump. We will also use a 20x4 LCD to display values/instructions.
One way to assess soil conditions is with a soil moisture sensor. The electromagnetic signal that the sensor emits travels through the soil. The sensor then evaluates the moisture level based on the signal's reception.
We can use soil moisture sensor has numerous purposes. Saving water is one of them. Adjustments to the watering system can be made based on readings from the sensor that measures the soil's moisture level. This could cut down on both water consumption and waste. Plant health can be enhanced by employing a soil moisture monitor, another perk. We can use this sensor to set off a relay to begin watering the plant if the soil moisture level drops off a given threshold.
The two exposed wires on the fork-shaped probe function as a variable resistor whose resistance changes with the soil's moisture level.
The above figure demonstrates how to use a soil moisture sensor to detect moisture levels. When water is poured into the soil, the voltage of the sensor immediately reduces from 5V to 0V. The module has a potentiometer(blue) that adjusts how sensitively the digital pin changes state from low to high when water is introduced into the soil.
There are typically two components that make up a soil moisture sensor.
Two exposed conductors on a fork-shaped probe are put wherever moisture levels need to be determined. As was previously mentioned, its a variable resistor whose resistance changes as a function of soil moisture.
The sensor also has an electronic module that is interfaced with the microcontroller. The module produces a voltage proportional to the probe's resistance and makes it available through an Analog Output pin. The same signal is then sent to a Digital Output pin on an LM393 High Accuracy Comparator.
The module features a potentiometer (DO) for the fine-tuning of digital output sensitivity. It can be used to establish a threshold i.e. at which threshold the module will output a LOW signal and a HIGH otherwise.
In addition to the IC, the module has two LEDs. When the component is activated, the Power LED will light up, and the Condition LED will light up if the moisture level is above the setpoint.
Four pins are included on the FC-28 soil moisture sensor.
Among the various uses of Moisture Sensors, I am sharing a few here:
As with most things involving the Raspberry Pi, connecting a soil humidity sensor is child's play. we need to connect the soil moisture sensor with Pi 4 GPIO header. This connection requires three wires.
We can now start coding our project because all the pieces are in place. Now is the time to begin.
Here's our hardware setup having soil Moisture Sensor with RPi4:
Here's the Pin's Mapping:
VCC -> 5V
GND -> GND
DATA-> GPIO4
After the sensor has been hooked up, testing it requires the creation of some code. The following code can be copied and pasted into a text editor, then saved as a .py file.
import RPi.GPIO as GPIO
import time
#GPIO SETUP
channel = 4
GPIO.setmode(GPIO.BCM)
GPIO.setup(channel, GPIO.IN)
def callback(channel):
if GPIO.input(channel):
print ("Water Detected!")
else:
print ("Water Detected!")
GPIO.add_event_detect(channel, GPIO.BOTH, bouncetime=300)
GPIO.add_event_callback(channel, callback)
while True:
time.sleep(0)
The below output should be observed if the sensor is operating correctly:
So, there's been a moisture detection! You can change the code to perform any action you like. Once the humidity level is detected, you could activate a motorized or audible alarm, for instance. In the next tutorial, we will Interface a Sharp IR Sensor with RPi4. Stay tuned. Have a good day.
Hello friends, I hope you all are doing great. Today, I am going to share the 6th lecture in the Raspberry Pi 4 Programming series. We're glad you could join us for another lesson in our comprehensive Raspberry Pi programming guide. In today's guide, I'll show you how to interface a 16x2 LCD screen with Raspberry Pi 4.
So, let's get started:
Today, we are going to interface a 16x2 LCD screen with Raspberry Pi 4. At first, we will print the "Hello World" text on the LCD, and in the last section, we will implement the scrolling and blinking of text on the LCD.
We will need the following components for today's project:
The header pins of 16x2 monitors are not pre-soldered. Normally a male header pin is soldered to the LCD pin holes.
We can perform 2 types of communication modes in LCDs, named:
In 8-Bit mode, all 8 data pins are used to send data, while in 4-Bit mode, the last 4 pins(D4-D7) are used for data transmission.
LCDs employ two distinct registers:
You can use the RS pin on LCD to alter the register. If RS is High, we are accessing the data register and if it's Low, we are accessing the command register.
The LCD's command register keeps track of the user's command. Pre-display data is saved in the data register. In order to manipulate the display, one must first load the instruction register with commands and then load the data registers to display the data. If you're working on a Raspberry Pi project and want to avoid learning low-level commands, you can use the Liquid Crystal Library instead.
The screen's brightness can be adjusted from Pin 3, normally a potentiometer is placed at Pin 3 to adjust the brightness. You can also use a resistor if you don't have a potentiometer. If a resistor is used, try one between 5k-10k ohms. You should experiment with a few different values to get the optimal resistance.
LCD works on the principle of light transmission from one layer to the next via molecules. These units vibrate and align themselves in a way that the polarized sheet gets at an angle of 90 degrees, allowing light to pass through. In other words, these molecules inspect the information on every pixel. Every single pixel uses the light absorption technique to display the digits. It is necessary to adjust the molecular orientation to the incident light angle in order to show the value.
The 16x2 LCD screen can easily be connected to the Raspberry Pi 4. There will be a lot of cables to connect because LCD has 16 pins, but nothing too complicated. Here's the schematic of the pin connections between RPi4 and LCD:
Having done so, the screen should power up and establish a connection with the RPi.
The newest Raspbian release has all the necessary packages loaded out of the box to allow for GPIO communication. But we need to install the Liquid Crystal Library to work on the LCD. Let's do that:
git clone https://github.com/pimylifeup/Adafruit_Python_CharLCD.git
cd ./Adafruit_Python_CharLCD
sudo python setup.py install
After the installation, you can use the Adafruit library from any Python program on the Pi. Just paste this line into the beginning of your Python file to make use of the library.
import Adafruit_CharLCD as LCD
The Adafruit LCD library makes it simple to display data from Raspberry Pi to LCD screen. The library package also has several working examples of utilizing the LCD. Before running any of these examples, make sure the pin parameters at the top of the program reflect your setup. My Circuit should yield the following results.
lcd_rs = 25
lcd_en = 24
lcd_d4 = 23
lcd_d5 = 17
lcd_d6 = 18
lcd_d7 = 22
lcd_backlight = 4
lcd_columns = 16
lcd_rows = 2
cd ~/Adafruit_Python_CharLCD/examples/
sudo nano char_lcd.py
Change the values in this section to match the ones described above for the pin configuration. To save the code, hit CTRL+X+Y on your keyboard. To execute this code, open a terminal and type Python followed by the name of the file (including the extension).
python char_lcd.py
In this session, I'll go over the fundamental Python methods for interacting with the screen. To initialize the pins, it is necessary to invoke the following class. Before calling the class, make sure all the parameters have been defined.
lcd = LCD.Adafruit_CharLCD(lcd_rs, lcd_en, lcd_d4, lcd_d5, lcd_d6, lcd_d7, lcd_columns, lcd_rows, lcd_backlight)
After that, you can adjust the screen to your liking. In this short guide, I'll give you a taste of what you can do with the Adafruit library.
The Ardafruit CharLCD.py file in the Adafruit CharLCD folder of the Adafruit Python CharLCD folder will list all the accessible methods.
sudo nano ~/Adafruit_Python_CharLCD/Adafruit_CharLCD/Ardafruit_CharLCD.py
My simple script for displaying user-entered text is included below.
#!/usr/bin/python
# Example using a character LCD connected to a Raspberry Pi
import time
import Adafruit_CharLCD as LCD
# Raspberry Pi pin setup
lcd_rs = 25
lcd_en = 24
lcd_d4 = 23
lcd_d5 = 17
lcd_d6 = 18
lcd_d7 = 22
lcd_backlight = 2
# Define LCD column and row size for 16x2 LCD.
lcd_columns = 16
lcd_rows = 2
lcd = LCD.Adafruit_CharLCD(lcd_rs, lcd_en, lcd_d4, lcd_d5, lcd_d6, lcd_d7, lcd_columns, lcd_rows, lcd_backlight)
lcd.message('Hello\nworld!')
# Wait 5 seconds
time.sleep(5.0)
LCD.clear()
text = raw_input("Type your name in the terminal ")
LCD.message(text)
# Wait 5 seconds
time.sleep(5.0)
LCD.clear()
lcd.message('Goodbye\nWorld!')
time.sleep(5.0)
LCD.clear()
If everything's fine, you will get something printed on your screen, as shown in the below figure:
If your Python script isn't producing any output on the screen, it's probably due to incorrectly configured pins.
This guide walked you through connecting the Pi 4 to a 16x2 LCD. You can accomplish so much more with this sleek screen. You may set up a script to run at boot time and show useful information like the IP address, time, temperature, and more.
You can also incorporate a wide variety of interesting sensors with this screen. A temperature sensor like the DS18B20 would be ideally suited for use with the screen. Refresh the screen every few seconds to reflect the current temperature.
Please let me know how successful you were in putting up a Pi 4 with LCD 16x2 display with the help of this tutorial. In the next tutorial, we will interface Keypad 4x4 with Raspberry Pi 4. Till then, take care. Have fun !!!
We're glad you could join us for another lesson in our comprehensive Raspberry Pi programming guide. I will show you how to install and connect the RFID card chip to your Raspberry Pi through step-by-step instructions.
Modern security systems would only be complete using radio frequency (RFID) devices. To control who can enter a facility or which rooms they can access, RFID chips and card readers are employed. The RFID card's unique identification number can be read wirelessly with a wall-mounted RFID reader. A door will only unlock and allow entry if the RFID card's unique identification number matches a list of approved cards.
It's fun to tinker with this circuit, and it may be used in many other applications, from opening locks to taking attendance. The MFRC522 microcontroller underpins the RFID RC522, a cheap RFID (Radio-frequency identification) reader/writer. The RFID tags can connect with this microcontroller using an electromagnetic field it generates at 13.56MHz and sends to them via the SPI protocol. If you want to use your RFID RC522 with tags, you must ensure that they are 13.56MHz compatible. We'll walk you through the wiring of the RC522 and the creation of Python programs to communicate with the chip, allowing you to read and write RFID tags. Adding a 16x2 LCD to the Raspberry Pi is a simple extension of this tutorial, and it can be helpful if you need to show the user some information or provide a visual prompt.
| Where To Buy? | ||||
|---|---|---|---|---|
| No. | Components | Distributor | Link To Buy | |
| 1 | Breadboard | Amazon | Buy Now | |
| 2 | Jumper Wires | Amazon | Buy Now | |
| 3 | Raspberry Pi 4 | Amazon | Buy Now | |
Raspberry Pi
Micro SD Card
Power Supply
RC522 RFID Reader
Breadboard
Breadboard Wire
An RFID reader reads the tag's data when a Rfid card is attached to a specific object. An RFID tag communicates with a reader via radio waves.
In theory, RFID is comparable to bar codes because it uses radio frequency identification. While a reader's line of sight to the RFID tag is preferable, it is not required to be directly scanned by the reader. You can only read an RFID tag up to three feet away from the reader. The RFID tech quickly scans many objects, making it possible to identify a specific product rapidly and effortlessly, even if it is sandwiched between several other things.
Major components of Cards and tags include an integrated circuit (IC) that stores the unique identification value and a copper that acts as the antenna.
Inside the Rfid reader is another copper wire coil. This coil produces a magnetic field when current flows through it. Magnetic flux creates a current inside the wire coil when the card is brought close to the reader. This current can power the card's internal integrated circuit. The reader then takes in the card's serial number. A card reader will send the card's serial number to a central processing unit (CPU) like a Raspberry Pi for further processing.
When you buy an RFID RC522 Reader, you may discover that 90% of them do not have the header pins pre-installed. Due to a lack of pins, you'll have to solder them yourself; however, this is a relatively easy task, even for amateurs. Assuming the header pins that came with your RC522 are too large, you may snap them in half to reduce them to a single column of eight.
Start by inserting the header pins into the RC522 from the top. The circuit may be easily placed on top of the connector pins by inserting the large side of the pins onto a breadboard. The breadboard's secure holding of the pins will make soldering them to the RFID circuit much simpler.
Solder each pin individually by carefully heating your soldering iron and applying it to the pins. Remember that heating the junction slightly before to solder application increases the solder's adhesion and decreases the likelihood of generating a cold joint. When using solder, we advise you to be conservative. When you've finished soldering the header pins onto your RFID circuit, you'll be ready to move on with the guide.
There are eight different connectors on the RFID RC522. Except for the IRQ, we need to connect all these to the GPIO pins on our Raspberry Pi.
This guide shows how to connect an RFID RC522 to a Breadboard and then to the Raspberry Pi's GPIO Pins, although you could also wire the components straight to the Pi.
Simply connecting 7 of the Raspberry Pi's GPIO pins to the RFID RC522 reader is all needed to get it up and to run. Refer to the GPIO pin locations detailed in our tutorial and the table below when deciding how to wire your RC522.
SDA connects to Pin 24.
SCK connects to Pin 23.
MOSI connects to Pin 19.
MISO connects to Pin 21.
GND connects to Pin 6.
RST connects to Pin 22.
3.3v connects to Pin 1.
We need to adjust the Raspberry Pi's settings before we can use the RFID RC522. Inconveniently, our RFID reader circuit relies on the Raspberry Pi's SPI (Serial Peripheral Interface), which is disabled by default. Worry not, though, as it is easy to restore this interface; follow our instructions below to set up your RPi and Raspbian to use the SPI port. Launch the raspi-config utility by opening a terminal and typing the following command.
sudo raspi-config
A menu of choices will appear when you use this tool. You may read up on all of these options in the raspi-config documentation. Choose "5 Interfacing Options" using the arrow keys. Select this choice, and then hit the Enter key. Once "P4 SPI" is selected in the next screen, press Enter once more to confirm your selection. To continue, use the arrow keys to choose "Yes" and then press Enter when prompted to confirm that you want to activate the SPI Interface. For the raspi-config utility to finish enabling SPI, you'll have to be patient for a while.
The raspi-config tool's success in enabling the SPI interface will be shown by the display of the message "The SPI interface is enabled." Activating the SPI Interface requires a full reboot of the Raspberry Pi. Press Enter, and then ESC, to return to the terminal. If you want to restart the RPi, enter the following Unix instruction into the terminal.
sudo reboot
It is time to verify that Raspberry Pi has been activated now that it has rebooted. Checking if spi bcm2835 is available is as simple as running the following command.
lsmod | grep spi
If you get spi bcm2835, you're good to go with the rest of the tutorial. If you tried the preceding command and it didn't work, try the following three things. If the SPI component is not enabled, we can manually modify the boot config file by issuing the following code to our RPi.
sudo nano /boot/config.txt
You can use CTRL + W to search the configuration file for "dtparam=spi=on" If you think you have discovered it, look if it has a number in front of it. If there is, delete it because it disables the code. If you cannot find the line, add "dtparam=spi=on" to the very end of the file. To commit your modifications, use CTRL + X, followed by Y and Enter. You can double-check that the module has been activated by restarting your Raspberry Pi, as in Step 5.
After connecting our RFID circuit to the RPi, we can turn it on and start writing Python scripts to communicate with the chip. You'll learn how to read and write information to RFID chips by composing scripts like the ones we'll provide. These will serve as the foundation for future RFID RC522 tutorials and provide you with a fundamental understanding of how data is handled. The Raspberry Pi must be brought up to date with the most recent software versions before we can begin programming. Get the latest version of Raspbian for your Pi by running these two commands.
sudo apt update
sudo apt upgrade
Installing the python3-dev, python-pip, and git packages is the last thing to do before moving forward. To get your RFID reader set up with this guide, type the following command into your Raspberry Pi's terminal.
sudo apt install python3-dev python3-pip
Now that we have python "pip" installed on our Raspberry Pi, we can install the spidev Python library. An integral part of this guide, the spidev library allows the RPi to communicate with the RFID via the SPI. Run the following command to get spidev set up on your Raspberry Pi via pip. It's important to remember that we're using sudo to guarantee that the package gets installed for everyone's usage, not just the logged-in user.
sudo pip3 install spidev
After getting the spidev library up and running on our Raspberry Pi, we'll move on to setting up the MFRC522 library with pip. Two files, in particular, are used by us, both of which are part of the MFRC522 library:
This library, MFRC522.py, implements the RC522 interface for communicating with RFIDs via Raspberry Pi's SPI port.
Simplifying the MFRC522.py file so that you only need to work with a small subset of its many functions, SimpleMFRC522.py is a significant time saver.
Enter this command into your terminal to have pip setup the MFRC522 library on your Pi 4:
sudo pip3 install mfrc522
Now that the library has been transferred to the Pi, we can start writing code for the RFID RC522. First, we'll explore how to use the RC522 to program your RFID cards. Move on to the following part, where we will write our first Python code.
In this first Python script, we'll go over the steps needed to send information from the RC522 to RFID tags. This is made more accessible by the SimpleMFRC522 script, but we'll still break down the code's individual components for you. To begin, let's create a directory to hold the scripts we'll be using. Create the "pi-RFID" folder by using the following command.
mkdir ~/pi-rfid
To get started, navigate to the folder you just cloned and create the Write.py script in Python.
cd ~/pi-RFID
sudo nano Write.py
Add the following blocks of code to this file. This code prompts you for some text, which it then uses to update the RFID Tag.
#!/usr/bin/env python
import RPi.GPIO as GPIO
from mfrc522 import SimpleMFRC522
The very first line of the code snippet instructs the terminal to use Python rather than another scripting language like Bash to parse and run the file. To guarantee that the GPIO Pins are reset when the script terminates, we must first import the RPi.GPIO package contains all the necessary functions for communicating with the GPIO Pins. The second import is our SimpleMFRC522 library, which will be used to communicate with the RFID RC522. Compared to the standard MFRC522 library, it dramatically simplifies working with the chip.
reader = SimpleMFRC522()
In this line, we make a new instance of the SimpleMFRC522 object, use its setup function, and save the result in our readers variable.
try:
text = input('New data:')
print("Now place your tag to write")
reader.write(text)
print("Written")
We enclose the following section of code with a try statement to ensure that any unforeseen problems are handled, and the code is cleaned up correctly. Python is whitespace sensitive; it uses tabs to distinguish between code sections, so keep them after trying. In this case, the second line reads a command-line input and stores it in a text variable using Python 3's input function.
The third line makes advantage of print() to prompt the user to set the RFID tag onto the reader. After that, on line 4, we utilize our scanner object to instruct the RFID Circuit to write the text field's contents to a certain sector of the RFID tag. On line 5, after successfully writing to the RFID tag, we call print() once more to inform the user.
finally:
GPIO.cleanup()
The script will terminate in the last two lines of code. The finally statement always follows the try statement. Thus the GPIO.cleanup() method is called after each iteration of the try block. These lines are essential because improper cleanup can disrupt the functionality of other programs. Upon completion, your script should be like the example given below.
The file can be saved by pressing CTRL Plus X, Y, then ENTER once you've double-checked the code and are convinced it's correct. Now that the script is written, we need to put it through some testing. Get an RFID tag ready before running the script for testing. When you're ready, open the terminal on your Raspberry Pi and enter the following command.
sudo python3 Write.py
In this situation, we're just going to type in "any word" because it's easy to remember and short. Press the Enter key when you have finished writing and are ready to send. After that, your RFID Tag can be placed directly above your RFID circuit. It will immediately update the tag with fresh information when it does. You'd see the word "Written" on the command prompt if it worked. Now that you have your Write.py script completed, we can move on to explaining how to read information from the RFID RC522.
We have successfully programmed our RC522 to print to RFID tags and can now move on to writing a script to retrieve the data from the tags. First, we'll make sure we're in the correct location by switching directories, and then we'll use nano to start drafting the Read.py script.
cd ~/pi-rfid
sudo nano Read.py
Incorporate the following code into this document. When an RFID tag is placed in the RFID reader, the script will wait until the tag's data has been read before displaying the results.
This file's first line of code instructs the operating system on how to proceed when the user clicks the "Run" button. If you don't specify that it's a Python file, it'll try to run it like any other script. An initial RPi.GPIO import is made. Importing this library ensures that the Raspberry Pi's GPIO pins are cleaned up after script termination, as it contains all the necessary functions. SimpleMFRC522 is the second import. With the assistance functions included in this script, reading and writing to an RFID RC522 is a breeze, whereas, with them, the scripts would quickly grow to be manageable.
This line is crucial because it invokes SimpleMFRC522's creation method, which returns an object that is subsequently stored in our reader variable.
try:
id, text = reader.read()
print(id)
print(text)
The following code section will be encapsulated in a try block to allow us to handle any unforeseen errors gracefully. Because Python is sensitive to whitespace, you must use the 'tabs' as displayed following try:
In this scenario, the second line of this code block initiates a call on our scanner object, instructing the circuits to begin scanning any Rfid card that is positioned on top of the reader. On the third and forth lines, we use print() to display the data we gleaned from the RFID Chip; this includes the tag's unique identifier and any text it may consist of.
finally:
GPIO.cleanup()
The script ends with the last two lines of code. No of what happens inside the try block, the final statement is always executed afterward. No matter what, the GPIO.cleanup() code will be executed thanks to this try statement. It's vitally important, as not doing so can disrupt the proper operation of other scripts that rely on the GPIO. Your completed Read.py script for the RFID RC522 should resemble the example below.
When you've double-checked your code and are satisfied with it, press Ctrl + X, then Y, and finally ENTER to save the file. The time has come to put our completed Read.py script to the test. Get ready to test the script by picking up any of the RFID tags. If you're all set, enter this command into the terminal on your Raspberry Pi.
sudo python3 Read.py
Now that the script is active, you can set your RFID Tag atop your RFID circuit. When the RFID tag is placed on top, the Python program will immediately begin reading the information from the tag and display the results on the screen. What a finished product might look like is shown below as an illustration.
To test whether your Raspberry Pi is properly connected on the RFID RC522 Circuit, run the Read.py script and see if it returns any data that matches the text you wrote to the card in the Write.py script.
Connecting an RC522 RFID module to a Pi 4 makes reading MIFARE chips and cards is now possible. This might be very useful in security systems and other applications where identifying an item or person is required without the user having to physically interact with the device by pressing buttons, switching, or activating any sensors. Eventually, you should be able to use this to decipher the UID encoded on your MIFARE tags. You should know that these cards can be duplicated and assigned a new unique identifier (UID) if you plan on employing this technique in a security system. To ensure the safety of your system, you must ensure that no one learns your UID or gains remote access to your devices. The contactless tags are convenient because they can be attached to a keychain, and the cards are convenient because they can be carried in a wallet. Both things can be concealed inside others to give them a hidden identifier that the Pi can access. With the help of our Pi 4-powered RFID attendance systems guide, you can learn how to set up your RFID Reader/Writer for use in checking attendance. Our exploration of the RFID chip and the scripts above will continue in subsequent guides. A door security system is one of the fantastic DIY Pi ideas we'll look into. The next lesson will teach you how to connect a 16x2 LCD screen to a Raspberry Pi 4.