The Engineering Projects

Smart Irrigation System using Arduino UNO

Hello everyone, we are back with a new project and we hope you all are doing well. In this article, we will discuss a project named Smart Irrigation System using Arduino UNO. We will use different sensors to measure the environmental and crop parameters which are responsible for good production. We will also make the water pump system automatic which will open the water valve automatically according to the soil moisture of the crop.

We will discuss all points and concepts briefly in this article and also provide a Proteus Simulation to observe how it will work in the real world. Complete fully explained code and simulation are also provided below as you go ahead in this article. You can download it from there.

Smart Irrigation System using Arduino UNO

Let’s start with an Introduction:

Where To Buy?
No.	Components	Distributor	Link To Buy
1	LCD 20x4	Amazon	Buy Now
2	LDR Sensor	Amazon	Buy Now
3	MQ-135	Amazon	Buy Now
4	Arduino Uno	Amazon	Buy Now

Introduction 

In the late decades, there has been a quick advancement in Smart Agricultural Systems. Show that agriculture has great importance worldwide. Indeed, in India for example, about 70 % of the people rely upon the vital sector of agriculture. In the past, irrigation systems used to be dependent on the mills to irrigate the farm by conventional methods without knowing the appropriate quantities of these crops.

These old systems are a major cause of the waste of large quantities of water and thus destroy some crops because of the lack of adequate quantities of water. However, with the recent technological developments, there have been innovative systems for irrigation without the farmer interfering in the irrigation process. We will discuss it in brief below.

We will do a simulation on Proteus 8 Professional Software.

Working

The working of this project is like, we will use a Soil Moisture sensor for measuring the moisture of Soil according to which water valves are controlled. When the moisture level gets below a threshold value, valves will open with the help of a relay or solenoid till the soil is well moisturized.

• The BMP180 sensor will measure the Atmospheric Pressure.
• The DHT11 sensor will measure the temperature and humidity of the climate.
• The MQ135 sensor will measure the Air Quality Index of the environment.
• LDR will measure the sunlight intensity.
• We will use a 20x4 LCD Screen for displaying the data gathered from the sensors.
• And the main thing, we will use an Arduino UNO microcontroller as the brain of the project.

In a used case, when the moisture level gets below a threshold value, valves will open with the help of a relay or solenoid for a required time interval.

Block Diagram

• Here's the Block Diagram of Smart Irrigation System:

Components Required

Here's the list of components used in this project:

• Arduino UNO
• BMP180 Sensor
• DHT11 Sensor
• LDR Sensor
• MQ135 Gas Sensor
• Soil Moisture Sensor
• 20x4 LCD Display
• PCF8574 remote 8-bit I/O expander for the I2C bus
• Breadboard.
• Jumper wires (Male to Male, Male to Female, Female to Male.)

Since we are designing a prototype of this project, we will use jumper wires instead of soldering.

• Power Supply

You can use a Battery, Adapter or any DC source of 5-8v(recommendable).

Circuit Diagram

Since we are making a prototype of this project, we will make connections on the breadboard and avoid soldering the components. We will use male to male, male to female and female to female jumper wires. 

Pins Connections

These are the pin connections of all components.

Pin Connections of Smart Irrigation System
No.	Sensor	Pinout
1	Soil Moisture Sensor	Data - A0 (Arduino)
2	LDR Sensor	LDR-Resistor Junction - A2 (Arduino)
3	MQ135 Gas Sensor	Out - A1 (Arduino)
4	DHT11 Sensor	Data - D2 (Arduino)
5	BMP180 Pressure Sensor	SDA-SDA (Arduino) SCL - SCL (Arduino)

 

Arduino Libraries Required

You need to install these third-party Arduino Libraries, in order to interface sensors:

1. Adafruit_BMP085.h
2. DHT.h
3. LiquidCrystal_I2C.h

We have added comments in the code for better understanding so it can be understood easily.

Note - Change the Address of the LCD Screen while you run the code in Proteus, change it to 0x20 instead of 0x27 or anyone else. In the real experiment, we can alter the address of the LCD by changing the configurations of A0, A1 and A2 pins of the PCF8574 module.

Proteus Libraries Required

We will show you a demo of this project as a simulation. We are using Proteus 8 Professional Software for the simulation.

• Proteus Software Download from here - Download Proteus - Try Proteus EDA Software - Labcenter Electronics
• Soil Moisture Sensor Library for Proteus - Downloads - The Engineering Projects
• Gas Sensor Library for Proteus - Downloads - The Engineering Projects
• LCD Library for Proteus - Downloads - The Engineering Projects

Proteus Simulation Connections

• This potentiometer defines the soil water content in the proteus simulation.
• When the resistance is maximum at the test pin, the circuit shows zero volts across the voltmeter, which means the sensor is either in the dry ground or taken out of the ground, i.e. giving zero moisture value of the water content.
• And when resistance is zero, the circuit will show the maximum voltage across the voltmeter which indicates the sensor is inserted in a wet ground i.e. water contents in the soil are too high.
• This is important. We have attached the output pin with an LC filter. This filter is not required in real hardware implementation.
• We are using it in Proteus Simulation only as Proteus gives the peak-to-peak value and we have to convert that PP value into Vrms.
• If you are working on a real sensor then you don’t need to add this LC circuit.
• Similarly for Gas sensor, as we increase the potentiometer, in simulation it means good air quality.

Steps for Simulation

These are the steps for simulation. Follow them to create a fully working simulation.

• Download the Zip Files given at the start of this tutorial.
• Extract them in the LIBRARY folder. You will find it inside the Labcenter Electronics Folder.

• Go to Arduino IDE and open the code, go to Tools and select the board Arduino UNO.

• Go to Sketch and Click on Export Compiled Binary. It will create a compiled .hex file of the code which will be used as the main program in the simulation ahead.

• Open Proteus software and add components by searching like Arduino, DHT11, BMP180, 20x4 LCD, etc.

You can see the components listed here.

Note - We used a simple LED instead of the valve because the valve component is not available in the Software, simply replace the LED with a valve in a real project. Make connections according to the circuit diagram and add virtual terminals to Serial pins to see the readings and Data.

• Paste the Program File here for all the sensors.

• Paste the Compiled Binary File as a Program file of Arduino UNO.
• Run the simulation and you can see the readings by opening the virtual terminal.

Observations and Results

 

1. In this simulation and project, you can see the sensor's information first in the terminal.
2. After that, we are getting well organized and easily understood data on the terminal by every sensor according to code.
3. According to the code, when the value of the soil moisture sensor gets less than a threshold value, the LED gets on.

This means when the soil gets dry the valve will open and water will be provided to the crops.

pH Sensor Library for Proteus

Hi guys, I hope you are good and doing well in your life. In this article, I am going to tell you about a new pH Sensor Library for Proteus. I hope you all will enjoy it and find it useful. We are all well aware of pH Sensors which are used for the detection of pH of different fluids. By knowing the pH of a liquid we can tell whether the liquid is acidic or basic. You can’t find a pH sensor in Proteus software, so we designed a pH sensor for simulation purposes. You can interface this pH Sensor with any Microcontroller, for example: Arduino, PIC Microcontroller, 8051 Microcontroller etc.

In this pH Sensor Library, I have added four different pH Sensors, which are used for the detection of the pH of any fluid. Since we can’t place real liquid and measure pH in this software, I have attached a test pin in the pH meter where you have to connect a potentiometer. The potentiometer will produce a reading from 0 to 1023, which will be mapped from 0 to 14 in the program code. We can predict the nature of the liquid. We will have a look at how to use these sensors below. So, here’s the list of all four pH sensors, I have added to this pH sensor  library:

• PH METER
• PH METER 2
• PH METER 3
• PH METER 4

So, let’s start with downloading and installing the pH Sensor Library for Proteus.

Where To Buy?
No.	Components	Distributor	Link To Buy
1	LEDs	Amazon	Buy Now
2	Resistor	Amazon	Buy Now
3	Arduino Uno	Amazon	Buy Now

What is a pH Sensor?

• A pH sensor is a device that is used to measure the pH value of a liquid. pH can be defined as the concentration of H+ ions in a liquid. We can find whether the fluid is acidic, basic or neutral by knowing the pH of the liquid.
• Real pH sensors are shown below:

pH sensor Library for Proteus

• First, download the zip file of Proteus Library for pH Sensor.
• Click the link below to download the library zip file of pH Meter:

pH Sensor Library for Proteus

• After downloading the zip file, extract its files and open the folder named “Proteus Library Files“.
• In this folder, you will find three files, named:
  • pHMeterLibraryTEP.IDX
  • pHMeterLibraryTEP.LIB
  • pHMeterLibraryTEP.HEX
• We have to place these files in the ‘LIBRARY’ folder of Proteus software.
• Now, open Proteus. if you are already working on it you have to restart it.
• In the components search box, search for “PH METER” and you will get four results, as shown in the below figure:

• Let’s place these four pH Meter models in our Proteus workspace:

Adding Hex File to the Sensor

• Now we need to paste the hex file of the pH METER in the properties section of the sensor. Double click on the sensor to open the properties window.
• Go to the program file section, browse to the hex file, which we have downloaded above and placed it in the ‘LIBRARY’ folder of Proteus software:

• After adding the hex file, click the Ok button.
• Now all is ready, let’s create a circuit to check it's working.

pH Sensor Proteus Simulation

• The pH sensor is now ready to simulate in Proteus, so let’s design a simple circuit to understand its working:

• As you can see, I have placed an LC filter on the analog output of the pH sensor, it's because proteus gives us a peak to peak voltage value and we need to convert it to Vrms.
• While performing the real experiment, you don’t need to do the above stuff.
• Now, let’s run the Proteus simulation. You will see such a screen if everything will work fine.

Interfacing of pH sensor with Arduino UNO

• Add Arduino UNO  and pH sensor to the components list and place them in the workspace.
• Placed an LC filter on the analog output of the pH sensor, as mentioned above.

• Connect it to the A0 pin of Arduino. Add a virtual terminal also to see the readings generated.

• Paste the hex file of the program at the program file section of the Arduino.
• Now run the simulation, if everything's fine you will get results as shown in the below figure:

• You can watch the complete working simulation in the below video:

So, that was all for today. I hope you have enjoyed today's lecture. Thanks for reading !!!

First Project using STM32 in STM32CubeIDE

We will use for our examples STM32CubeIDE released by ST and completely free. STM32CubeIDE is a development tool and supports multi operative system (SO), which is part of the STM32Cube software ecosystem. STM32CubeIDE allows using a single platform to configure peripherals, to generate/compile/debug the code for STM32 microcontrollers and microprocessors. The framework used is Eclipse®/CDT, as tool-chain for the development is used GCC toolchain and GDB for the debugging.

To start the project, you must first select the MCU and then initialize and configure the peripherals the user wants to use. At this point, the initialization code is generated. At any time, the user can go back and change initializations and configurations, without affecting the user code. We will dive into these steps with a simple example in the next paragraph.

Where To Buy?
No.	Components	Distributor	Link To Buy
1	STM32 Nucleo	Amazon	Buy Now

First Project in STM using STM32CubeIDE

• First of all, you have to install on your PC the STM32CubeIDE. In order to do it, you have to go on the ST site and after registered in it you can navigate to "https://www.st.com/en/development-tools/stm32cubeide.html" to download it.
• At this point, you can install it, if you'll find problems you can check the "UM2563 - STM32CubeIDE installation guide".

• STM32 Nucleo board (in our example we will use NUCLEO-L053R8, but you can use the one you prefer, as already said all Nucleo boards are pinout compatible);
• USB 2.0 Cable - A-Male to Mini-B Cord to connect PC to ST-LINK;
• Breadboard to hold and connect the simple electrical components;
• Jumper Cables Kit to connect the Nucleo board to breadboard or other components;
• Various basic electrical components such as Resistors (THT), Capacitors (THT), Buzzers, LEDs, etc.

Now let’s start!

Blinking LED using STM32 Nucleo Board

• Turning a LED on and off is a basic and classical experiment when dealing with NUCLEO for the first time.
• First, let's turn on the led, to do this we have to connect the LED to the power supply (on Nucleo we can find 3.3V and 5V).

Assuming:

• the power supply 5V;
• LED forward voltage of LED 7 Volt;
• LED maximum forward current 20mA;

We must connect in series to LED a resistor. What resistance value must be considered to limit the current to 20 mA (see the formula below)?

R > 5 - 1.7/0.02 , where R > 165 ?

A good value of R is 220 ?.

Now we must be able to turn off the led, to do it we need a switch to connect and disconnect the power supply as shown below.

In this case when the switch is closed the Led is ON, when the switch is open the Led is OFF. This can be easily done with a Nucleo board by configuring a GPIO (General Purpose Input Output) pin.

The steps required to configure a core board are explained below. Obviously, this is a very simple practical example, but peripherals, communication protocols and anything else can be configured in a similar way.

Steps to generate the config. files from STM32CubeMX

As already said, we will use for our examples a NUCLEO-L053R8 board. For our examples, so also a Windows PC is required. The ST-Link USB connector is used both for serial data communications, and firmware downloading and debugging on the MCU. A Type-A to mini-B USB cable must be connected between the board and the computer. The USART2 peripheral uses PA2 and PA3 pins, which are wired to the ST-Link connector. In addition, USART2 is selected to communicate with the PC via the ST-Link Virtual COM Port. A tool that emulates the serial communication terminal is necessary to view received messages and send them. You can download many open-source tools as Tera Term. In this way, you can display on PC the messages received from the board over the virtual communication Port and the other way around.

In this paragraph, we will initialize the peripherals using STM32CubeMX. The STM32CubeMX tool to create the necessary config. files to enable drivers of peripheral used (for more detail read “UM1718 - User manual STM32CubeMX for STM32 configuration and initialization C code generation.”).

Steps to Follow

• Select the NUCLEO-L053R8 board looking in a selection bar within the New Project menu.
• Select the required features (debug, GPIOs, peripherals, timer) from the Pinout view: peripheral operating modes as well as assignment of relevant signals on pins.
• Configure the MCU clock tree from the Clock Configuration view.
• Configure the peripheral parameters from the Configuration view.
• Configure the project settings in the Project Manager menu and generation of the project (initialization code only).
• Update the project with the user application code corresponding to the Led blinking example.
• Compile, and execute the project on the board.

Creating a new STM32CubeMX project

• Select File -> New project from the main menu bar to open the New Project window.
• Go to the Board selector tab and filter on STM32L0 Series.

• Select NUCLEO-L053R8 board and then click on OK button to confirm. In this way the board is loaded within the STM32CubeMX user interface.

• Insert the project name, in this case, "BlinkLed" and click finish.

• Then the tool will open the pinout view.

Selecting the features from the Pinout view

• Select Debug Serial Wire under SYS, for do it click on System Core (on the topo right) and then select SYS and finally flag on “Debug Serial Wire”.

 

• Select Internal Clock as clock source under TIM2 peripheral. To do this click on Timers and then select TIM2. Now go to clock source and select through the drop-down menu “internal clock”.

• Select one of the available pins (basically anyone!) as GPIO output, for example PA9 (the last pin of CN5)

Check that the signals are properly assigned on pins:

• SYS_SWDIO on PA13
• SYS_SWCLK on PA14
• GPIO OUTPUT on PA5

Configuring the MCU clock tree

• Go to the Clock Configuration tab and in this project, there is no need to change the configuration.

Configuring the peripheral parameters

• Come back to Pinout&Configuration and select System Core -> GPIO to open the peripheral Parameter Settings window and in this case no change the configuration.

• Select Timers -> TIM2 and change the Prescaler to 16000 and the Counter Period to 1000.

• Go to the NVIC Settings tab and flag TIM2 global interrupt to enable the interrupt related to TIM2.

Configuring the project settings and generating the project

• In the Project Manager tab, configure the code to be generated and click OK to generate the code.

Updating the project with the user application code

• Our project has been initialized by STCubeMX.
• In /BlinkLed/Core/Src/main.c we will find our main where we will write the main body of our program.

STM32 Programming Code for Led Blinking

The user code must be inserted between the "USER CODE BEGIN" and "USER CODE END" so that if you go to regenerate the initializations that part of the code is not deleted or overwritten. As shown in the code below, the simplest way is to use the function:

• HAL_GPIO_TogglePin(GPIOx, GPIO_Pin) in the infinite loop ( while (1) ) with a chosen delay, for example of 1 second. To do this we use the function HAL_Delay(Delay). The declarations of these two functions with their parameters are described below
• HAL_GPIO_TogglePin(GPIOx, GPIO_Pin): Toggles the specified GPIO pins.
• GPIOx: Where x can be (A..E and H) to select the GPIO peripheral for STM32L0xx family devices. Note that GPIOE is not available on all devices. All port bits are not necessarily available on all GPIOs.
• GPIO_Pin: Specifies the pins to be toggled.
• HAL_Delay(Delay): This function provides minimum delay (in milliseconds) based on variable incremented. In the default implementation, SysTick timer is the source of time base. It is used to generate interrupts at regular time intervals where uwTick is incremented.

Note This function is declared as __weak to be overwritten in case of other implementations in a user file.

- Delay: specifies the delay time length, in milliseconds.

So, in our case GPIOx is GPIOA and the GPIO_PIN is GPIO_PIN_9 (see below).

int main(void) { /* USER CODE BEGIN 1 */ /* USER CODE END 1 */ /* MCU Configuration--------------------------------------------------------*/ /* Reset of all peripherals, Initializes the Flash interface and the Systick. */ HAL_Init(); /* USER CODE BEGIN Init */ /* USER CODE END Init */ /* Configure the system clock */ SystemClock_Config(); /* USER CODE BEGIN SysInit */ /* USER CODE END SysInit */ /* Initialize all configured peripherals */ MX_GPIO_Init(); MX_TIM2_Init(); /* USER CODE BEGIN 2 */ /* USER CODE END 2 */ /* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_9); HAL_Delay(1000); /* USER CODE END WHILE */ /* USER CODE BEGIN 3 */ } /* USER CODE END 3 */ }

Now we are ready to compile and run the project:

• Compile the project within IDE.
• Download it to the board.
• Run the program.

Another simple way is to use the function

• HAL_GPIO_WritePin(GPIOx, GPIO_Pin, PinState).
• HAL_GPIO_WritePin(GPIOx, GPIO_Pin, PinState): Sets or clears the selected data port bit.

Note This function uses GPIOx_BSRR register to allow atomic read/modify accesses. In this way, there is no risk of an IRQ occurring between the read and the modified access.

• GPIOx: where x can be (A..E and H) to select the GPIO peripheral for STM32L0xx family devices.

Note that GPIOE is not available on all devices.

• GPIO_Pin: specifies the port bit to be written.

This parameter can be one of GPIO_PIN_x where x can be (0..15).

All port bits are not necessarily available on all GPIOs.

• PinState: specifies the value to be written to the selected bit.

This parameter can be one of the GPIO_PinState enum values:

• GPIO_PIN_RESET: to clear the port pin
• GPIO_PIN_SET: to set the port pin

So, in our case GPIOx is GPIOA and the GPIO_PIN is GPIO_PIN_9 and the pin state changes between 0 (LOW or CLEAR) and 1 (HIGH or SET).

In this case, the code is the following:

while (1) { HAL_GPIO_WritePin(GPIOA, GPIO_PIN_9,0); HAL_Delay(1000); HAL_GPIO_WritePin(GPIOA, GPIO_PIN_9,1); /* USER CODE END WHILE */ /* USER CODE BEGIN 3 */ } /* USER CODE END 3 */ }

There are many other ways to blink an Led such as PWM, Interrupts etc. and will discuss it in the upcoming lectures. Thanks for reading.

Introduction to Nucleo Development Board

To become familiar with the world of microcontrollers it is necessary to have a development board (also known as a kit), which generally allows you to start working on it easily. Fortunately, the ST provides a wide portfolio of development boards. In this guide, we will describe and use the Nucleo board.

The Nucleo has been introduced a few years ago and its line is divided into three main groups:

• Nucleo-32;
• Nucleo-64;
• Nucleo-144.

Where To Buy?
No.	Components	Distributor	Link To Buy
1	STM32 Nucleo	Amazon	Buy Now

Nucleo-32 Development Board

The number of pins available, so the package, gives the name to the board: Nucleo-32 uses an LQFP-32 package; Nucleo-64 and LQFP-64; Nucleo-144 an LQFP-144. The Nucleo-64 was the first line introduced and counts 16 different boards.

The Nucleo boards have interesting advantages compared to the Discovery. First, is the cheaper cost, you can buy it for around 15-25 dollars. Now in 2021 due to the lack of processed semiconductors, it is very difficult to find them on the normal distribution channels and costs are rising. A return to normal is expected from 2023. Furthermore, Nucleo boards are designed to be pin-to-pin compatible with each other. It is a very important advantage, in fact, if I start to develop my firmware on generic Nucleo later then I can adapt my code to another one.

In the next paragraphs, we will see the main structure of STM32-64

STM32 Nucleo-64 parts

The Nucleo-64 is composed of two parts:

• ST-LINK part
• MCU part

The part with the mini-USB connector is an ST-LINK 2.1 integrated debugger. It needs to upload the firmware on the target MCU and run the debugging. Furthermore, the ST-LINK interface provides a Virtual COM Port (VCP), which can be used to exchange data and messages with the host PC. The ST-LINK interface can be used as a stand-alone ST-LINK programmer, in fac,t can be easily cuttable to reduce board size.

To program the STM32 on board, simply plug in the two jumpers on CN4, as shown in the figure below in pink, but do not use the CN11 connector as that may disturb communication with the STM32 microcontroller of the Nucleo.

However, the ST-LINK provides an optional SWD interface which can be used to program another board without detaching the ST-LINK interface from the Nucleo by removing the two jumpers labeled ST-LINK (CN4).

The rest of the board, MCU part, contains the target MCU (the microcontroller we will use to develop our applications), a RESET button, a user-programmable push button (switch), and an LED. It is possible to mount an external high-speed crystal (HSE) through X3 pads (see figure below). Generally, the Nucleo boards, especially the most recent ones, provide a low-speed crystal (LSE).

Finally, the board has several pin headers we will look at in the next paragraph.

STM32 Nucleo-64 connectors

The STM32 Nucleo-64 board has 8 connectors:

• CN2: ST-LINK USB connector on ST-LINK (already described in the previous paragraph);
• CN11: SWD connector in ST-LINK part (already described in the previous paragraph);
• CN7 and CN10: ST morpho connectors;
• CN5, CN6, CN8, and CN9: ARDUINO® Uno V3 connectors;

The CN7 and CN10 ST morpho connectors are male pin headers (2x19, 2.54mm male pin headers) accessible on both sides of the STM32 Nucleo-64 board (see the figure below). All signals and power pins can be probed by an oscilloscope, logical analyzer, or voltmeter through the ST morpho connectors. They are two. They are called Morpho connectors and are a convenient way to access most of the MCU pins.

• The figure below is shown the CN7 pinout (the STM32 peripherals and GPIOs associated with the Morpho connector) for NUCLEO-L053R8.

• In the next figure, is shown the CN10 pinout for NUCLEO-L053R8.

• The previous figure showed the pinout for NUCLEO STM32L053R8, but I remember you the Nucleo is pinout compatible with each other.
• Another important feature of the Nucleo board is the compatibility with ARDUINO® Uno V3 through the CN5, CN6, CN8, and CN9 connectors (see figure below).

• CN6 and CN8 are directly connected to CN7 and CN5 and CN9 to CN10.

Setting-Up the Tool-Chain

The first step in developing an application on the STM32 platform is to fully set up the tool-chain. A tool-chain is a set of programs, compilers, and tools that allows us:

• to write our code and to browse the source files of our application;
• to browse inside the application code, in order to examine variables, definitions, function declarations, and etc;
• to compile our code using a cross-platform compiler;
• to upload and debug our application on the development board (or a custom board).

To carry out these activities we basically need:

• an IDE with integrated source editor and navigator;
• a cross-platform compiler able to compile source code for our platform;
• a debugger that executes the debugging of firmware on our board;
• a tool that interacts with the ST-LINK interface.

There are several complete tool-chain for the STM32 Cortex-M family, both free and commercial. The most used tools are: IAR for Cortex-M, ARM Keil, and AC6 SW4STM32.

They can integrate everything necessary for the development of applications on STM32 to simplify and accelerate their development. The first two are commercial solutions and therefore have a price to the public that may be too high for those approaching the first time.

So, that was all for today. I hope you have enjoyed today's lecture and have understood this Nucleo Development Board. In the next lecture, we will design our first project in STM32CubeIDE. Thanks for reading.

Introduction to STM32 Family

In this guide, we will explain step by step to start programming on the STMicroelectronics (STM) platform, especially the STM32 family.

The term, "STM32" refers to a family of 32-bit microcontroller integrated circuits based on the ARM® Cortex®M processor. The architecture of these CPUs (Central Processing Unit) is ARM (Advanced Risk Machine) which is a particular family of Reduced Instruction Set Computing (RISC). RISC architecture differs from Complex Instruction Set Computing (CISC) for its simplicity that allows you to create processors capable of executing instruction sets with shorter times. Why use STM32? The advantages are many, and now we will list a part of them:

1. ST offers a wide portfolio of solutions depending on the developer's needs. We can find products that combine different advanced features while maintaining a high level of integration. In fact, we can choose products with high performance, real-time processing, digital signal processing, and low consumption.
2. Thanks to the availability of different development tools and available support material, the development of a simple or complex project is quite simple and fast, reducing the time to market if you want to develop a product.
3. Each microcontroller has an integrated processor core, static RAM, flash memory, debug interface, and various peripherals such as GPIO, ADC, DAC, Timer, SPI, UART-USART, I2C, etc.
4. For every MCU, ST provides the STM32 Nucleo Board that helps anyone who wants to fastly build and test prototypes for new projects with any STM32 MCU. STM32 Nucleo boards share the same connectors and can be easily expanded with many specialized application hardware add-ons (Nucleo-64 includes ST Morpho and Arduino Uno Rev3 connectors, while Nucleo-32 includes Arduino Nano connectors). Another and not insignificant advantage is the cheap cost of these development boards.

In the next paragraph, it will be illustrated how the STM32 is divided to easily identify the one used for your purposes.

Where To Buy?
No.	Components	Distributor	Link To Buy
1	STM32 Nucleo	Amazon	Buy Now

STM32 Family

• To date, the STM32 family has 16 series of microcontrollers divided into four groups in order to cover all the needs of developers.
• The four groups are Mainstream, Ultra-Low-Power, High-Performance Wireless.

STM32 Mainstream

The STM32 Mainstream has been designed to offer solutions for a wide range of applications where costs, time to market, reliability, and availability are fundamental requirements. They are widely used in real-time control signal processing applications.

There are 5 series in this group:

1. STM32F1 are microcontrollers based on the ARM Cortex-M3 core. It was launched in 2007 and evolved over time in terms of maximum clock rate, memory depth, and peripherals. In fact, the maximum clock rate has gone from 24 MHz to 72 MHz, static RAM up to 96 kB, and Flash up to 1024 kB. It also supports Thumb-1 and Thumb-2 instruction sets.
2. STM32F0 are microcontrollers based on the ARM Cortex-M0 core. It was launched in 2012. The maximum clock rate is 48 MHz and includes the SysTick timer. Static RAM up to 32 kB, and Flash up to 256 kB. It also supports Thumb-1 and Thumb-2 instruction sets.
3. STM32F3 are microcontrollers based on the ARM Cortex-M0 core. It was launched in 2012. The maximum clock rate is 72 MHz and includes the SysTick timer. Static RAM up to 40 kB, and Flash up to 256 kB. It also supports Thumb-1, Thumb-2, Saturated, DSP, FPU instruction sets.
4. STM32G0 are microcontrollers based on the Cortex-M0/M0+ core. It was launched in 2018. The maximum clock rate is 64 MHz. Static RAM up to 128 kB, and Flash up to 512 kB. It also supports Thumb-1 and Thumb-2 instruction sets. Compared to the older F0 series, it presents improvements in terms of efficiency and performance.
5. STM32G4 are microcontrollers based on the Cortex-M4F core. It was launched in 2019. The maximum clock rate is 170 MHz. Static RAM up to 128 kB, and Flash up to 512 kB. Thumb-1, Thumb-2, Saturated, DSP, FPU instruction sets. Compared to the older F3/F4 series, it presents improvements in terms of efficiency and performance and higher performance compared to the L4 series.

STM32 Ultra-Low-Power

The STM32 Ultra-Low-Power has been designed to meet the need to develop devices with low energy consumption (such as portable and wearable devices) but maintaining a good compromise with performance.  There are 6 series in this group:

1. STM32L0 are microcontrollers based on the ARM Cortex-M0+ core. It was launched in 2014. The maximum clock is 32 MHz, static RAM is of 8 kB, and Flash is up to 64 kB. It also supports Thumb-1 and Thumb-2 instruction sets.
2. STM32L1 are microcontrollers based on the ARM Cortex-M3 core. It was launched in 2010. The maximum clock rate is 32 MHz, static RAM up to 80 kB, and Flash up to 512 kB. It also supports Thumb-1 and Thumb-2 instruction sets.
3. STM32L4 are microcontrollers based on the ARM Cortex-M4 core. It was launched in 2015. The maximum clock rate is 80 MHz, static RAM is of 64 kB, and Flash is of 1024 kB. It also supports Thumb-1 and Thumb-2, Saturated, DSP, FPU instruction sets.
4. STM32L4+ are microcontrollers based on the ARM Cortex-M4 core. It was launched in 2016. The maximum clock rate is 120 MHz, static SRAM up to 640 kB, and Flash up to 2048 kB. It also supports Thumb-1 and Thumb-2, Saturated, DSP, FPU instruction sets. It has been enriched with advanced peripherals such as a TFT-LCD controller, Camera interface, etc.
5. STM32L5 are microcontrollers based on the ARM Cortex-M33F core. It was launched in 2018. The maximum clock rate is 110 MHz, static SRAM up to 640 kB, and Flash up to 2048 kB. It also supports Thumb-1 and Thumb-2, Saturated, DSP, FPU instruction sets.
6. STM32U5 is the last ultra-low-power series launched (in 2021). It is an evolution of the L series and is based on the ARM Cortex-M33F core. the new 40 nm silicon technology allows to further reduce energy consumption, it also includes advanced cyber security features and graphics accelerators. The maximum clock rate is 160 MHz, static SRAM up to 640 kB, and Flash up to 2048 kB. It also supports Thumb-1 and Thumb-2, Saturated, DSP, FPU instruction sets.

STM32 High-Performance

The STM32 High-Performance has been designed for data processing and data transfer. It also has a high level of memory integration. There are 5 series in this group:

1. STM32H7 are microcontrollers based on the ARM Cortex-M7F core. It was launched in 2017. The maximum clock is 480 MHz, static RAM is up to 1.4 MB, and Flash is up to 128 kB. It includes Ethernet and some advanced features such as dual Octo-SPI, JPEG codec, etc. It supports Thumb-1 and Thumb-2, Saturated, DSP, FPU instruction sets.
2. STM32F7 are microcontrollers based on the ARM Cortex-M7F core. It was launched in 2014. The maximum clock is 216 MHz, static RAM is up to 1.4 MB, and Flash is up to 128 kB. It is fully pin-compatible with F4-series. It supports Thumb-1 and Thumb-2, Saturated, DSP, FPU instruction sets.
3. STM32F4 was the first series of microcontrollers based on the ARM Cortex-M4F core. It was launched in 2011. The maximum clock is up to 180 MHz. It is the first series to have DSP and FPU. It also has faster ADCs, full-duplex I2S and an improved real-time clock. It supports Thumb-1 and Thumb-2, Saturated, DSP, FPU instruction sets.
4. STM32F2 are microcontrollers based on the ARM Cortex-M3 core. It was launched in 2010. The maximum clock is 120 MHz, static RAM is up to 128 kB, and Flash is up to 1024 kB. It is fully pin-compatible with the F2 series. It supports Thumb-1, Thumb-2 and Saturated instruction sets.

STM32 Wireless

With STM32 Wireless ST adds in the portfolio a platform for wireless connectivity to the portfolio. It has a broad spectrum of frequencies and is used in various industrial and consumer applications.

It has features compatible with multiple protocols which allows it to communicate with different devices in real-time. Now, only two series belong to this group:

• STM32WB provides Bluetooth®LE 5.2 and IEEE 802.15.4 communication protocols, Zigbee® and Thread, which can work simultaneously or individually.

 

• STM32WL is the first series that support LoRa® communication.

So, that was all for today. I hope you have enjoyed today's lecture. In the next lecture, I am going to focus on the Nucleo Development board, as we are going to use that in our upcoming tutorials. Thanks for reading. Take care !!! :)

Ten Roofing Maintenance Tips For Lasting Roofline Results

Roofing issues can be overwhelming! Whether you have purchased a new home or have resided in a house for the past twenty years, roofing issues are here to stay. In most cases, these roofing issues include roof leaks, interior water damage, or missing shingles. These problems make roofing maintenance an imperative and attention-seeking job for many homeowners. Now, what to do in this case? Who to call? Well, there are many roofing maintenance firms out there, that can lend you a helping hand in resolving these issues. Also, some roofing maintenance tips can offer lasting results.

1. Examine Your Roof

While buying a new home or commercial space, your focus should be on the roof. The roof is the prime protective layer of your premises. Even if you have been living in the house for years, it is crucial to assess the condition of the roof periodically. Take a trip to your roof once a month. It would be better if experts inspect the roof and predict its life expectancy before you run around with a bucket for leaks.

2. Keep The Clutter Away

Though surrounding landscapes add beauty, the falling leaves and twigs can clog your gutter system. It would prevent proper drainage of rainwater or melting snow. Regular cleaning can avoid damage to your rooftop. While cleaning, you should prefer not to stand on your roof and keep a garbage bag or a bucket to collect all the debris. After picking up large pieces, wash your roof with a hose to flush out dirt. Trimming the trees is another option to minimize the natural debris.

3. Floss The Moss

Your haven cannot be at the mercy of moss. Lichen, moss, and algae need damp habitats to reproduce. Your roof becomes an ideal place for their growth. They have the potential to weaken your entire home. Once moss seeps between the shingles, it can damage the inside panel of the wooden beam that holds up your home. Since mosses have a persistent nature of returning, you would need a permanent professional solution.

4. Stimulate Ventilation

In the absence of proper ventilation, dampness and heat can aggravate roof rotting. The sheathing and rafting lose their effectiveness and threaten the protective layer of your home. It also increases the danger to your interior. Your roof can start seeing tiny holes, which can enlarge over time. Exposure to sufficient sunlight can nip the evil in the bud.

5. Roof Needs Sunscreen

The harmful UV rays and excessive exposure to the sunlight can devastate your roof lining. Speaking to a certified roof expert can mitigate the impact and provide an effective sunscreen solution for your roof.

6. The First Sign of Damage

Your roof is constantly attacked by the environment in the form of natural disasters, stormy weather, high temperatures, etc. Holes in the granules or discoloration of the shingles hint towards damage. The blistering shingles indicate that it is time for a replacement. Ignoring the first signs can lead to extensive damage and expensive repair work.

7. Trim The Trees

Though you love the greenery around you, your roof may not be fond of clinging tree branches. The overhanging branches can spell disaster for your roof. The trees may strike against the shingles and crush your roof during hurricanes and tornadoes. It would be a good idea to trim your trees to safeguard your roof.

8. Attic Insulation For Your Roof

Insulated rooftops lock in the heat during winters and prevent cool air from escaping your indoors during summers. It will help if you ensure effective insulation in and around your attic space. An insulated roof assures a healthier and more durable home that prevents ice damming, moisture build-up, etc.

9. Renew Flashing Seals

Weatherproofing your home is an integral part of roof protection. From time to time, your roof demands the replacement of caulking around the flashings, such as a chimney, vent pipes, etc. Withering caulks can lead to seepage and damage. Scrape the residues of the old caulk and apply new ones to seal the gaps.

10. Prepare For Winters

It is crucial to pay heed to roof maintenance at the onset of winter. Once it starts snowing, it would not be safe to climb up your roof. Your house may be exposed to bad weather if the roof gives in at any time during the winter season. You would have to wait for spring to begin with repair work.

Roof maintenance is serious work. You can take up the task yourself or contact the experts of roofing.

In Oil, New Health And Safety Standards Greet Industry Newcomers

The oil and gas industry is an intrinsically dangerous one. The nature of the work can lead to risks both for on-site workers as well as engineers and remote staff. As a result, Energy News asserts that fatalities and injuries on oil and gas fields are vastly underreported and that there may be a greater risk posed on such sites than ever previously thought. At the same time, advances in legal protections and engineering tools are making the job safer than ever - at least on a surface level. This is good news for engineers looking to carve out a career in the new world of eco-conscious hydrocarbon extraction.

Regulatory drive

Leading the charge towards better conditions for oil and gas workers is the US-wide litigation climate. Both on and off-shore, there are huge pushes towards making health and safety better for the numerous oil and gas workers in hydrocarbon states. Click2Houston highlighted the tragic death of one worker in Texas when a rig fell on him. During the July 2021 Houston oilfield accident lawyer action quickly brought restitution for the family involved, and in turn, brought in a greater level of health and safety scrutiny.

That level of scrutiny is being pushed at national and international levels. CNBC has highlighted how many oil and gas industry consultants are looking for novel ways at which to reduce gas flaring, a process estimated to produce 400 million tons of CO2 every year. Flaring in itself can be dangerous, and poorly monitored or delayed flaring can cause serious incidents. The curious note here is it’s not a direct engineering need that is pushing forward change, but rather the wider pro-environmental agenda being promoted by global governments. This is where novel engineering starts to make an impact.

Smaller impacts

In February, RigZone noted the expansion of wearable health and safety tech and how it was being issued to a wider range of rig employees. Manufacturer Transocean had developed the novel technology to provide a way for risk and repair contractors to undertake critical work while achieving it in a smart fashion - that is, safely, and with the absolute minimum interference both with the operation of the rig and the natural environment around it.

These devices are now brought into the wider engineering field upon rigs and offer a fantastic way for contractors to obtain assurance over their health and safety  The usability of this technology is fairly expansive, and reaches down to the actual drill floor of rigs, for instance. This presents a way for engineers and contractors to ensure their safety - at least until perhaps the most fail-safe way of conducting work makes its mark.

The automated wave

Automation seems to be coming for jobs in every area of industry, and especially so in engineering. Manufacturers are already well acquainted with the huge benefits that robots and their ilk offer in factories across the world - they have truly revolutionized how businesses think about productivity and the safety and role of their workers within that. Now, automation is coming for oil and gas.

According to the Houston Chronicle, automation is set to replace hundreds of thousands of oil and gas engineering jobs. Where roles will be concentrated is, predictably enough, in engineering. Robots can complete much of the simple yet critical work undertaken by contractors, and the onus of the employee will instead be shifting towards engineers. Upkeep of robots and related devices, the continued development of them in line with machine learning and AI, and assurance over their suitability for the job, will be crucial. Achieving this, however, will tick a huge box in the world of health and safety. By taking human beings out of the firing line of risk and danger in the first place, you make huge strides towards an overall improvement in the industry. With automation set to make huge strides by 2030 at the latest, oil and gas businesses are well prepared for the disruption of this technology and the new focus it will place upon engineers performing maintenance.

That, of course, brings its own risks - every engineer knows about the inherent dangers of the shop floor and working with moving parts. However, it takes away a lot of the eminent risk posed by oil and gas, from simple incidents such as unstable, crushing devices, through to the explosions and blowouts experienced from time to time by rigs across the planet. The best way to reduce risk is to remove exposure, and the myriad of engineering tools and techniques being deployed to enhance the health and safety assessment system in oil and gas is helping with this to a great extent. That's good news for engineers entering perhaps one of the most exciting fields there is.

Quick-Turn PCB Prototyping Service

Hi friends, I hope you are enjoying yourself a lot and having a great deal of fun. Our mission is to help you by providing quality content that meets your expectations so now today we will discuss all quick turn PCB prototyping services. We will discuss what is quick-turn PCB? What is a PCB prototype? What is a quick-turn PCB prototyping service? Quick turn PCB general Capabilities provided by companies. Benefits, applications and importance of quick turn prototyping service. Online Quick-turn PCB service providers and time measurements. So, let's get started:

Overview

• First of all, before starting the discussion we have to know about the meanings of the words used in our topic heading.
• We have to make grip on the meanings of quick turn, PCB, prototype, and service. After understanding the heading of the topic we will be able to understand core concepts.
• Quick turn: quick turn means something or someone that does things with great speed. Day traders use the quick turn technique to make a great deal of profit.
• PCB: PCB stands for the printed circuit board. It is a combination of conductive and insulating layers to perform specific functions that meet the demands of customers.

• The prototype is defined as an original model on which something is patterned. It is an early sample product built to test a process or concept.
• Now prototyping is a fundamental process for designing a new product on which electrical components will be patterned.

• Service: service is a system that is used to provide utilities like providing PCBs to the provided/desired location.

What is a quick turn PCB?

• Now after understanding the meaning of each term used in the heading we have to understand what is quick turn PCB? What is PCB prototyping and then we will discuss what is quick turn PCB prototyping service?

• A quick turn PCB means that a customer has their PCB faster than ever before.
• A quick turn ensures that a customer doesn’t have to wait for their product so it reduces delays.
• A quick turn also ensures that the manufacturing time for the PCB is reduced.

What is PCB prototyping?

• A PCB prototyping is to help designers to determine if there are any faults in the original PCB.

• It helps to improve performance and enhance efficiency.
• As prototypes are crucial so it is very difficult to make changes in the PCB which is manufactured.
• Quick turn PCB prototyping service means that providing PCB prototypes to the customers at a very fast speed, without delay.

Online Quick turn PCB prototyping service providers:

There are some online quick turn PCB prototyping service providers available. The one I am going to recommend is JLCPCB Fabrication House. JLCPCB provides this service of Quick-Turn PCB Prototyping for researchers so that they could test their projects in no time. Here are a few of the key points of this service provided by JLCPCB:

• They provide 1-50 layer PCBs with PCB Order Quality < 1m2 within 24 hours, while normally it takes 2-3 days for accomplishing such tasks.
• For PCBs with order quality between 1m2-5m2, JLCPCB takes around 3-4 days, while the normal time range is 5-7 days.

Few other Quick-Turn PCB suppliers are:

1. pcb4u.com

Location: Santa Clara

2. pcbway

Location: china Capabilities: preferred for minimum trace and hole size...etc.

3. aipcba

Capabilities: PCB fabrication, SMT services, PCB assembly services.

4. pcbunlimited

Location: US-based Capabilities: US prototype PCBs, PCBs panel share, offshore PCBs, PCB   design and layout services, PCB assembly services.

5. pcbgogo

Capabilities: FIXME(minimum trace and hole size...etc) 6. Other Quick turn PCB prototyping service providers are:

• Homebrew fabrication
• Breadboard killer
• Foundation technology
• Linksprite
• Kingfield electronics- CEM services
• Apex
• Cadsoft Eagle
• Exception group
• Bittele electronics
• Technotronic
• 4pcbassembly
• Sinomicro PCB
• Asian circuits
• Standard printed circuit board limited
• PCB train
• Euro circuit.....etc

PCB Capabilities - Quick-turn PCB

• Providing PCB prototypes within 24-72 hours is the quick turn PCB prototyping service.
• Companies do not have to look eye only at providing PCB at a fast rate but they don’t have to compromise on the quality of the product.

Items	General Manufacturing Capabilities	Companies general Remarks
How many layers	1-10 layers	For orders above 10 layers, contact to company.
Material	Aluminium or RF-4	For Flex, Rigid-flex, Metal-based (Aluminium etc.,), HDI, Halogen-free, High Tg, etc.
Maximum dimensions of PCB	500*1100mm (min 5*6mm)	For any size Greater than these Standard dimensions customers have to contact to the company
Tolerance in board size	±0.2mm/±0.5mm	±0.2mm for CNC routing, and ±0.5mm for V-scoring.
Thickness of the board	0.2-2.4mm	0.2,0.4, 0.6, 0.8, 1.0, 1.2, 1.6, 2.0, 2.4mm. For other thicknesses, customers have to contact to company.
Tolerance in the thickness of board	±10%	Normally “+ Tolerance” will occur due to PCB processing steps such as solder mask, electroless copper and other types of finish on the surface.
Board Thickness Tolerance(t<1.0mm)	±0.1mm
Minimum manufactural Trace	0.1mm	Min manufactural trace is (0.1mm), To save cost design trace should be above 6mil(0.15mm)
Min Spacing		Min manufactural spacing is 0.1 mm. To save cost it should be 6mil(0.15mm)
Thickness of outer copper layer	1oz/2oz/3oz(35µm/70µm/105µm)	Also known as copper weight. 35µm=1oz, 70µm=2oz, 105µm=3oz. For copper weight greater than 3oz customers have to contact the company.
Thickness of inner copper layer	1oz/1.5oz(35µm/50µm)	Inner copper weight as per customer’s request for 4 and 6 layers is 1-1.5 oz.
Drill Sizes	0.2-6.3mm	Min hole size is 0.2mm, max drill size is 6.3mm. Any holes greater than 6.3mm or smaller than 0.3mm customer will have to pay extra charges.
Annular Ring’s minimum width	0.15mm(6mil)	Min width for Annular Ring is 0.15mm(6mil), for pads with vias in the middle
Diameter of finished hole	0.2mm-6.2mm	The final hole diameter will be smaller than the size of the drill because of copper plating in the holes.
Tolerance of finished hole size	±0.08mm	For example, if the drill size is 0.8mm, the finished hole diameter ranges from 0.72mm to 0.88mm will be considered acceptable.
Solder Mask	LPI	Liquid Photo-Image able is the most adopted. Thermosetting Ink is used in the inexpensive PCBs
Width of minimum character	0.15mm	Characters of less than 0.15mm wide will not be Identify easily.
Height of minimum character	0.8mm	Characters of less than 0.8mm high will be too small to be identified.
Width to Height Ratio of character	1:5	In PCB silkscreen legends processing, 1:5 is the most suitable ratio for character width to height.
minimum diameter of PHH( plated half holes)	0.6mm	Design Half-Holes greater than 0.6mm for better connections.
Surface Finishing	HASL with lead HASL lead free Immersion gold	These are the tree most popular types of surface finish.
Solder Mask	Black, yellow, white, blue, green, red	No extra charge (Green, Red, Yellow, Blue)
Silkscreen	White, Black and None	No extra charge.
Panelization	Tab-routing with Perforation (Stamp Holes)V- scoring Tab-routing	For break-routing min clearance between boards should be 1.6mm and for V- scoring it should be zero.
Others	UL certificate, Fly Probe and A.O.I. testing, ISO 9001:2008	No extra charge.

Quick turn PCB service types:

PCB manufacturing service providers provide PCB quick turn services as

• 1-day quick turn PCB prototype
• 2 days quick turn PCB prototype
• 3 days quick turn PCB prototype
• 5 days quick turn PCB prototype
• 10 days PCB standard PCB prototype
• > 10 days PCB prototype.

Benefits of quick turn PCB prototyping service:

• Why do designers rely on prototypes instead of making a standard product? The answer to this question is that the prototype allows designers to test the functionality of the product in the design process at several stages and allow them to make adjustments according to their needs.
• Prototyping creates several advantages for customers and manufacturers as

1. Reduced timeline:

PCB prototypes help designers to complete their final product in these ways by saving their time.

• PCB prototypes complete the testing process at a fast rate. Without prototypes, flaws will waste a lot of time, lost revenue, and make a customer unhappy.
• PCB prototypes also save time by providing visual assistance to clients during the production process.
• At several stages, Prototypes help in testing before a full production run and save not only time but also minimized rework.

2. Reduced costs:

Prototypes help in reducing cost by avoiding the following issues:

• Catching design flaws
• Pinpointing cost-saving adjustments.
• Determining product adjustments.

3. Test components individually:

Designers use PCB prototypes for testing purposes. Most beneficial testing is achieved by testing simple PCBs. This type of testing is used to achieve the purposes listed below

• Testing design theories
• Breaking down complex designs.

4. Accurate reliable prototype:

Accurately designed reliable prototypes help throughout the designing and manufacturing process. Quality PCB prototypes allow designers to test the following aspects:

• PCB design
• Functional testing
• Conditional testing
• Final product design

5. Manufacturing review and assistance:

Using third party PCB prototyping services companies gain benefits but several things can go wrong in the design process that results in mistakes listed below:

• Excessive input
• Design blind spots
• Design rule check

Applications of quick turn PCB prototype:

Quick turn PCB has several applications in different industries. The applications in different scenarios are listed below:

1. Electronic designers who require high-quality boards use quick-turn PCB prototypes.

2. PCB assembly manufacturers designs products for the mass market use quick turn PCB prototypes to fulfil the needs of the market. 3. Designers also need to work on new ideas so they use quick turn PCB prototypes. 4. To provide the investors and clients the samples of their products designers need to show quick turn PCB prototypes.

Importance of quick turn PCB prototyping service:

• The role of PCBs in the best performance of electronic devices can not be denied.
• Electronic devises based companies heavily depend upon PCB prototyping firms and their efficiency of fabrication.
• However, to meet challenging deadlines, pressing schedules, and excellent quality PCB manufacturing, quick turn PCB prototyping service plays a crucial role.
• Let’s know-how companies benefit from their quick services and attain their business goals.

1. By providing quick turn services, companies increase their number of customers.
2. For the projects that need to be completed in a very short time, companies charge extra amounts. To attain the goals of extra profit, and everything related to PCB manufacturing should be perfect.
3. By providing reference prototyping services, companies built a trust relationship with their customers.

• Listed above are the benefits/ importance for companies providing quick turn PCB prototyping service. Quick turn PCB prototyping service is not only beneficial for companies but also for clients. Here is the importance of quick turn PCB service for customers.

1. By obtaining their prototype according to their demands, customers can complete their projects on time.
2. Customers do not have to waste their time in transportation and searching for PCB, they just have to order PCB and mention their requirements. Their desired PCB will be at their door.
3. There are also some cost benefits to customers in this service.

Quick turn PCB prototyping service time measurement:

• When an order is placed in the morning like at 9:00 am then at next business day noon, 1 day is completed and from noon after 24 hours, 2nd day is completed from your order.
• If an order is placed at 12:00 am then after 24 hours, 1 day will be completed. And next days will be counted similarly.
• For orders placed after 4:00 pm lost much of their time so placing late time orders is not suitable.

Conclusion:

When we think about PCB prototyping, it seems an additional step that will enhance the PCB cost and we consider it one that never is overlooked. But the reality is that it is best to weed out errors, flaws, and faults before proceeding to the final product. Prototyping helps in reducing cost, provides us with quicker turnaround time, and provides you with more efficient design. Now designers always prefer prototypes before developing new innovative ideas as well. They know about the value of time, cost and quality so suggest to students, engineers, and innovators to use prototypes. In the end, we can say that the value of PCB prototypes can not be neglected, they are as fruitful and helpful as standard PCBs.

That’s all for today’s article. I hope you have enjoyed the article and make grip on the understanding points. However, if you still face any skepticism regarding single-layer PCB then please feel free to leave your questions in the comment section. I will provide an answer to these questions to the best of my knowledge and researching skills. Also, provide us with your innovative feedbacks and suggestions you improve the quality of our work and provide you content according to your needs and expectations. Stay tuned! Thank you for reading this article.

C++ Variables & Constants

In the previous topic, we have discussed data types in C++ in detail. Today we will discuss variables and constants in C++.

A named memory location or memory cell is called a variable. The program's input data and its results are stored in variables during execution. During the execution of the program, the value of a variable can be changed but its name can not be changed.

Variables are created in random access memory. As we know that RAM is a temporary memory so data stored in it is also temporary. It can only be used during execution. When the program ends, the data stored in the variable is automatically removed.

In C++, all the variables are declared first:

• Name of variable: an identifier that represents a memory location.
• Address of variable: memory location of the variable.
• Contents of variable: the value stored in a memory location.

Variable Declaration:

• Variable declaration is the process of specifying the name and the type of variable.
• Before a variable is used, it can be declared anywhere in the program before its execution.
• Information is provided to the compiler about the variable by variable declaration.
• The compiler determines the memory required for each variable.
• After the declaration, the required memory of bytes is allocated to variables.
• Once the variable is declared then its name and data type can not be changed but its value can be changed during execution.
• For example, an integer required 2 bytes of memory but a character required one byte of memory. During execution int and char data types can not be changed but integer value can be changed from 5 to 9 and character can be changed from ‘f’ to ‘g’.

SYNTAX of declaring a variable in C++

• data-type: type of data that is stored in a variable.
• variable-name: tell us about the memory location of the variable.

For example:

int num1=25, num2=1000;

We can also write it like this:

int num1,num2; num1=25; num2=1000;

Types of Variables 

Types of Variables can be categorized in two ways

• Types of variables regarding data types
• Types of variables regarding the scope

Types of variables regarding data type:

Based on the data type of variable, there are the following categories of variables in C++

• int: holds an integer value i.e. 1, 2, 3, 50 etc.
• char: holds character values like ‘c’, ‘F’, ‘B’, ‘p’, ‘g’, ‘q’ etc.
• bool: holds boolean value true or false(0 or 1).
• double: holds double-precision floating-point value.
• float: holds single-precision floating-point value.

Example

Different types of variables can be declared as follow:

• int marks;
• float average;
• char grade;
• double salary;

Variables having the same data type can be declared in a single line. Each variable in line should be separated by a comma as follows:

int  a, b, c;

Types of variables regarding scope

When we discussed the Hello Program, we have seen the curly braces in the program like this:

int main { //Some code }

When variables are declared in curly braces then their scope is limited within these braces. The variable declared in main() function can not be used outside the main() function.

There are two types of variables based on their scope.

1. Global variable
2. Local variable

Global Variable

Global variables are always declared outside of any function.

• Their scope is in the complete program so can be accessed anywhere in the program.
• Can be accessed in the main() function, in the user-defined function and anywhere in the program.

Global variable example

Let us have a global variable myvar and it is declared outside of main. We can access the variable twice in the main() function easily.

#include <iostream> using namespace std; // This is a global variable char myvar = 'G'; int main() { cout <<"Value of myvar: "<< myvar<<endl; myVar='m'; cout <<"Value of myvar: "<< myvar; return 0; }

Output:

• Value of myvar: G
• Value of myvar: m

Local variable

• They are declared inside the curly braces of any loop or control statement, main function, user-defined function and their scope is limited only to the curly braces so they can be used only within the curly braces.

Local variable example

#include <iostream> using namespace std;   char myFuncn() { // This is a local variable char myVar = 'X’; } int main() { cout <<"Value of myVar: "<< myVar<<endl; myVar='H’; cout <<"Value of myVar: "<< myVar; return 0; }

Output:

• As we are trying to access the variable outside its scope so a compile-time error will occur.
• Local and global variables may or may not have the same name.
• We can see an example having the same name for local and global variables.

#include <iostream> using namespace std; // This is a global variable char myVar = 'X'; char myFuncn() { // This is a local variable char myVar = 'Y’; return myVar; } int main() { cout <<"Funcn call: "<< myFuncn()<<endl; cout <<"Value of myVar: "<< myVar<<endl; myVar='A'; cout <<"Funcn call: "<< myFuncn()<<endl; cout <<"Value of myVar: "<< myVar<<endl; return 0; }

Output:

Funcn call: X

Value of myVar: Y

Funcn call: X

Value of myVar: A

As the scope of the local variable is limited so the changed value of the variable is only responded for the global variable and the value of the local variable remained the same ‘ X’.

 

RULES FOR DECLARING VARIABLES:

There are some rules in C++ for naming variables

• Variable can be a letter, number and underscore(-).
• Variable’s first letter should be a letter or underscore. The variables 6second, $6payment and 5kg are invalid.
• In the variable name, blank spaces can not be added. ‘ my var’ is an invalid variable.
• Both upper and lower cases can be used. User-defined variables are written in lower and constants are written in upper case conventionally.
•  special symbols can not be used in variables as a name.
• Reserved words can not be used as a variable name. e.g int, for, while etc can not be used as a variable name.
• The no of characters in the variable should not be more than 31.
• A variable can not be declared for more data types. It should be declared for only one data type.

Variable declaration vs variable definition:

•  The variable declaration tells us about the part where the variable was first declared before its use.
• While variable definition tells us about that part where variable assigned memory location and value
• Variable definition and declaration did at a time mostly.

#include <iostream> using namespace std; int main() { // declaration and definition of variable 'b123' char b123 = 'a'; float b; // multiple definitions and declararions int _c, _d45, e; cout << b123 << endl; return 0; }

Variable Initialization:

Variable initialization is the process of assigning a value to the variable.

• = sign is used to initialize a variable
• The variable name is written on the left side of = and the value is given on the right side of =.
• Compiler allocated some memory to the variable when it is declared.

Syntax

type_ name variable=value;

• type_name: indicates the data type of the variable
• variable: name of the variable
• =  assignment operator used to initialize a variable
• value: value to initialize a variable

Example

#include <iostream> using namespace std; int main() { int a = 10; int b; cout << " value of variable a : "<< a; // static initialization cout << "\nEnter the value of variable b : "; // dynamic initialization cin >> b; cout << "\n value of variable b : "<< b; return 0; }

Output

value of variable a : 10 Enter the value of variable b : 18 value of variable b : 18

CONSTANTS IN C++

• Constants are those quantities that cannot be changed during program execution.
• It is used in the program wherever it is needed.

There are two common types of constants in C++

1. Literal constant
2. Symbolic constant

Literal constant

It is typed directly in the program and used when needed. Example

• cout<<” Hi guys”;

The following statement contains "Hi guys" string literal constant.

• int age = 19;

Age is an integer variable and 19 is a literal constant.

TYPES OF LITERAL CONSTANTS: 

There are 5 common types of literal constants are used in C++

• Integer constant
• Floating-point constant
• Character constant
• String constant
• Bool constant

Integer literal constant

It can be a decimal, hexadecimal or octal constant. Examples:

• 85         // decimal
• 0213       // octal
• 0x4b       // hexadecimal
• 30         // int
• 30u        // unsigned int
• 30l        // long
• 30ul       // unsigned

 Floating-point literals

Floating-point literal constant contain four parts

• Integer part
• Decimal part
• Fractional part
• Exponent part

Decimal forms include a decimal point, exponent or both. Exponent forms include integer part, fractional part or both

Examples

• 3.14159       // Legal
• 314159E-5L    // Legal
• 510E          // Illegal: incomplete exponent
• 210f          // Illegal: no decimal or exponent
• .e55          // Illegal: missing integer or fraction

Character constants

• These constants are enclosed in single quotes
• Upper case letters are stored in wchar_t type and lower case letters are stored in char type
• A character literal can be a simple character (e.g., 'x'), an escape sequence (e.g., '\p’), or a universal character (e.g., '\u0C0').
• The characters with backslash have special meanings. These characters with a backslash are given below.

Escape sequence	Meaning
\\	\ character
\'	' character
\"	" character
\?	? character
\a	Alert or bell
\b	Backspace
\f	Form feed
\n	Newline
\r	Carriage return
\t	Horizontal tab
\v	Vertical tab
\ooo	Octal number of one to three digits
\xhh . . .	Hexadecimal number of one or more digits

 

Example

#include <iostream> using namespace std;   int main() { cout << "Hello\tWorld\n\n"; return 0; }

Output

Hello   World

String constants

They are enclosed in double-quotes. It may contain

• Characters
• Escape sequence
• Universal character

String literals are used to break long lines into multiple lines.

Examples

"hello, dear" "hello, \ dear" "hello, " "d" "ear"

Program for defining a constant

#include <iostream>

using namespace std;

#define VAL1 20

#define VAL2  6

#define Newline '\n'

int main()

{

   int tot;

   tot = VAL1 * VAL2;

   cout << tot;

   cout << Newline;

}

Programs

#include <iostream> using namespace std;   #define LENGTH 5 #define WIDTH  20 #define NEWLINE '\n'   int main() { int area;   area = LENGTH * WIDTH; cout << area; cout << NEWLINE; return 0; } Program # 2 #include <iostream> using namespace std;   int main() { const int SIDE = 40; int area; area = SIDE*SIDE; cout<<"The area of the square with side: " << SIDE <<" is: " << area << endl; return 0; }

Bool constants

Three keyword literals exist in C++: true, false and nullptr:

• For Boolean variables, we have true or false literals/ constants.
• nullptr indicates the null pointer value.

1 2 3

bool foo = true; bool bar = false; int* p = nullptr;

Symbolic constants 

•  It is the Symbolic name given to the Symbolic values that cannot be changed
• A Symbolic constant PI having the value 3.141593 is used where needed and its value can not be changed.

There are two ways by which Symbolic constants can be derived.

1. const Qualifier
2. define Directive

The syntax for const Qualifier

const <Data_Type> <Variable_Name>

The syntax for define directive

<Return_Type> <Function_Name>() const

Example

#include <iostream> using namespace std;   const int a = 100;    // Const Variable   class TestConst { public: void display() const   // Const Function/ define directive { cout << "Value of a in the const function is " << a; } };   int main () { Test int1; int1.display(); cout << a; return 0; }

Comparison table for Constants and Variables

We have discussed above the clear understanding of variables, their types and some programs to make grip on the topic. We have also discussed constants and their types and some programs to make ideas clear. At the end, we make a clear comparison between constants and variables.

In the next section, we will discuss operators, expressions and comments in C++. Till then take care and have fun. Thanks for reading.

C++ Data Types

In the previous section, we have had an overview of a detailed Introduction to C++. Today, we will have a look at the data types in C++. It's our 2nd tutorial in the C++ programming language series.

In the previous tutorial, we have seen the basics of C++ and have also discussed a small code. We have discussed various programming terms in the previous tutorial and from now on, we are going to discuss those terms in detail. So, today's lecture is on Data Types in C++, let's get started:

C++ Data Types

A  data type defines the type and the set of operations that can be performed on the data. Various types of data are manipulated by the computer. The data is given as an input to the program. According to the program's set of instructions, data is processed and then output is returned on the screen. Before designing the actual program data, its type and operations performed on it are defined and used to process the data. At the start of the program, the type of each data value is identified. Various data types are provided by C++ and the computer’s memory allocates each data type differently.

Types of data types in C++

1. Built-in data types
2. derived data types 
3. user-defined data types

Built-in Data Types in C++

• Integral, floating-point and void data types are provided by C++ as built-in data types.
• The integral and floating-point data types can be treated with different types of modifiers.
• The size or range of data type is changed by using these modifiers.
• Short, long, signed and unsigned are various modifiers.

Three main built-in data types provided by C++ are:

1. Integral data type

• Integer data type: keyword int is used to express integer data type.
• It normally requires 4 bytes of memory and ranges from -2147483648 to 2147483647.

long b = 4523232; long int c = 2345342; long double d = 233434.56343; short d = 3434233; // Error! out of range unsigned int a = -5;    // Error! Used for storing only +ive  numbers and 0

Example

 

Character data type in C++

• Characters are stored by using character data type.
• Char is used to representing character data type.
• It normally requires 1 byte of memory.

• char test = 'h';
• As each character is assigned by a unique ASCII code which is an integer so that’s why characters are included in integral data type.
• When we store a character in memory, we actually store a unique numeric code associated with that character in memory.
• And when the computer is instructed to print characters, it basically prints characters associated with the numeric code.
• Here's the chart showing ASCII codes of alphabetical characters:

2. Floating data types in C++:

• Variables holding real numbers are defined by using floating-point data type. In C++  three data types are used to represent floating-point numbers.

1. float
2. double
3. Long double

float area = 64.74; double volume = 134.64534;

• Values having floating-point types are expressed in terms of precision and range.
• The accuracy in the fractional part of the value is precision.
• Range: it is for the range of fractions and numbers.
• The floating point number is stored as mantissa E or the power of 10.

3. Void data type

• The meaning of void is without any value and is used where functions do not return any value.
• A function does not take any argument when the void is used to define an empty parameter list and a function does not return any value when it is used to return value to the function.
• 0 bytes of memory is allocated to it and hence it cannot store anything. As a result, it cannot be used to declare simple variables but it can be used to define generic pointers.

C++ Void Pointer

#include <iostream> using namespace std; int main() { void* ptr; float f = 2.3f;   // assign float address to void ptr = &f;   cout << &f << endl; cout << ptr << endl;   return 0; }

Output

0xffd117ac 0xffd117ac

Bool and wcha_t:

• In C++, Boolean and wide-character data types are also used.
• Boolean values are defined by bool data type.
• Bool data type contains only 2 integers 0 and 1.
• False is represented by 0 and 1 is used to represent true.
• Only 1 bit of storage is required by bool data type.
• As it is stored as an integer so it can be considered as an Integral data type. The results of logical operations performed on data are represented by the bool data type.

bool cond = false;

• In addition to char data type, wchar_t is used to store 16- bit wide characters in C++. Large character sets are allocated with non-English languages so wchar-t is used to store wide characters.

wchar_t test = $# // storing dollar and hash character;

User-Defined Data Types in C++

C++ provides various user-defined data types

• structures, 
• unions, 
• enumerations and
• classes.

Structure, Union and class

Important features of the C language are structures and unions. Similar or dissimilar data types assigned a single name are grouped by structure and union. However, in C++ the concept of structure and union is modified by adding some new features to provide support to object-oriented programming. Class is defined as a new user-defined data type by C++ and it forms the basis of object-oriented programming. A class functioned as a template that can be used to define the data and functions that are included in an object of a class. Classes are declared using the keyword class. The object of the class can be created when the class is declared.

Enums in C++

A set of integer constants that are named and specify all the values that can be assigned to variables Enumerators are the set of these permissible values. For example, consider the statement.

enum Colour{red, green, blue, white};       // declaring an enum type

• In this statement, an enumeration data-type color (Colour is a tag name), consisting of enumerators red, green, blue and white is declared.
• These enumerators represent only integer values, so any arithmetic operation can be performed on them.
• By default, the first enumerator in the enumeration data type will have the value zero.
• The value of the next enumerators is increased by one. Hence,
  • the value of red is 0,
  • the value of green is 1
  • the value of blue is 2 and
  • the value of white is 3.

We can also assign values explicitly to enumerators as shown here.

enum country {US, UN=2, India, china} ;

• Value for the US is 0 by default in this declaration
• the value of UN is 2
• Russia is 3 and
• China is 4

When enum is declared then its variables assign the values specified in enum.

country country1, country2;

For example, consider these statements.

• Country1 Pakistan; // valid
• country2 China; // invalid

Int data types can not be assigned to enumerators because they are treated as integers.

Derived Data Types in C++

Derived data types are derived from built-in data types. C++provide 4 major derived data types that are

• arrays, 
• Functions, 
• references and
• pointers.

Array

• The set of elements having the same data type and same name formed an array.
• In memory, all the elements are stored one after another location.
• An index or subscript is used to access an element.
• The position of the element is indicated by the subscript value.

Declaring Arrays:

• Syntax to declare a one-dimensional array:

//intExp indicates number of elements dataType arrayName[intExp]; //declares array num containing 4 elements of type int: //num[0], num[1], num[2],and num[3] int num[4];

Accessing Array Elements:

• Syntax to access array element:

 

// intExp is used to specify position array Name[intExp]   //fourth element in array num num[3];

One dimensional array example

1. Initialize
2. Input
3. Output
4. Sum and Average
5. Find largest element value
6. Find the smallest element value

  // name of the constant is initialized const int arraySize=5;   double list[arraySize];   //initialize 7 variables int i=0; double smallest=0.0; double largest=0.0; double sum=0.0; double average=0.0; int maxi=0; int mini=0;   //1. Array us initialized for (i=0; i < arraySize; i++) list[i]=0.0;   //2. Give value for each element in array list, beginning w/first element for (i=0; i < arraySize; i++) cin >> list[i];   //3. Resulted value for each element in array list, beginning w/first element for (i=0; i < arraySize; i++) cout << list[i] << " ";   //4. Sum and Average elements in array list, and display for (i=0; i < arraySize; i++) sum = sum + list[i]; average = sum / arraySize;   cout << "Sum = " << sum; cout << "\nAverage = " << average;   //5. find largest element value in array list, and display for (i=0; i < arraySize; i++) if (list[maxi] < list[i]) maxi = i; largest = list[maxi];   cout << "\nLargest = " << largest;   //6. find smallest element value in array list, and display for (i=0; i < arraySize; i++) if (list[mini] > list[i]) mini = i; smallest = list[mini];   cout << "\nSmallest = " << smallest;

 Function in C++

• The function is used to carry out a specific well-defined task. It is a self-contained program segment.
• In C++ one or more functions can be used in a program and can be invoked from the other parts of the program when needed.

#include <iostream> using namespace std; int fact(int n); // function prototype   int main(){ int nv,ans; cout<<" Input n:"; cin>> nv; ans = fact(nv);// calling a function cout<<"Answer is:"<<ans<<endl; }

int fact(int n){  // int to another int int ans =1; for(int i= 3; i<= n; i++) ans *=i; return ans are; // function providebanswer to the caller }

function prototype, calling main program and the complete function definition shown in the above program

C++ Reference

The alternate name of the variable is a reference. So we can say that a reference is an alias for the variable in the program. Both variable and reference allocate the same memory location so they can be interchangeably used in a program. When we make changes in variables, these changes are also made in reference and vice versa. –  reference type variable in C++ is treated as a constant pointer that can be dereferenced.

• Constant reference type variable must be initialized first and can not be used as a reference to other variables.
• Ampersands (&) are used with reference type variables. For example,

int result  = 0; int &ref_result =  result; … ref_result =  100;

C++ Pointers

• The variable which can be used to store the memory address of another variable is called a pointer.
• Memory is used dynamically by pointers.
• In run time, memory can be allocated and de-allocated with the use of pointers which increases the efficiency of the program.
• Assignment and dereferencing are two major operations performed by pointers. Assignment operation assigns a value to the pointer and dereferencing takes reference by indirection technique.
• If ptr is a pointer variable with the value 7080,  and the cell whose address is 7080 has the value 206, then the assignment j = *ptr sets j to 206.
• The assignment operation j = *pta

• Pointers should be used with care because they are flexible.
• Used for management addressing and dynamic storage.
• Pointer arithmetic in C++ makes them more interesting than other programming languages.
• The asterisk (*) is used for dereferencing operation, and the ampersand (&) for producing the address of a variable. For example, in the code

int *ptr; int count, init; … ptr = &init; count =  *ptr

• single assignment statement can take place the value of two assignment operators.

count =  init;

Example: Pointer Arithmetics in C++

int list[10]; int *ptr; ptr = list;

• *(ptr+5)   is equivalent to list[5]   and  ptr[5] *(ptr+i)   is equivalent to  list[i]   and  ptr[i] –
• Domain type is not needed to be fixed.

So, that was all for today. I hope you have enjoyed today's lecture. In the next tutorial, we will discuss the variables and constants in C++. Stay tuned !!! :)