Campus - Blog #electronicomponent

LoRa Enabled GPS Tracker with ESP8266 & Nuvoton N032LE3AE

Thu, 21 Mar 2024 06:30:05 +0000

In industrial applications like logistics and inventory management tracking applications are used on a large level. GPS Tracking is also used in cab services, vehicle monitoring, human tracking, asset management, and public transport surveillance. However, traditional vehicle tracking systems that rely on GSM technology often encounter challenges in areas with poor signal coverage, limiting their effectiveness. The introduction of ESP8266 with a LoRa-based GPS tracker is the solution to this problem, where you can track your asset from any remote location in the world. In this project article we will build a LoRa Based Low Power GPS Tracker with ESP8266 and also look at how you can integrate the same with Nuvoton N032LE3AE module.

Components Required

NLN500 LoRa Module
Neo 6M GPS Module
ESP8266 Development Board
LM2596 Step-down Converter.
LoRa Gateway

LoRa GPS Tracker Working

In our previous blogs we have discussed how LoRa modules work and how they are ideal for low power wireless applications. To establish a connection between any LoRa module and The Things Network, a primary prerequisite is a LoRa gateway. Learn more about LoRa in IOT.

The project has simple working: the ESP8266 serves as the primary controller. It gets/collects information from the Neo-6M GPS Module, transforming Latitude and Longitude data into a LoRa Packet. This packet is then transmitted to the HPD13A LoRa module, establishing a connection with a nearby gateway. Once linked to a LoRa gateway, the packet is forwarded to The Things Network, where the raw data can be viewed on the Things Network Dashboard. To enhance functionality, we've implemented a webhook integration, allowing the position data to be seamlessly sent to Ubidots. Leveraging this information on Ubidots enables us to create a user-friendly map interface for visualizing our location data.

ESP8266 integrated with LoRa GPS Tracker Circuit Diagram is shown below

The connections for the Nodemcu LoRa GPS Tracker with ESP8266 are shown above in the circuit diagram. We use an LM2596 Step-Down Converter to lower the input voltage, ranging from 9-12V from a Li-Po Battery, to 4.2V. This lower voltage powers both the ESP8266 and the Neo-6M GPS Module. The LoRa module receives power from the ESP8266 at 3.3V and communicates through the SPI Pins. When uploading the code to the ESP8266, ensure the Neo-6M is disconnected since it is connected to the hardware serial pins of the ESP8266 during this process.

Setting Up End Node on The Things Network

To begin, sign up on The Things Network by creating either an individual or a student account, both are free. When choosing the LoRa Cluster, opt for the EU Cluster if you're not situated in North America or Australia. After successfully creating your account and completing the email verification, you'll gain access to the TTN Console, which is as shown below.

Click -> create application -> Enter unique application ID -> application name -> create.

When your application gets created go to add an end device.

Click -> Manually -> Enter parameters -> generate the DevUI, AppEUI, AppKey, -> complete the end device creation.

Switch to “Payload Formatters” once your device gets created

Choose "Custom JavaScript formatter" under the Formatters Type option, and insert the provided code below:.

function Decoder(bytes, port) {

var result = "";

var result1 = "";

var result2 = "";

for (var i = 0; i < bytes.length; i++) {

if(String.fromCharCode(bytes[i])=='X') {

break;

}

else {

result += (String.fromCharCode(bytes[i]));

}

var myArray = result.split(",");

result1=myArray[0];

result2=myArray[1];

return {

"position": { "value":1, "context":{"lat":result1.trim(),"lng":result2.trim()}}

};

}

Now that we've set up our end device on the Things Network, let's move on to programming the ESP8266. Open the device overview and copy the DevUI, AppEUI, and AppKey. Make sure to set the LSB order for DevUI and AppEUI, and the MSB order for AppKey.

Open the ESP8266 code (given at the end of the blog) in Arduino IDE and paste those IDs in their respective fields in the code.

After uploading the ESP8266 code, your device will begin transmitting LoRa data to The Things Network, and you can track this activity in the "Live Data" tab.

Ubidots Connection Setup For Data Visualization

Now that our data is reaching TTN, let's integrate a Ubidots Dashboard. Since our data includes Latitude and Longitude Coordinates, we can use Ubidots' Maps Widget. To begin, create a Ubidots STEM account and open your dashboard.

Select -> Devices Menu -> Select Plugins.

Search and select -> “The Things Stack” option

Leave the rest of settings to default and select the Ubidots Token as Default Token

Add the name and description of the plug-in -> Click on Create.

Your plugin is now active next click on the "Edit Plugin" option.

In the decoder settings, find the HTTPs Endpoint URL. This URL is where we'll set up the TTN Server to send data packets. Copy the Plugin ID, which is the part of the URL that comes after the /api/webhook/ section.

After completing the previous steps, scroll down to the Decoder Function panel and uncomment the following line of code.

//var decoded_payload = args['uplink_message']['decoded_payload'];

//Also, comment on the following two lines.

//let bytes = Buffer.from(args['uplink_message']['frm_payload'], 'base64');

//var decoded_payload = decodeUplink(bytes)['data'];

Select the "Save & Make Live" button. Our integration is now set up on the Ubidots side. Before going to TTN, navigate to the API credentials option in your profile menu and copy the default token this will be useful later on.

Open TTN Application -> Integrations panel -> Webhooks -> Add Webhook button.

Select the Ubidots plugin from the given options.

Further enter your Plugin ID and your Ubidots Token.

And that’s it your integration webhook is successfully created

After completing this integration, our LoRa device will transmit data to our TTN Server. Open your Ubidots dashboard, and on the Devices page, your device will be seen here.

Final step is to add a Map Widget to your dashboard. Select -> Data Tab -> Dashboards -> Create Widget Button.

Add new Widget -> Map

Select Add Marker Group.

Select your LoRa Device.

Customize the Map Trace settings as per your preferences and then click on the Save button.Top of Form

That's all! Now, all the location and tracking data from the LoRa device will appear on the map widget as location markers. You can also edit your dashboard by adding other widgets like tables to display appropriate coordinate values.

Working Of Our LoRA Based Low power GPS Tracker with ESP8266

The image below depicts the physical setup and shows how the latitude and longitude values are updated on Ubidots. The range of our LoRa GPS tracker relies on the availability of LoRa Gateways available in the area. As long as a gateway is within reach of your LoRa module, you'll be able to successfully send data to Ubidots.

ESP8266 Code

#include

TinyGPSPlus gps; String ProcData="Hello,World";

#ifdef COMPILE_REGRESSION_TEST

# define FILLMEIN 0

#else

# warning "You must replace the values marked FILLMEIN with real values from the TTN control panel!"

# define FILLMEIN (#dont edit this, edit the lines that use FILLMEIN)

#endif

// This EUI must be in little-endian format, so least-significant-byte

// first. When copying an EUI from ttnctl output, this means to reverse // the bytes. For TTN issued EUIs the last bytes should be 0xD5, 0xB3,

// 0x70. static const u1_t PROGMEM APPEUI[8]= {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; void os_getArtEui (u1_t* buf) { memcpy_P(buf, APPEUI, 8);}

// This should also be in little endian format, see above.

static const u1_t PROGMEM DEVEUI[8]= {0x36, 0x52, 0x05, 0xD0, 0x7E, 0xD5, 0xB3, 0x70};

void os_getDevEui (u1_t* buf) { memcpy_P(buf, DEVEUI, 8);}

// This key should be in big endian format (or, since it is not really a

// number but a block of memory, endianness does not really apply). In

// practice, a key taken from ttnctl can be copied as-is.

static const u1_t PROGMEM APPKEY[16] = {0x97, 0x7B, 0x4B, 0xA3, 0x9A, 0x8D, 0x33, 0x5E, 0x42, 0x13, 0x9C, 0x6B, 0xE9, 0xF9, 0x5E, 0xE1};

void os_getDevKey (u1_t* buf) { memcpy_P(buf, APPKEY, 16);}

uint8_t mydata[25] ;

static osjob_t sendjob;

// Schedule TX every this many seconds (might become longer due to duty

// cycle limitations). const unsigned TX_INTERVAL = 2;

// Pin mapping

const lmic_pinmap lmic_pins = {

.nss = 15,

.rxtx = LMIC_UNUSED_PIN,

.rst = 16,

.dio = {5, 4, LMIC_UNUSED_PIN},

};

void printHex2(unsigned v) {

v &= 0xff;

if (v < 16)

Serial1.print('0');

Serial1.print(v, HEX);

}

void onEvent (ev_t ev) {

Serial1.print(os_getTime());

Serial1.print(": ");

switch(ev) {

case EV_SCAN_TIMEOUT: Serial1.println(F("EV_SCAN_TIMEOUT"));

break;

case EV_BEACON_FOUND: Serial1.println(F("EV_BEACON_FOUND"));

break;

case EV_BEACON_MISSED: Serial1.println(F("EV_BEACON_MISSED"));

break;

case EV_BEACON_TRACKED: Serial1.println(F("EV_BEACON_TRACKED"));

break;

case EV_JOINING: Serial1.println(F("EV_JOINING"));

break;

case EV_JOINED: Serial1.println(F("EV_JOINED")); {

u4_t netid = 0; devaddr_t devaddr = 0;

u1_t nwkKey[16];

u1_t artKey[16];

LMIC_getSessionKeys(&netid, &devaddr, nwkKey, artKey);

Serial1.print("netid: ");

Serial1.println(netid, DEC);

Serial1.print("devaddr: ");

Serial1.println(devaddr, HEX);

Serial1.print("AppSKey: ");

for (size_t i="0;" i

if (i != 0) Serial1.print("-");

printHex2(artKey[i]);

}

Serial1.println("");

Serial1.print("NwkSKey: ");

for (size_t i="0;" i

if (i != 0) Serial1.print("-");

printHex2(nwkKey[i]);

}

Serial1.println(); }

// Disable link check validation (automatically enabled

// during join, but because slow data rates change max TX

// size, we don't use it in this example. LMIC_setLinkCheckMode(0); break;

/* || This event is defined but not used in the code. No || point in wasting codespace on it. || || case EV_RFU1: || Serial1.println(F("EV_RFU1")); || break; */

case EV_JOIN_FAILED: Serial1.println(F("EV_JOIN_FAILED"));

break;

case EV_REJOIN_FAILED: Serial1.println(F("EV_REJOIN_FAILED"));

break;

case EV_TXCOMPLETE: Serial1.println(F("EV_TXCOMPLETE (includes waiting for RX windows)"));

if (LMIC.txrxFlags & TXRX_ACK) Serial1.println(F("Received ack"));

if (LMIC.dataLen) {

Serial1.print(F("Received "));

Serial1.print(LMIC.dataLen); Serial1.println(F(" bytes of payload"));

}

// Schedule next transmission

os_setTimedCallback(&sendjob, os_getTime()+sec2osticks(TX_INTERVAL), do_send);

break;

case EV_LOST_TSYNC: Serial1.println(F("EV_LOST_TSYNC"));

break;

case EV_RESET: Serial1.println(F("EV_RESET"));

break;

case EV_RXCOMPLETE: // data received in ping slot Serial1.println(F("EV_RXCOMPLETE"));

break;

case EV_LINK_DEAD: Serial1.println(F("EV_LINK_DEAD"));

break;

case EV_LINK_ALIVE: Serial1.println(F("EV_LINK_ALIVE")); break;

/* || This event is defined but not used in the code. No || point in wasting codespace on it. || || case EV_SCAN_FOUND: || Serial1.println(F("EV_SCAN_FOUND")); || break; */

case EV_TXSTART: Serial1.println(F("EV_TXSTART"));

break;

case EV_TXCANCELED: Serial1.println(F("EV_TXCANCELED"));

break;

case EV_RXSTART: /* do not print anything -- it wrecks timing */

break;

case EV_JOIN_TXCOMPLETE: Serial1.println(F("EV_JOIN_TXCOMPLETE: no JoinAccept"));

break;

default: Serial1.print(F("Unknown event: "));

Serial1.println((unsigned) ev);

break;

}

void do_send(osjob_t* j){

// Check if there is not a current TX/RX job running

if (LMIC.opmode & OP_TXRXPEND) {

Serial1.println(F("OP_TXRXPEND, not sending"));

}

else {

// Prepare upstream data transmission at the next possible

time. unsigned long start = millis();

do {

while (Serial.available())

gps.encode(Serial.read());

}

while (millis() - start < 1000);

float flat="gps.location.lat();

float flon="gps.location.ln"g();

char charLat[20];

char charLong[20];

Serial1.print("Cords: ");

Serial1.print(flat); Serial1.print(" , ");

Serial1.println(flon);

dtostrf(flat, 10, 7, charLat);

dtostrf(flon, 10, 7, charLong);

sprintf((char *)mydata, "%s,%sX", charLat,charLong);

LMIC_setTxData2(1, mydata,25, 0);

Serial1.println(F("Packet queued"));

//int x="ProcData.len"gth();

//ProcData.toCharArray((char *)mydata,sizeof(mydata));

}

// Next TX is scheduled after TX_COMPLETE event.

}

void setup() {

Serial1.begin(9600);

Serial1.println(F("Starting"));

Serial.begin(9600);

// LMIC init os_init();

// Reset the MAC state. Session and pending data transfers will be discarded. LMIC_reset(); LMIC_setClockError(MAX_CLOCK_ERROR * 1 / 100);

// Start job (sending automatically starts OTAA too) do_send(&sendjob);}

void loop() {

os_runloop_once();

}

Conclusion

Thus we have implemented a LoRa based low power GPS tracker with ESP8266, you can track any of your device location using this setup in your project. The same process as above will be followed if you are building a GPS tracker using Nuvoton N032LE3AE. The LoRa-based Low Power GPS Tracker with ESP8266 gives multiple options and ways to enhance your IoT devices. Offering extended battery life, precise location tracking, real-time monitoring, cost-effectiveness, and versatile connectivity.

If you are looking for LoRa Module and GPS module from brands such as Smatech and Hoperf or microcontrollers from brands like Nuvoton and Espressif reach out to Campus Component an electronic components distributor today!

Get Started Now

Applications of Internet of Things in Electric Vehicle Chargers

Wed, 27 Dec 2023 07:24:00 +0000

The application of Internet of Things(IOT) is becoming increasingly beneficial in our everyday lives. One area where the IOT is beginning to have a major impact is in Electric vehicles, Electric Vehicle Charging, and its Infrastructure. With the introduction of IOT technology, EV Charging Stations become more efficient and convenient not only for drivers but also for service workers.

The application of IOT in electric vehicle charging infrastructure enables remote control and management, enabling charging stations to offer personalized services to EV drivers and communicate in real-time to unexpected events.

In this special article, we will explore the diverse application of IOT in EV chargers and how this synergy is propelling the Electric Mobility Revolution.

Benefits of IoT in the EV Industry

The integration of IoT technology in EV charging stations has become a hot topic in the industry because of its multiple applications, generating massive interest among companies seeking to adopt innovative solutions. This technology offers a range of notable benefits:

Improved User Experience:

Drivers gain access to real-time information about their vehicle’s charging status, battery range, and maintenance needs through smartphone apps or vehicle dashboards.
Empowers users to plan journeys effectively, find nearby charging stations, and monitor vehicle performance.

Enhanced Efficiency:

Real-time data collection by sensors in various vehicle components, including batteries, motors, and charging guns.
Analysis of data to identify patterns, anomalies, and areas for improvement.
Optimization of vehicle systems and energy usage, leading to improved energy efficiency and accurate range estimation.

Minimized Downtime:

Sensors continuously collect and analyze data from vehicle components to identify potential issues or malfunctions.
Timely maintenance or repairs based on the analyzed data minimizes extended downtime.
Proactive maintenance ensures EVs remain on the road for longer, reducing disruption to operations and enhancing productivity.

Cost-Efficient Operations:

IoT sensors analyze data from various vehicle components to detect anomalies or signs of potential failures.
Proactive addressing of issues before they lead to breakdowns or major repairs.
Reduction in downtime, minimized repair costs, and increased overall cost-effectiveness of EV operations.

IoT Applications in Electric Vehicles

Vehicle Connectivity:

Real-time data collection through IoT technology regarding various vehicle performance parameters such as battery health, tire pressure, and engine condition.
Continuous monitoring and analysis of data to ensure optimal vehicle operation.
Early detection of potential issues using advanced analytics and machine learning.
Predictive maintenance based on data analysis to reduce downtime and repair costs.

Predictive Maintenance:

Direct connectivity between EVs and charging stations through IoT, streamlining charging procedures and automating vehicle identification and billing.
Efficient charging processes and seamless payment procedures for EV owners.
IoT facilitates communication between EVs and traffic management systems, enabling intelligent traffic management.
Real-time information exchange about traffic light changes to optimize speed, reduce stop times, and enhance road safety.
Real-time data sharing about vehicle location and nearby facilities.

Energy Management:

Real-time data analytics through IoT to monitor and adjust energy usage in various vehicle components.
Fine-tuning energy consumption to extend the vehicle’s range efficiently.
Smart charging systems optimize the charging process, potentially reducing charging time.
IoT systems detecting idle states and adjusting power usage to conserve energy.
Improved range and convenience for EV owners through optimized energy consumption.

Fleet Management:

Real-time tracking of vehicle location and performance metrics using IoT technology.
Optimization of vehicle routing based on location, traffic conditions, and vehicle status.
Early identification of issues to prevent breakdowns and improve vehicle utilization.
Data-driven optimization of routing, minimizing unnecessary travel and reducing fuel consumption.
Significant cost savings and environmental responsibility in fleet operations.

Personalized User Experience:

IoT in electric vehicles provides custom in-car experiences for enhanced user satisfaction.
Automatic adjustment of user preferences such as music and climate settings.
Personalized driving environment promoting brand loyalty and positive word-of-mouth referrals.
Increased user satisfaction crucial in the competitive EV market.

EV Charging Management:

Remote monitoring and management of EV charging infrastructure through IoT.
Ensuring charging stations are available and functioning correctly when needed.
Real-time data on energy usage for accurate billing information and efficient energy management.
Dynamic load balancing to manage power demand effectively and prevent grid overloading.
Integration of renewable energy sources for sustainable EV charging.

Battery Management:

Real-time monitoring of EV battery health and performance through IoT.
Tracking temperature, voltage, current, and charge level for optimal battery operation.
Predictive maintenance through advanced data analytics to identify potential issues.
Optimization of the battery charging process, managing the charging rate for efficiency.
Scheduled charging during off-peak hours to reduce charging costs.

Challenges of Implementing IoT in Electric Vehicle Charging Stations

High Implementation and Maintenance Costs:

Installation of the IoT system poses a significant financial challenge.
Ongoing maintenance costs add to the overall expense, making implementation economically demanding.

Security Concerns:

Ensuring protection against hackers and potential security threats is a critical challenge.
Establishing robust security measures becomes imperative to safeguard sensitive data and user information.

Reliability Issues:

Ensuring proper charging of batteries is paramount, requiring a reliable system.
Challenges arise when the battery cannot be plugged in until fully charged, impacting the efficiency of the charging process.

Necessity for Regular System Updates:

Regular upgrades are essential for the charging station to accommodate the latest technologies.
Ensuring compatibility and functionality with evolving technologies is a continual challenge.

Lack of Flexibility:

The charging station's lack of flexibility hampers its adaptability to new technologies.
Regular updates are crucial to maintaining compatibility and ensuring optimal performance.

Addressing these challenges is necessary for the successful integration and sustained effectiveness of IoT in electric vehicle charging stations. Overcoming these obstacles will contribute to the seamless operation and evolution of smart charging infrastructure.

Conclusion

IOT in EV charging infrastructure have applications from optimizing energy consumption and vehicle performance to enabling personalized driving experiences and real time monitoring of charging processes, the IoT enhances operational efficiencies and the overall user experience. However, its challenges, such as cybersecurity and flexibility should be taken care of. Electric vehicles are an innovative step towards better control over air pollution, and the IoT solution plays a critical part.

We at Campus Component, provides a one-stop destination for all IoT modules and electronic components from top brands, you can explore a wide range of cutting-edge components and solutions. Empower your projects with quality electronic components available at Campus Component, your trusted partner in the world of electronics."

Get Started Now

BLDC Motors: Working, Features, Components, & Applications

Tue, 02 May 2023 09:58:42 +0000

Hello readers, in this blog we will learn about Brushless Motors also known as Brushless DC Motors or BLDC Motors. In this blog, we will discuss the working principle of BLDC motors.

What are BLDC Motors?

Brushless DC motors (BLDC)are widely used in various applications such as robotics, electric vehicles, drones, and industrial automation systems. Unlike conventional DC motors, BLDC motors do not have brushes, which makes them more reliable and efficient. Brushless DC motors are also known as electronically commutated motors (ECMs, EC motors).

BLDC motor is a permanent magnet synchronous electric motor which is driven by direct current (DC) electricity and it accomplishes electronically controlled commutation system (commutation is the process of producing rotational torque in the motor by changing phase currents through it at appropriate times) instead of a mechanically commutation system. BLDC motors are also referred to as trapezoidal permanent magnet motors.

Key Features of BLDC Motors

Brushless Operation

Unlike traditional motors, brushless motors use electronic communication, which eliminates friction, wear, and tear, making the motor reliable.

High Efficiency

BLDC motors produce rotational torque by changing phase currents through them at regular intervals, which eliminates the friction, wear, and tear of brushes like normal motors, making it highly efficient to use.

Lightweight Design

Absence of components like carbon brushes and a mechanical commutator inside the BLDC motors makes it significantly lighter than traditional brushed motors.

Long Lifespan

Electronic commutator allows low to no wear and tear of mechanical parts inside the BLDC motors. Also, brushless motors allow better heat dissipation due to winding placement on the stationary part. Both these features ensure a long operational life for the BLDC motors.

Precise Speed Control

Electronically commutated controller determines the exact time and sequence for switching current in motor windings; this precise timing enables accurate control of motor speed and torque.

BLDC motors often use Hall effect sensors or optical encoders to detect the exact position of the rotor, which allows the controller to adjust commutation and maintain the desired speed under varying loads.

Lower Noise & Vibration

Absence of brushes and mechanical commutator eliminates the fraction, resulting in lower noise. Precise and smoother current switching by the electronic commutator minimizes ripple and vibration.

Low Maintenance

Less mechanical wear and tear due to fewer moving parts, brushless operations make BLDC motors ideal for long-term usage, reducing maintenance costs.

BLDC Motor Components and Construction

A BLDC motor has three main components: the stator, the rotor, and the Hall effect Sensor.

Stator

The stator is the stationary part of the motor that contains the windings. These windings are made up of insulated copper wire and are arranged in a specific pattern. The stator provides a magnetic field that interacts with the rotor to produce torque.

Rotor

The rotor is the rotating part of the motor that contains permanent magnets. The magnets are arranged in a specific pattern, opposite to that of the stator. The interaction between the magnetic fields of the stator and the rotor produces rotational movement.

Hall Effect Sensor or Electronic Controller

The Hall effect Sensor is the brain of the motor. It is responsible for controlling the flow of current to the motor windings. The controller also senses the position of the rotor and adjusts the current accordingly to ensure smooth and efficient operation.

Working Principle of BLDC Motor

The working principle of BLDC motors is based on the interaction between the magnetic fields of the stator and the rotor. The stator produces a rotating magnetic field, which interacts with the permanent magnets on the rotor, producing a torque that causes the rotor to rotate.

The Hall Effect Sensor plays a crucial role in the operation of the motor. It controls the flow of current to the motor windings based on the position of the rotor. The controller senses the position of the rotor using sensors or Hall effect devices mounted on the stator. These sensors detect the position of the magnets on the rotor and send signals to the controller.

Based on the signals from the sensors, the controller adjusts the flow of current to the motor windings to ensure that the magnetic fields of the stator and rotor are properly aligned. This ensures that the motor operates efficiently and smoothly, without any loss of power or vibration.

Advantages of BLDC Motors

BLDC motors offer several advantages over conventional DC motors. Some of the advantages are:

Higher Efficiency

BLDC motors are more efficient than conventional DC motors due to the absence of brushes. This results in less friction and lower power loss.

Higher Power Density

BLDC motors have a higher power density compared to conventional DC motors. This means that they can produce more power in a smaller size.

Longer Lifespan

The absence of brushes in BLDC motors results in less wear and tear, making them more reliable and durable.

Low Maintenance

BLDC motors require less maintenance compared to conventional DC motors. This results in lower maintenance costs and longer service life.

Applications of Brushless DC Motor

Brushless DC motors (BLDC) use for a wide variety of application requirements such as

Computer hard drives and DVD/CD players
Electric vehicles, hybrid vehicles, and electric bicycles
Industrial robots, CNC machine tools, and simple belt driven systems
Washing machines, compressors and dryers
Fans, pumps and blowers.

Conclusion

BLDC motors are becoming increasingly popular due to their efficiency, reliability, and low maintenance requirements. The working principle of BLDC motors is based on the interaction between the magnetic fields of the stator and the rotor, which is controlled by the electronic controller. With their numerous advantages, BLDC motors are expected to play an increasingly important role in various applications in the future.

If you are looking for Best in standard motors and other electronic components, reach out Campus Component today!

BLDC Motors- FAQs

What are the Types of BLDC Motors?

Based on rotor and stator configurations and control methods, BLDC motors can be classified as Inner Rotor BLDC Motors and Outer Rotor BLDC Motors.

Can a BLDC Motor Run on AC?

No, Brushless DC motors can not be run directly on AC power; however, they can be operated indirectly with AC current with the use of a proper electronic controller or inverter.

Is the BLDC Motor Synchronous or Asynchronous?

BLDC motor is synchronous, where the rotor’s magnetic field rotates at the same speed as the stator’s rotating magnetic field.

Why are BLDC Motors More Efficient than Traditional Motors?

Brushless operation, electronic commutation, better heat dissipation, and precise control of current make BLDC motors more efficient than traditional motors.

Get Started Now

Arduino UNO Library for Proteus and other software

Tue, 02 May 2023 06:19:21 +0000

Are you an Arduino enthusiast who loves to experiment with circuits and codes? Do you use simulation software like Proteus to test your circuits before you implement them? If yes, then you must have faced the challenge of finding the right models for simulating the Arduino UNO board.

Don’t worry In this article, we are going to share Arduino UNO Library for Proteus and will see different Simulation software like Proteus.

What is Arduino UNO Library for Proteus?

Arduino UNO Library for Proteus is a simulation model for the Arduino UNO board. It is a software library that can be used to test your codes and circuits before uploading them to the physical board. The library is compatible with Proteus, making it an essential tool for Arduino enthusiasts.

Why to use Proteus?

The Proteus and other simulation software offers several advantages. Here are a few reasons why you should use it:

Saves time and money: With different simulation modules and their libraries, you can test your codes and circuits in simulation software before implementing them on the physical board. This way, you can detect and fix any issues before spending money on components and wiring.
Accurate simulation: It contains accurate simulation models for the Arduino UNO board and other controllers. This ensures that your simulation results are close to what you would get on the physical board.
Easy to use: Proteus is easy to use, even for beginners. It comes with clear instructions and documentation, making it easy to get started.

Download Proteus Software

Now let’s see how to install and use the arduino library to simulate in Proteus:

Download the Arduino UNO library for Proteus
In this downloaded zip file you will find two files, named as:

a) ArduinoUnoTEP.dll

b)ArduinoUnoTEP.idx

3. Now extract these two files and place it in the libraries folder of your Proteus Software.

4. Now, open your Proteus software and search for Arduino as shown in below image.

5. Now select this Arduino board and click OK

6. Now place this Arduino UNO board in your Proteus workspace and it look as shown in below image

7. Now we have our Arduino Board in proteus, double click this board in order to open its Properties.

8. Now here you can set different properties of the Arduino UNO board.

9. You need to upload the hex file of your Arduino code in the program file.

10. So, once you have the hex file of your code then upload it here and click OK.

And that’s it after successfully compiling the hex file, your simulation will start running and you can perform multiple functions as per the application you want.

There are Multiple Simulation software available such as:

TinkerCad
Eagle
Multisim
Matlab

You can also try these once you got hands-on Proteus.

Conclusion:

The Arduino UNO Library for Proteus and other simulation software is an essential tool for anyone interested in Arduino and Iot related projects.

For more such details and updates on electronics do follow regular our blogs and if you are looking to buy Arduino Uno and different microcontrollers reach out Campus Component today!

2. Arduino Gesture Control Bluetooth Speaker

Get Started Now

ESP -32 A guide for beginners

Tue, 02 May 2023 06:19:21 +0000

ESP – 32 is a low cost, low power microcontroller. It has integrated Wi-Fi, and Bluetooth. It employs Tensilica Xtensa LX – 6 microprocessor, Xtensa LX – 5 microprocessor or RISC – V microprocessor. It has built – in antenna, switches, power amplifier, filters and power modules.

Features:

CPU: Xtensa single core 32 bit LX6 microprocessor.

Operating: 160 MHZ

Memory: 32 KB
Connectivity:

Wi – Fi: 802.11 b/g/n

Bluetooth: v4.2 BR/EDR and BLE (shares the radio with Wi-Fi)

Peripheral Interface:

34 × programmable GPIOs

12-bit SAR ADC up to 18 channel

2 × 8-bit DACs

10 × touch sensors ( capacitive sensing GPIOs)

4 × SPI

2 × I2S interfaces

2 × I2C interfaces

3 × UART

SD/SDIO /CE - ATA /MMC /eMMC host controller

SDIO/SPI slave controller

Ethernet MAC interface with dedicated DMA and planned IEEE 1588 Precision Time Protocol support

CAN bus 2.0

Infrared remote controller (TX/RX, up to 8 channels)

Pulse counter (capable of full quadrature decoding)

Motor PWM

LED PWM (up to 16 channels)

Hall effect sensor

Ultra low power analog pre-amplifier

Security:

IEEE 802.11 standard security features all supported, including WPA, WPA2, WPA3 (depending on version) and WLAN Authentication and Privacy Infrastructure (WAPI)

Secure boot

Flash encryption

1024-bit OTP, up to 768-bit for customers

Cryptographic hardware acceleration: AES, SHA - 2, RSA, Ellipric Curve Cryptography (ECC),Random Number Generator (RNG)

Power management:

Internal low dropout generator

Individual power domain for RTC

μA deep sleep current

Wake up from GPIO interrupt, timer, ADC measurements, capacitive touch sensor interrupt

Interfacing an LED:

Connect the positive end of the LED to 100 Ohm resistor. Connect another end of the resistor to pin 18. Connect the negative end to GND.

Code:

/*ESP32 LED BLINK

#define 18

Void setup() {

//set pin

Pinmode (18,OUTPUT);

}

void loop {

delay (500);

digitalWrite(18,HIGH); //LED TURN ON

delay(500);

digitalWrite(18,LOW); //LED TRM OFF

}

Interfacing a switch:

Components:

1 push button switch

1 LED

2 Resistors 100 ohm

Jumper wires

Bread board

Circuit:

Check the switch connectivity with a multimeter. Place the switch on the breadboard (please refer to the image). Connect one pin to Pin 15 of ESP 32. Connect a resistor in series with Pin 18 and GND. Connect another pin to 5V of ESP 32. On the other side, Place a LED on the breadboard. Connect a resistor in series with Pin 19 and positive terminal of LED. Ground the negative terminal.

Working:

When we press the switch the circuit gets completed pin 15 gets 5V. This is a pull up mode. When the resistor is connected between +Vcc and switch it is in pull up mode. When the resistor is connected between switch and GND it is pill down mode. We can use any of the two.

As pin 15 gets a signal we turn Pin 22 high. Thus the LED glows.

Code:

#define 15

#define 22

void setup() {

//declare pin 15 as input

pinMode(15, INPUT);

//declare pin 22 as output

pinMode(22,OUTPUT);

}

void loop() {

//checkes the pin is high or low, condition statement

//if switch is ressed LED will turn on else will remain off

if (15==HIGH)

{

digitalWrite(22,HIGH);

}

else

{

digitalWrite(22,LOW);

}

Thus we have seen how to interface a LED and a switch with ESP 32. After going through this you would surely be able to use the GPIO pins.

Get Started Now