Embedded Life

Raspberry Pi Pico SDK Installation Guide for Windows PC

2025-03-24T23:00:00.004+05:30

This post is me writing down step by step process I followed to make a simple code compile in pico SDK.

What do we need to learn?

Understanding hardware.
Installation of softwares required.
Installation of pico sdk.
Understanding of important files for project compilation.
Creating your folder for project from above understanding.
Compiling your first successful code using SDK.
Programming the code to the development board.

What does Raspberry Pi Pico Hardware contains?

1. Micro USB Interface: Helps you connect to the computer during programming and also behaves like a virtual com port for serial communication.

2. Reverse Protection diode: helps to avoid wrong polarity during connections only if you power the device via VBUS pin and GND. VSYS pin is not going through this diode.

3. Buck Boost Converter 3.3V: it provides steady 3.3V output with max 800mA current. It gets used when you power the pico via USB, VBUS and VSYS. It does have maximum rating of 5.5V so you must not connect anything above that voltage. A battery input of 3.7V can be connected to this device. As per my understanding this regulator will maintain constant 3.3V for Pico usage up to 1.8V of battery input.

4. RP2040 Microcontroller: Its a Raspberry Pi Pico microcontroller. Where all your code will be executed.

5. Flash memory W25Q16: Its a 16Mbit Flash memory (16Mbit divide by 8bit = 2MBytes). This is where you code will be stored.

6. 25MHz crystal: Its required to run the RP2040 Microcontroller.

7. Boot Switch: This switch purpose is to press when you plugin the device on USB. RP2040 goes in bootloader mode where it becomes recognized as pendrive on PC. Then you can store output file of your code.

8. Debug LED: I call it as debug led as this is first thing you need to turn ON to know if your board which you recently purchased is working or no. It is available on gpio25.

Installation of software's required

1. Cmake tool: https://cmake.org/download/ - required for compilation.

2. Visual studio code: https://code.visualstudio.com/download - required for code writing.

3. Notepad++ : https://notepad-plus-plus.org/downloads/ - required because you don't want to be ancient coder. we use this for slower PC.

Installation of PICO SDK:

Download the library to your PC. https://github.com/raspberrypi/pico-sdk

Download as show in the above picture. And unzip in your project folder. Should look something like this.

You Need to Copy the SDK Path to the environment variables. Open the environment variable by typing in search

Follow the steps as shown in image below:

You're now ready with setup.

Understanding important files for compilation and folders.

There are total 4files and one folder which I found necessary to compile a project.

1. pico_sdk_import.cmake - this file is necessary for importing pico sdk in cmake build integration.

2. pico_extras_import_optional.cmake - this file imports optional libraries not done by pi, mostly third party into cmake integration.

3. CMakeLists.txt - this file contains instructions to build via cmake properly using pico sdk.

4. build - this folder is necessary to get the output files.

5. build/uf2 file - the file inside of build folder after compilation is a output file that you can copy paste into pico during boot mode.

Creating your first project folder. This is how your project should look like.

My basic code usually has 2 files.

main.h and main.c

As you keep on coding for many years you kind of catchup on working with same code over and over again so you kind of need to create libraries where all your custom functions are. I call it myfunctions.c

As I'm no expert in remembering the commands to compile I try to go through lot of codes online to understand what and how it works. So in windows I use something call bash programming its nothing but text you type in cmd prompt.

To build the code you need four commands:

The above code doesn't delete object files that are created from previous build so if you want to fully build the files again, you need to follow the below code:

So the above files are only so that you do not need to remember the command again and again. You can just copy paste it in custom project and use it again and again as long as build folder name and CMakeList.txt file is present along with these files.

What CMakeList.txt file contains?

For example you create a file called mygpio.c where you've made a custom function to work with gpio's.

You need to add in line 29 as :

add_executable(blink main.c mygpio.c)

Please note main.h files are not to be added in this CMakeList.txt as its not required but you do need to maintain them.

I've already created a sample project for you. So if you've downloaded them from gitlab.com

link here: Click here for repository download

pico-template is folder of interest.

Lets try by clicking Compile-rebuild.bat

NOTE:

If you get an error saying path doesn't exists. Delete everything inside build folder and try again.

Once the build is done. Go to the build folder and you must see the UF2 file if compilation was successful.

If you do not see any files. Thats probably because there is an error in your code. So compilation failed.

This is why PAUSE is required in scripting so you can look into what error it was. For example there was a syntax error in my code. This was the output during build.

It will tell you exactly where the error is. In this case its in main.c at line 20.

For a slower PC, notepad++ is recommended. You can see how the syntax looks like below:

The code doesn't show if there are any errors in notepad++. Only after compilation you would see error in build log.

Lets try the same in visual studio. All you need to do is open the directory within visual studio.

Here the only difference is that the code has auto completion feature where you type and it will show the function or variable to you which makes coding much simpler for larger projects.

Now lets copy paste the generated blink.uf2 file into RPI-RP2 Drive

Once you copy paste the file, you will get a eject sound from your PC and your board must start blinking.

Hope you enjoyed this tutorial. I was bursting my head understanding pico for years finding lot of tutorials and resources I could find and very few I found useful. Hope this help you complete your project.

All the best. Please do share me your feedback on above if you found something interesting or you have a better way.

ARIES 3.0 Flash Programming Issue with Arduino IDE

2024-04-24T00:02:00.003+05:30

This post is a discussion replication done which I discussed with Vega Team and resolved my issues with programming with Vega Processor THEJAS32. Thanks to the team with valuable support throughout the process.

AIM: To Program the ARIES 3.0 Flash memory via Arduino IDE. (View here)

The issue:

Materials Required:

Board Purchase was done at: Robu.in

You may also purchase the boards via vega website

I followed the procedure mentioned on the blog for programming the board on RAM only. This is to be done via XMODEM mode.

I've tried the hello world tutorial from above and it works perfectly on XMODEM mode. This is the screenshot:

and I'm also getting below message on Arduino once upload is complete. And the code runs fine. This is a best way to write code incase you want to learn writing codes or for a lab experiment.

This is a best way to write code if you are having lot of bugs and want to test out first before writing in flash. As you are aware flash memory read/write cycles are numbered. The current chip used on Aries 3.0 is Adesto Technologies - 25SF161B - SOIC8. Datasheet.

Off course this value will not make sense if you are using it for personal use, yes it will matter if same board is used in workshops where lots of students programmed these boards every year.

As I wanted to retain my code in memory and I wanted to use it for in field applications, flash programming was necessary for me.

So I followed the blog, and did my flash programming.

These were the settings I put in arduino IDE:

As mentioned in the blog, I've shorted J12. and was trying this. My process is as follows:

Step 1: Power the board.

Step 2: Add Jumper J12

Step 3: Press Reset. Device must go to flash mode here.

Step 4: Upload with above settings. ("Flash mode enabled, programmer vega flasher"

Step 5: Board was Stuck with below message:

Please note that I had never worked with Aries Before and I was clueless whether to press the reset or let it reset on its own.

So if I try pressing Reset the screen gets stuck here only:

and If I don't press reset the screen shows this message after like 30seconds to minute.

As for curiosity purposes, I tried checking what's happening on the Terminal. As the message said expected ACK; got C. I wondered what's that's like in terminal via hex view. I was still clueless.

Then as per discussion with Vega Team, Following steps I took.

Step1: Do not short jumper J12, and keep settings as below:

Step 2: Click on Burn Bootloader.

Successfully done, I assume the bootloader is now in RAM? To flash the firmware later? Device is not RESET or power cycled at any time right now as I'm assuming the data is in ram.

Step 3: Now short the jumper J12, and change the settings as below:

Step 4: Compile and upload using programmer

Step 5: Programmer asks for reset

It didn't work. Wondering if my steps are proper. I sent these to Vega Team regarding this as I was still getting issues.

So they asked me to do following tests, send a screenshot of terminal with & without jumper.

Without Jumper on J12 screenshot:

With Jumper on J12 screenshot:

It seems the Flasher was kind of restarting and no code was present.

Here I also found that in one post it was mentioned that programmer needs to be in flash mode during burning of bootloader. So even though my driver was not updated my procedure was still wrong.

The blog I referred to is here (check link)

In this blog the steps were as follows:

Step 1: remove jumper J12. & Press Reset.

Step 2: Tools -> Flashmode -> Enabled.

Step 3: Tools -> Programmer -> VEGA FLASHER.

Step 4: Tools -> Burn Bootloader.

After discussing with them on call I realized, I must not press the reset button.

The board must do the reset automatically when programming. so they asked me to update the firmware drivers for CP210x (drivers here)

Step 1: Download Drivers.

Step 2: Unzip driver.

Step 3: Go to Device manager -> Ports - > Update drivers of CP210x

Step 4: Select Driver location manually and click on next.

Step 5: done. Now open Arduino IDE and try again.

To the Season Finale:

Step 1: Connect the board and remove Jumper J12. Press Reset button.

Step 2: Do following settings as mentioned below. (once CP210x driver is updated). Select Flash mode: enabled, and programmer as VEGA FLASHER.

Step 3: You must click on burn Bootloader. This is the message you will get.

Step 4: Now put the Jumper J12. And do not press reset yet. (This is what I did)

Step 5: compile and upload your code via Programmer.

Step 6: See if this message appears. This message must appear within few seconds and you must not press RESET here like I did in past:

Step 7: Check if your code works by pressing reset. This time keep the jumper on J12 still ON.

This time the code didn't get erased and It worked brilliantly.

Step 8: From Now on, you must only use Sketch -> upload using programmer. The bootloader process is to be done only at startup.

To use back the RAM Version you can also follow the steps mentioned in first blog that I mentioned (View here)

If it really helped you, please do comment your feedback and share it with your friends and colleagues.

And thank you VEGA TEAM once again for all the support. #vegaprocessors #riscv

Precision delay function for Nucleo STM32F746ZG

2020-11-19T22:33:00.009+05:30

AIM: To teach you how to create a delay function using timer from STM32F746ZG.

Why we need to learn this topic?

Creating precision delays for projects.
Interfacing slow peripherals on i2c bus and RS485 bus. Specially in bit banging data to other IC's.
Blinking LED patterns and preventing switch de-bouncing.

Things required:

Nucleo F746ZG development board or STM32F746ZG microcontroller board.
ST-LINKV2 programmer. (Already present in this development board)
Inbuilt LED, or any LED you have spare on GPIO. (General purpose Input/Output)
Micro USB Cable to power up the development board.

Software required:

Atollic True Studio for ARM 6.0.0 and above.
Drivers for STLINKV2 (Gets auto downloaded upon connecting nucleo/ while installing atollic studio)

Documents required:

STM32F74xx Reference Manual (RM0385)
STM32F746ZG datasheet
Nucleo F746ZG manual

To create a precision delay we need to know few steps below so we can focus more on that section.

Finding clock frequency of the STM32F.
Finding the right timer and understanding to calculate reload value.
To create a universal delay function for our programs.
To select a GPIO pin and test LED blinking properly for delay function accuracy.

Flow chart for initializing timer 2:

Flow chart for interrupt service routine:

STEP1: Finding out default clock frequency.

To begin with timer, first you always need to know what is the clock frequency of the microcontroller. This exercise below is to find out what is the default clock frequency set in atollic studio template and how to initialize in main function.

Atollic studio embedded c template creates a default system clock function for you so lets try that shall we.

Lets create a new project by clicking on File - New - C project as shown below

Lets name this project as delaymstest. Select embedded c project and click next.

Now we need to chose STM32F746ZG by going to STM32F7 device category, then MCU sub category and then STM32F746ZG as show below. Once done click on next.

This MCU has huge space so lets not select nano-lib, lets consider standard library and click next.

Since there is a STLINKV2 programmer on nucleo board, lets choose STLINK as debug port and click finish.

Now lets check out system_stm32f7xx.c file to see what default clock frequency has been provided by atollic default template.

The frequency can be found at SystemCoreClock variable which is 16MHz.

Lets add SystemInit() function to initialize 16MHz clock in our code directly for now. I will not be explaining how to create different clock frequencies since its another whole topic to be discussed.

Lets clean up the code and add above SystemInit() function to main as below:

Now at this stage our clock is finally set. So lets move to step 2.

STEP2: Understanding Timer block diagram. In our case we have to use general purpose timer 2.

Main aim here is to understand how timer block works and what are they key Internal registers to be programmed for making timer work. We need to set/clear certain registers or individual bits inside register for configuring timer.

In ARM controller timer peripheral is OFF by default and needs to be turned ON. This is done by enabling clock using the RCC register.

To enable Clock for timer 2. We set TIM2EN bit from APB1ENR register of RCC registers.

Timer will not start without giving clock to its block. To enable clock for timer 2, we need to set last bit of APB1ENR. APB1ENR is a peripheral clock enable register.

RCC->APB1ENR = RCC->APBENR | 1;

RCC-> APB1ENR| = 1;

(Very imp: We have to do binary OR for APBENR since it also enables other peripherals.)

RCC-APB1ENR = 1; // unacceptable

Now 16MHz clock is now connected to timer block and it will start consuming little extra current then usual. Lets initialize Timer 2 block parameters.

Now to only perform delay operation we only need to focus on few registers of timer 2. Lets not study all.

Important registers are mentioned below:

TIM2->CR1 - Timer 2 control register 1

TIM2->CR2 - Timer 2 control register 2

TIM2->CNT - Timer 2 counter register

TIM2->PSC - Timer 2 pre-scalar

TIM2->ARR - Timer 2 auto reload register

TIM2->DIER - Timer 2 DMA/ Interrupt enable register

TIM2->SR - Timer 2 status register

First we reset both control registers to disable timer operation. This helps to reset previous settings incase you want to re-initialize the timer. We always have to reset the count register because it has to start from 0 at first time to get correct delay.

Then we reduce the clock further to even lesser frequency. This is because CPU is meant for Fast processing and clock has to be fast. But peripherals cannot be fast, they interact with outside world directly or indirectly.

Most peripherals work at 1/2 the rate of CPU clock frequency. For example purposes I've selected 255 as pre-scalar. You can choose anyone.

TIM2->CR1 = 0;

TIM2->CR2 = 0;

Then we reset the counter value so it starts counting from 0 on startup.

TIM2->CNT=0;

Now the important part. The counting frequency is adjusted using pre-scalar. Pre-scalar is a 16bit number that is from 0 ~ 65535 or 0x0000 ~ 0xFFFF.

The formula for calculating counting frequency is given below:

To select right frequency depends on what kind of timer you are building, if its very long delay timer the pre-scalar will be bigger number, in our case we are designing a standard milli second timer so lets choose randomly pre-scalar to 255 which is 0xFF in hex format. Any format is acceptable.

TIM2->PSC=0xFF; //Acceptable

TIM2->PSC=255; //Acceptable

(Please note you can choose any number you want for test, the count match interrupt will only happen if we match ARR register to get certain time in milli seconds or in seconds.)

Once pre-scalar is chosen we can easily calculate frequency at which timer will operate with above formula. Once we find out clock frequency of timer, we multiply it with minimum delay we prefer, in this case 1 milli seconds which is 0.001 second. Multiplying my least count which is 0.001 second to timer clock frequency we get reload value which we need to put inside ARR which is Auto Reload Register.

So Fclk = 16Mhz i.e. 16000000

pre-scalar = 255

then Fc = 16000000/(255+1) = 62500Hz

Tc = 1/62500 = 16 micro seconds.

That means for every 16 micro seconds timer count will go up by one.

If we want to make a 1milli second delay then our reload value will be???

reload value = FC x delay in sec.

If we want 1milli second as delay then

reload value = 62500 x 0.001 = 62.5

Since reload value can only be integer and not float rounding up will give us 63. Therefore

reload value (ARR) = 63

TIM2->ARR = 63; //acceptable

TIM2->ARR = 0x3F; //acceptable

We want to create an event or an interrupt whenever timer counter CNT reaches value equal to ARR register value which is 63 in this case. And to do this there are 2 steps.

Step 1 is to set UIE bit in DIER register, which will enable flag whenever timer counter reaches reload value.

Step 2 is to enable nested vector interrupt for timer 2 in NVIC (Nested Vector Interrupt Controller) which manages all interrupts of peripherals and CPU in priority order.

So our timer values are in place, lets work on interrupt side of things. To create an interrupt on match we need to enable update interrupt in DIER register.

TIM2->DIER=0x0001;

But again enabling interrupt isn't sufficient in ARM controller as the interrupt controller for timer 2 is OFF. to enable this we need to go into NVIC (Nested Vector Interrupt Controller). In NVIC, there is SET and RESET registers to enable and disable interrupts.

NVIC->ISER - Enables vector interrupts (array of 32bit number)

NVIC->ICER - Disables vector interrupts (array of 32bit number)

To set interrupt we need to find position of timer 2 interrupt w.r.t. acronym. Please check below:

Since TIM2 interrupt is on position 28, it means its in array location 0 i.e. ISER[0]. Any number after 31 will be in ISER[1]. (!!!VERY IMPORTANT!!!)

So we set

NVIC->ISER[0] = NVIC->ISER[0] | (1<<28);

NVIC->ISER[0]|=(1<<28);

We need to binary OR NVIC-ISER[0] with new value because we do not want to disturb other set bits in this register.

NVIC->ISER[0]=(1<<28); // Un-acceptable

So now our timer is ready for operation so lets turn ON the timer.

Once all above registers are set we only need to set control register CR1 last bit to turn on the actual timer functionality. Once you set this bit in CR1 , the interrupts will start happening every 1 milli second.

So timer 2 control register 1 becomes

TIM2 ->CR1 = 1;

To sum up, the code will look like this:

RCC->AHB1ENR|=1; //Enable timer 2

TIM2->CR1=0; //reset control register 1 to 0

TIM2->CR2=0; //reset control register 2 to 0

TIM2->CNT=0; //set counter to 0

TIM2->PSC=0xff; //prescalar f/256 = 62500hz

TIM2->ARR=63; //1ms

TIM2->DIER=0x1; //Update Interrupt Enabled

NVIC->ISER[0]|=(1<<28); //T2 interrupt enable

TIM2->CR1=1; //enable timer2

STEP3: Creating universal delay function

Now when timer interrupt happens, the ARM controller will call for interrupt service routine function. This is already predefined with vector functions which were created. Check below to find one:

startup_stm32f746xx.s contains all vector handlers for other peripherals too which you can explore here.

When interrupt happens for timer 2, it will jump to TIM2_IRQHandler function. Whenever timer interrupt happens UIF (Update Interrupt Flag ) in SR (Status Register of Timer 2) becomes 1. The next timer interrupt will happen immediately even before 1 milli second if you do not clear the UIF Flag inside IRQHandler function. The UIF flag needs to be cleared every time the timer interrupt happens.

We need to use the below function in our main c file for timer 2 interrupt handling.

void TIM2_IRQHandler(void)

{

//this function is called every 1ms

//your code here
//clear timer flag here

}

Timer update interrupt flag becomes 1 when interrupt occurs indicating there was an interrupt. But when it sets to one, it needs to be cleared else the interrupt will occur continuously and the system will get hanged. This flag is available in SR (Status Register) which you can see below:

If you are not using any other features of this timer then you can directly set as below:

TIM2->SR =0;

If you are using other features then you need to clear only UIF as show below.

TIM2->SR&= ~(1);

We need to reset only the last bit of SR register. This is possible by using AND logic and Negating the buffer. Negating 1 gives 0xFFFE and if we AND with TIM2->SR it will keep all other bits unchanged accept bit 0 to 0. And the simplest way to write that is above.

So our timer ISR routine will look as below:

void TIM2_IRQHandler(void){

//This function is called every 1ms

//your code here

TIM2->SR&=~(1); // clear update interrupt flag

}

But our task isn't over yet. We need to create delay function.

We know that this ISR will be called every 1 milli second. So now instead of creating for loop delays we need to work with while logic and decrement the delay value using the ISR routine.

Lets create a variable called delay. Lets initialize it with size of 32bit.

uint32_t delay=0;

Let's define a function which will set this delay variable independently. Example

void delayms( uint32_t n){

delay=n; //we set delay variable here with n value

while(delay); //we wait till delay becomes zero to exit while loop.

}

The concept of old for loops and while delay is similar accept here the decrementing happens outside the function independently and precisely.

Lets modify the ISR to decrement delayms variable to 0. But once it goes to 0, we don't want to decrement further and that goes like this below:

void TIM2_IRQHandler(void){

//This function is called every 1ms

if(delay > 0){ //decrements only if number is greater then 0

delay--; //decrements every 1 milli second

}

TIM2->SR&=~(1); // clear update interrupt flag

}

So this function concludes step 4. Its time for next step that is testing. How do we test if the timer is proper? For this lets do step 5.

STEP5: Initializing GPIO for LED blinking and testing our delay function.

My previous tutorial explains wonderfully how GPIO can be programmed for digital output. Please do visit.

Basic programming with Nucleo

Our target LED is LD2 which is on nucleo F746ZG board. If you check user manual for nucleo board there is schematic given on page 75 of nucleo 144 manual.

The schematic shows LD2 LED which is blue in color is connected to GPIO PB7.

To initialize GPIO we do the process below:

RCC->AHB1ENR=0x00000002; //Enable peripheral clock to GPIOB Port

GPIOB->MODER=0x00004000; //Set PB7 pin as output. LED (LD2 is on PB7)

GPIOB->OTYPER=0x00000000; //Set output pin as push pull type

GPIOB->OSPEEDR=0x00004000; //set output speed as medium speed

Now lets write the code as a whole.

#include "stm32f7xx.h"

volatile uint32_t delay=0;

void delay_init(void);
void delayms(uint32_t n);

int main(void){
SystemInit(); //SystemInit initializes clock at 16000000Hz
RCC->AHB1ENR=0x00000002; //Enable peripheral clock to GPIOB Port
GPIOB->MODER=0x00004000; //Set PB7 pin as output. Blue LED (LD2 is on PB7)
GPIOB->OTYPER=0x00000000; //Set output pin as push pull type
GPIOB->OSPEEDR=0x00004000; //set output speed as medium speed
delay_init();
/* Infinite loop */
while (1){
GPIOB->ODR=0x00000080; //Set PB7 bit high using ODR register
delayms(100);
GPIOB->ODR=0x00000000; //Set PB7 bit high using ODR register
delayms(100);
}
return 0;
}

void delay_init(void){
RCC->APB1ENR|=1; //enable peripheral clock to timer 2
TIM2->CR1=0; //reset control register 1 to 0
TIM2->CR2=0; //reset control register 2 to 0
TIM2->CNT=0; //set counter to 0
TIM2->PSC=0xFF; //prescalar f/256 = 62500hz
TIM2->ARR=63; //1ms
TIM2->DIER=0x1; //Update Interrupt Enabled
NVIC->ISER[0]|=(1<<28); //T2 interrupt enable
TIM2->CR1=0x01; //enable timer2
}

void TIM2_IRQHandler(void){
TIM2->SR&=~(1);
if(delay>0)delay--; //decrement every 1 ms if delay is greater than zero
}

void delayms(uint32_t n){ //simple delayms function
delay=n; //we set delay variable here with n value
while(delay); //we wait till delay variable becomes zero , then exit
}

Lets compile and upload the same using debug button.

If you do not know how to set a debugger in action. please read this link below:

Basic programming with Nucleo

Once the debug is enabled, debugger will program the new code into STM32F746ZG and the blinking will happen immediately.

I've then used Digital Storage Oscilloscope to see if delay is proper. And here are the results below:

As you can see the delay is perfectly 100ms as expected. But is it?

If you notice carefully there is few microseconds delay added up. Why is that? Lets analyze further.

As per old calculations of Auto Reload register,

(ARR) reload value = 62500 x 0.001 = 62.5

1 milli seconds is perfectly achieved at 62.5 but we cannot put float value in ARR. We can only put integer value. Since we chose by rounding up 62.5 to 63. I decided to use Logic analyzer to analyze timing even further.

I modified the code to blink LED 1ms ON and 1ms OFF using delay routine I created and below is the timing plotted by logic analyzer.

As you can see the timing is showing 2.032ms for blinking period. So 1ms delay is actually now 1.016ms and the reason was round up.

What if we round down??

What if we put ARR = 62. Lets check this with logic analyzer. Lets see if this plot is accurate.

Woooooow!!!!!!! Right?

The period is exactly close to 2.002ms. That means 1ms is now become 1.001ms which is very good compared to which we set before. So deciding which ARR value gives precise 1ms is only possible by doing multiple test via Digital Storage Oscilloscope or Logic Analyzer.

This is a nice example how we should test our delay routines using different methods for accuracy after coding is done.

You can make use of this function now to customize the delays for external chip communication via i2c and rs485 bus, bit banging drivers etc.

Congratulations! You have finally understood how delay function can be implemented for STM32F746ZG Nucleo development board. You can modify the same for implementing in seconds.

The reason I've not explained you to create delays in micro and nano seconds is because the interrupts have tendency to disturb other processes. Since this device is working at 16MHz making a micro second delay may cause lags in other parts of the code if you're implementing this on your project.

It's better to use for loops for micro and Nano seconds delays because they wont hang other processes.

Conclusion:

1. Successfully created timer.

2. Understanding the method of how to perform research on a microcontroller using help of documentation provided.

3. Reading and implementing on only the required peripherals and not the whole book.

If you like my post, please subscribe so you get the latest updates.

ALL THE BEST!!!

Nucleo - F746ZG basic programming using TrueSTUDIO 6.0 for ARM

2016-11-13T18:09:00.001+05:30

AIM: To teach you basic programming on Nucleo - F746ZG development board using TrueSTUDIO 6.0 and c programming. Also to write a simple code for LED blinking and test it on the hardware.

Things needed:

1. STM32F746 Nucleo - 144 F746ZG development board.

2. Micro USB Cable.

Working Summary:

Nucleo - F746ZG development board uses STMicroelectronics ARM Cortex M7 microcontroller STM32F746ZG. This development board contains onboard In - Circuit Debugger (ICD) called ST - LINK V2-1 which is used to program the microcontroller. This ICD section on development board has its own USB connector. The same ICD can be used to program other STM32F series microcontrollers. Connecting micro USB cable we can program the microcontroller with the help of PC Software. We will be using traditional c programming to program the board and turn LED ON/ OFF using IO Port settings. We will use the debugging feature to program the code and test internal registers for data we wrote. That's one good thing about ICD, yes you can see what has been written in internal registers.

To read more on Nucleo development board check this link below:

Nucleo - 144 F746ZG Development board user manual

You will need to download TrueStudio 6.0 Lite. For programming/debugging purposes lite version is good. But for using advanced features of ST-LINK for debugging pro version needs to be purchased.

TrueStudio 6.0 (860MB)

Reference Documents:

STM32F746ZGT6 Documentations

From above link you may need to refer these documents to help you write code better.
1. RM0385 Reference manual (18MB)
2. STM32F746xx Datasheet Production Data (3.2MB)

Step by step Procedure:

1. When starting Nucleo for the first time. There's demo code which blinks LED's with different speed and changing LED based on user Switch. So when you connect micro USB cable to the PC. This code will start executing and USB drivers will be getting installed automatically. If you do not see any LED blinking, check for Power LED which is Green. You do not need to worry about this at all. But if you want to check if the drivers are installed properly you need to go to Device Manager and check for STLINK Virtual COM Port. You can go to Device Manager by clicking on Start button and type in search bar for device manager. Device manager Shown below:

2. Now open Atollic TrueSTUDIO for ARM 6.0.0. You may be asked to upgrade to pro but you can continue using lite version after 5seconds.
After opening TrueSTUDIO it will look like this below. I have marked important buttons and locations for you in blue:

3. In menu, click on File, then new, and select c project. My workspace is in D drive. Select the following items below as you will need these settings to run c code on Nucleo.

4. Now after clicking next, you will see hardware settings screen. You need to select you appropriate target microcontroller and evaluation board. In our case, it is STM32F746ZG.

5. On clicking next, comes software settings. This is already done for you by software. But these were the settings I was using below:

6. Clicking next comes the debug settings. Here you need to select ST-LINK debugger. And finish the project setup.

7. You will now see project opened and main.c opened. Default code will be present inside main.c as default template.

8. So let's write code to blink LED LD2.
To turn any GPIO ON/OFF these are following things you should know:
1. Enable peripheral clock.
2. Set the GPIO as output.
3. Set the GPIO as push pull mode.
4. Rest settings is upto the application.
For reading more on GPIO of ST32F746ZG. Check page 195 of RM0385 Reference manual.

Check the code below:

9. After writing code for LED blinking. Rebuild the project by clicking rebuild button in menu.
If there are errors, check the code again. There should not be any errors. You can also click on console and see build process. If no errors, proceed by clicking on debug.

10. After clicking on debug. For first time you will get debug configuration setting. See if all debug configurations are OK. And then click on debug.

11. After clicking on debug, you should get this message on console. Which means STlink connected Successfully.

else if ST-LINK is not getting detected. You will get message like this.

12. Debug view is epic in its looks. It has debug menu, shows location of program counter, internal registers that you have set, even shows assembly level language of code you have written.
Clicking on RUN in debug menu will run the code directly. Else if you want to do step by step the click on step into button or use F5 function key.

Sometimes you get message in console like System interrupt and code doesn't run. I was trying to repeat that error but it came only once. I think it means debugger was not ready. In that case, re-launch the debugger and it will work like charm.

13. CONGRATULATIONS!!!
You have finally mastered the ARM basics. The Blue LED will be blinking now on your board. If you disconnect and turn the board ON using USB charger. Your code should be working. LED should be blinking.

You can download project workspace here below:

Well All the best programming with Nucleo - 144 746ZG development board. It's become my favorite board out of all development boards I've worked with. ARM Cortex M7 is very powerful processor. The features given in STM32F746ZG is capable enough for creating your own video game emulator and much more.
My main reason for trying this microcontroller out was because it has dedicated TFT driver and camera driver ports which helps a lot when comes to high speed processing.

Thank you Atollic TrueSTUDIO for such an amazing tool.
Thank you STMicroelectronics for the amazing development board.

If you like my post, please subscribe so you get the latest updates.

ALL THE BEST!!!

Arduino Due programming using Atmel Studio 6

2016-10-21T01:41:00.001+05:30

AIM: To teach you alternate way programming Arduino Due using Atmel Studio 6 and c programming. Also to write code for LED blinking and test it on hardware.

(NOTE: Concept applies for Atmel Studio 7 as well. You can also use c++ as Atmel studio supports both languages)

Things needed:

1. Arduino Due development board.

2. Micro USB cable.

Working Summary:

Arduino Due uses Atmel ARM Cortex M3 microcontroller ATSAM3X8E which has inbuilt bootloader. Bootloader is a program written inside microcontroller which helps in programming the microcontroller Flash memory without external programmer. The term BOOT means at startup the code from internal Flash ROM is read and stored to RAM and executed. This booting code then checks for the programming sequence which I will explain to you later. After programming sequence detected the device then goes into programming mode. Once programming mode is achieved, the PC application can be used to program the microcontroller. If programming sequence is not given at start up, the bootloader executes code from the Flash memory (This memory is the one we will program).

So in Arduino DUE you have two USB ports. One is arduino programming input atmega16u2 where you can program using arduino IDE. Second port is native USB Port. Now ATSAM3X8E contains two methods to write program into it which are:

1. Native USB Port.

2. UART Port.

To read more in details check arduino page here:
http://playground.arduino.cc/Bootloader/DueBootloaderExplained

Arduino IDE interacts with ATMEGA16U2 microcontroller which is preprogrammed to interface with ATSAM3X8E which then communicates with each other through UART. Therefore the routines are designed in such a way it looks like you are programming through Arduino IDE. But behind the scene there is another PC software running called Bossac.exe which is designed to interface with ATSAM3X8E bootloader code inside the microcontroller.

Since we do not want to interfere with the UART bootloader part since its already used for booting through Arduino programming port, we will use Native USB port. Below sections are important and marked which will be needed for programming purposes.

So before starting all these lets download software tools to begin with:

1. Atmel Studio 6

2. bossac.exe (Can be found in folder where arduino IDE 1.6.3 is installed. It is designed for Arduino Due boards) Do a search in that folder. I found it in this location below:

C:\Arduino15\packages\arduino\tools\bossac\1.3a-arduino\bossac.exe

3. batch file. (You need to create this using notepad app on your PC) Explained in details below.

Step by Step Procedure:

1. To start with this tutorial first we need to erase any program present in the memory. The procedure remains same throughout the tutorial. That is we keep Reset Switch pressed then Press Erase Switch, then we release Reset Switch, then we release Erase Switch. This completely erases the internal flash memory and then goes into bootloader mode which waits for bossac.exe interaction. Watch small video how it's done.

2. Open Atmel Studio 6 IDE Software on PC. Create New project. Select GCC C Executable Project, Enter project Title and location address. Click OK.

3. Select Device Family as SAM3, 32bit. Select ATSAM3X8E microcontroller. Click OK.

4. You will get this screen with default code already written in main file. The main file is duetest_ledblink.c here.

5. SystemInit() function is already implemented in one of the arm library which configures ATSAM3X8E to run at full swing that is 84MHz clock frequency. To check this function in more details you can go into the c file by right clicking on function SystemInit() and clicking on goto implementation.

6. To activate bossac programming tool we need to click on Tools, then External tools.

7. You need to add the following given below in the External tools window:

· Enter programming tool title. I wrote Arduino Due Programmer.
Enter the batch file location. My batch file name is duelink.bat and I stored it into D drive. So address is very short i.e. D:\duelink.bat
Apply the settings to show Arduino Due Programmer in tools menu.
· Click on OK when done.

8. Check if the programmer tool is visible in tools menu.

9. I have mentioned above about the batch file? What the hell is that? Well batch file contains set of commands which executes certain instructions given to the computer. We need create a batch file duelink.bat in my case. But you can name it as per your understanding term. As I told earlier we need to use notepad to create this file. So open notepad and type this below:

Since this are commands you must be wondering what does these numbers mean. The first line is the MODE command.

Mode instruction basically sets mode of operation for devices like printers or monitor or serial port. More detailed information below:

If you are still interested in learning mode here are few links:

http://www.easydos.com/mode.html

http://www.robvanderwoude.com/mode.php

The second line contains instructions given by bossac.exe which needs information like

· bossac.exe location
· which COM port to transfer
· sequence of programming like erase, write, verify, reset
· location of the bin file. (executable file which is generated after compiling the c code. In this case it is duetest_ledblink.bin)

· bossac instructions can be found by using command prompt and entering command bossac.exe -help

which pops the data below:

As you can see the example code also is given. We follow the same and create one for programming Arduino Due. The photo below explains how to write the same:

So now you know how to write the batch file. Save this notepad text file with extension .bat instead of .txt

Save it in the location mentioned in the IDE external tools setup.

So when you want to program, first erase the chip as mentioned at beginning of tutorial. Then click on tools, then click on Arduino Due Programmer. You will get this details below on output screen:

Remember. If your project name or the programming location changes, you need to change the batch file too as per that setup. Also keep the addresses small as possible because I was facing some issue due to long address.

NOTE: My program gets compiled inside atmelstudio workspace. So I copy the duetest_ledblink.bin and paste it in D: drive. You need to put the huge address to the batch file which is sometimes problematic. So just copy paste the binary file if the location link is greater than 20 characters.

Lets write simple code for LED blinking:

Onboard LED of Arduino Due is located on Port B pin 27.

· Compile the program.
· Put the Arduino Due board in programming mode.
· Copy paste the duetest_ledblink.bin to D drive. (Or location defined in batch file)
· Go to tools and click on Arduino Due Programmer.
· Check on output screen if successful. Do not interrupt during programming.
· Reset the board by pressing Reset.
· The LED will blink.
· Congratulations!!! You can start working on Arduino Due with famous c programming language.

You can download entire files done here below:

Well all the best programming with Arduino Due and our old c programming method. You will realize how powerful ARM ATSAM3X8E actually is. I will be updating more on peripheral interfaces like TFT and SD Card so be in touch.

Why write this article?

I'm big fan of c programming. And using Arduino IDE is kind of complicated since I have no control on some peripherals. I didn't know what registers to be set to enable some peripherals and what was the working. Even students now a day's who work with arduino straight doesn't know the basic of internal working. So for Viva they get blank. Doing code in c actually helps understanding the basics. I was totally confused how to work with due. So I researched a lot and found out solution which I share with you today.

If you like my post, please subscribe so you get the latest updates.

ALL THE BEST!!

Knock sensor using MMA7361 and Arduino UNO R3

2016-10-02T22:11:00.005+05:30

AIM: To be innovative with accelerometer sensors and teach you how to use them. (With CODE + Connection Diagram given below)

watch video here:

Accelerometers basically converts acceleration in x,y,z axis to analog output. Normally they give voltage output or I2C interface based which can be directly processed.

We will use MMA7361 (NRND). This sensor converts acceleration to voltage which we will take advantage of to sense tap or knock.

Normally safest tap is measured by me is 1.53g = 1.5 x 9.8 m/s2 where g = 9.8m/s2 acceleration due to gravity.

How do I achieve m/s2 from output voltage of the sensor?

1. Read ADC.
2. Convert ADC raw value to output voltage value of accelerometer which is given below:

3. Remove Zero g offset which is 1.65V.
4. Then divide the result by sensitivity. But the result is still in g. To remove g from calculation we multiply by 9.8m/s2 which gives us proper formula below:

Things needed:

1. Arduino UNO R3
2. USB Charger + Arduino UNO USB cable.

3. SSR Relay 40A. (Ratings depends on your load of LAMP. I had 40A in my stock.)

4. Lamp with Switch. (Shown in connection diagram)

Connection diagram:

Download the Arduino code and needed images here:

DOWNLOAD HERE

1.Why tap / knock sensor?

Sensors basically makes everything easy. I have a large desk and sometimes the plug is too far to turn the lamp ON/OFF. Specially for the people who age and have hard time moving around to turn on just a lamp. So basically just tap or knock on the desk and turn the lamp ON/OFF when needed. This actually helps sometimes when you are too busy to get up from desk just to turn on the lamp or this same can be modified for aged people who live alone.

2. What are we using to build hardware?

We will make this tap sensor using arduino UNO and MMA7361 module.

MMA7361 module is an accelerometer which can sense motion in all 3 axis. For this application we need only z axis (i.e. +z axis and - z axis since vibration is sinusoidal in nature you can choose any one)

3. Hardware working?

We need to place MMA7361 sensor module on the desk. I glued it at the center of the box I chose. We need to note which axis will get affected by knock. Say for now the desk is on -z axis side. So when I tap the desk, the sensor will detect signal in +/- z axis direction. This can be used for sensing knocks. The sensitivity of knock can be setup easy. You do not want to turn lamp ON/OFF accidentally. So what we do is adjust the trigger point little higher then normal taps we do on our desk. I found out the good knock shock is around -1.53g where g is 9.8m/s2. Knock to turn ON the lamp. Knock to turn OFF the lamp. Lamp is linked to Arduino with a Solid State relay.

4. What to take care of during coding?

a. Since you are coder you definitely bang your head or hands on the desk while you frustrate.

b. You also sometimes lean towards the computer and keep your elbows on the desk, which can produce sensing in z axis.

c. Also books, pens creating noise in sensing region.

In other words, false triggers often will happen if you are not observing. We fix this issues by limiting the knocks with parameters and eliminate few noises but not all are possible.

d. Even arduino is so fast in reading analog input that sometimes single tap can toggle the lamp many times. I have found tap usually falls in 20ms range. Analog ADC can sample at much faster rate hence creating multiple toggles. To prevent this we add delay of 300ms after trigger sense.

Since you will be working with 230V AC line on lamp side. Be careful!!!. You can harm yourself if you touch the AC lines.

Making of the lamp pictures:

1. You need to open the box and remove the switch wires. This wires need to be connected to SSR (Solid state relay).

2. You also need to find Live and Neutral lines of AC Line and connect USB charger to it. So all together 4 wires will come out. If its a lamp with choke, then keep the choke in the circuit.

3. I soldered even the USB Charger. The SSR screws were jammed so I soldered on screws. After soldering them cover them with insulation tape, or for long life use heat shrink tubes.

4. Drill hole sufficient enough to take out 4 wires. Make sure you seal the hole with glue gun.

5. Connect everything and place properly. Also cover the SSR screws in glue to avoid shock. While glue the MMA7361 make sure you do not let glue touch any pins. I debugging for hours why the sensor was not working but apparently there is some parasitic capacitance effect with the glue and the pins. You may also glue arduino and usb charger so it doesn't move around.

Final outcome:

All the best and thank you for reading.

If you like my post, please subscribe so you get the latest updates.

3 Channel Simple PWM Example for AT89C51 (Revision 2.0)

2015-05-25T23:48:00.003+05:30

AIM: To teach you how to implement basic PWM modulation on AT89C51 with the help of timer and work with RGB LED example code.

Basics:

AT89C51 doesn't not have a PWM peripheral built in. So here the concept of creating one comes in. We know how to make Digital outputs high and low through coding. Lets make use of this and timers to our advantage to create one.

We have learnt how Pulse Width Modulation (PWM) works. The clock Pulses are given in a time frame with divisions in time frame (resolutions = 32/64/128/256/512/1024) which gives us attenuated voltage which we will be using to control RGB LED brightness which in return gives colors. We will be using 256 Bit resolution because many of the free available palettes are with 256 combination support.

Like for example this can be done like shown below:

PWM brief idea (click to zoom)

So after going through this you must be wondering how to make this counts to set high and low on a Output pin. So this is when precision timer comes into picture. Lets understand how to configure this timer to our advantage. Check this article

In this case let us consider Tmax = 10mS. (10 milli seconds).
So for each division to happen accurately. You must adjust the timer for :
timer interrupt = Tmax
resolution
so we get
timer interrupt = 10mS
256
= 39.0625μS

So calculating using timer preset value for 39μS we get 0xFFDB (65499) which we have to put into timer TH0,TL0 registers.

Now main question arises in your mind is timer is done, pwm is understood but how to know which color will come on RGB LED according to our pwm counts?

Well it is simple then you think!

What I do is I open any sketching tool or paint tool. Then I open color palettes. Check image below

Palettes idea (click to zoom)

So you choose your color in the big multi-color square block. And you will get color counts like this below:

Palette as color generator (click to zoom)

I want a purple color to be displayed on my RGB Led. So my counts from above is as below:
Red counts = 154,
Green counts = 65,
Blue counts = 235.

So lets start making one. First we need a schematic layout for RGB LED driver and controller. I have taken some trouble making this one better then I used to make. Hope you like this type schematics.

The microcontroller can be as you want. Since this theory can work on any microcontroller you like eg. PIC,ARM,AVR,STM and so on...Even for arduino board UNO R3, you just need the RGB LED driver section. Power is taken by UNO through USB so you do not require much circuitry there.

WARNING:The current calculations are given below in schematic diagram itself. For higher current RGB LED's you need to calculate maximum limits of the hardware first. UNO and other hardware doesn't support current above 300mA. USB power can go upto 500mA max. Doing so you may end up burning the device. Be careful there. Offcourse PTC will protect if you put a right one for higher current.

Schematic diagram:

Schematic diagram (click to zoom)

Bill of material:

Bill of material with element14 order codes (click to zoom)

RGB LED I chose for this application. (Source: Internet)

CODE for RGB Led Driver in C (Keil uVision):

/*start of code*/

c code (click to zoom)

/*end of code*/

Download whole project here
In the above code. P3_0 behaves as PWM channel for RED, P3_1 behaves as PWM channel for GREEN, P3_3 behaves as PWM channel for BLUE.

Maximum period (Tmax) is given by Timer interrupt interval multiplied by 256 which is maximum resolution.

Note that: pwm_r, pwm_g, pwm_b contains values that you need to load to attenuate the load properly. You can increase the timer interrupt period to even higher. I kept it low frequency to eliminate digital noise. (Ringing in mosfet) (needs extra RC circuit across Drain and source)

APPLICATIONS IN MIND RUSHING!!!!!

1. You can make now a PWM based RGB Pixel display! 1 bit resolution screen. This time you add luminosity control.

2. This same with different circuit can be used as PWM based 10x10 matrix RGB color display to create a tiny color display of 10x10 resolution.

3. You can create a PWM based temperature based RGB Color Display. Where LM35 can be used to read adc input and then you can convert the temperature to fixed color to know temperature presets.

4. You can create PWM based PC terminal based RGB color display by linking pc terminal and sending color code through Visual C based PC Software with palette on it.

5. You can make a PWM based Mood Lamp with RGB Color vision which changes color on your mood. (Sounds/ vibration can be used to sense the tension or happiness)

You are now ready to make your own!!!

If you like my post, please subscribe so you get the latest updates.

Thank you for reading,
Macjan Camilo Fernandes

Where do I start learning embedded systems?

2015-04-22T09:20:00.002+05:30

Welcome to embedded world!!!.

There are super vast topics in embedded systems and hobbyists mostly aim for project specific. I assume you have already done some circuits before and you know most of the pin conventions of the IC's and other components. We like to know why this IC functions the way it's not suppose to happen rite. Because most IO's are fixed logic. Embedded deals with custom logics so same IC can do many stuff. We call them microcontrollers. Microprocessors is way beyond hobbyists and I do not recommend for beginners.

But now so many learning kits come with simply language SDK. Like raspberry pi. But think twice when you chose.

To turn LED on we do not need high end super processors or microcontrollers either. You should know what's inside that controller IC.

So these are some questions you need to go through before doing your first embedded project.

1. Do you really want to do this?

2. Is it reliable? Are you paying too much for this?

3. Am I really doing this for learning purpose or selling purpose?

(selling then stop there itself. If it's available in circuit diagram on some page of a book it's already patented or not your original product)

4. Are you qualified or studied enough to do this?

(sometimes you need high end peripherals like graphics LCDs, camera etc which you may hardly know and there are 95% chances you will fail)

5. Is it matter to do this project is open source?

Some embedded microcontrollers need software which needs to be paid before doing any compilation of the code. That is even worse. Open source ideally recommended.

6. If you are making it as a product then will it sell?

7. How cheap is it?

8. What's it's market value if existing?

9. How much certifications it has? (CE, BIS)

10. Are you ready for selling atleast 200+ per day or even 1000+ in a month on demand?

There are many other questions besides these. Your idea always exists in other part of the world so make sure you do research before starting New product. When making hobby projects find out if these already done projects need extra work to work it out. Or it doesn't even work.

When comes to microcontrollers vast language used is C language. Easy to understand. But learn Assembly language and do not use it. Unless your coding is just for simple purpose. Sometimes assembly language is useful when comes to saving a lot of programming space and where speeds are concerned but trust me you do not need to learn that far.

Make a proper decision of selecting a controller. Sometimes the application is so small but controller can handle 30 of these processes. So eg. Say you want just one RS232 port and few peripherals. Do not buy controller with 4 UARTs. Cost/power/space everything will increase.

Some engineers are so stupid they use high end microcomputers like raspberry pi, Beaglebone and so on for relay switching which even arduino uno can do.

Then comes interest. Everything to start and get completed needs interest. This is hard. I have lost interest in so many projects just because I knew I couldn't do them. Sometimes one problem just couldn't get solved like eg. Timing issue, Mis fire, communication not 100% working and more. These issues always happen. Even brilliant minds get errors and issues. That is why when solving they become genius in coding.

You will need a personal computer to burn programs and even a programmer device. So make sure you chose the right one. If you got AVR programmer and you had interest in 8051 based system. Oh hell! Well obviously if u know logic you can implement these on AVR. And vice versa. Learn to understand these logics.

Always remember what you have learnt from the past issues and fixes. Remember behind success there is a lot of hard work involved.

My Experience!

For the first time I learnt 89C51 which is very easy to learn. Maybe even you can start with this. Logic is same for every microcontroller but once you are clear with the peripheral blocks/logical blocks inside microcontroller then you can code any new controller which is just launched. Arduinos are great because they are meant for hobbyists. So if u understood the logic the same 89C51 based project or avr project can be implemented on arduino. You just need to map the pins properly or map the logic properly.

Learn how to modify codes for different libraries/ devices/ or different PCBs. It's a good practice. Learn to interface for keypad, LCD, LEDs, speaker, potentiometer, and so on. It will take atleast 2years if you are quick learner to understand microcontrollers. You will be ready to program anything you want. All if you got interest.

Learn where you can. If you can't buy tools you can join a course or ask your friend to gift you one. Why waste money on t-shirt or shoes or any apparel for gifting when you can ask you arduino or something similar to continue your liking. Be a good friend of tools. I got super collection of tools needed to do my projects.

Thank you for reading.

And all the best to you ahead!

If you like my post, please subscribe so you get the latest updates.

C code to convert Integer into ASCII HEX

2015-03-28T12:12:00.004+05:30

UPDATED: 18-04-2024

Why I made this post???

I was working with debug uart communication. And I wanted to know hexadecimal representation of values of certain data. Problem was I did not get any easy conversion tool. Besides SPRINTF. So this little code will help you convert integer (uint8_t) to ASCII HEX during debugging applications.

This code can be used in your embedded firmware to do conversions and print to terminal specially for those microcontrollers which has no support for sprintf function or has very less memory to support sprintf function.

eg:
char datab[20];
converthex(datab, 100);
printf("%s\n",datab);

Ans: 0x64

CODE:

void converthex(char *data, unsigned int a){ //definition

unsigned int temp =a;

int digits=0,set;

int i=0;

unsigned int x;

unsigned int mask;

mask=0x0f;

while(temp!=0){

temp=temp/16;

digits++;

if(digits>1)mask=mask<<4;

}

set=digits;

set--;

data[i]='0';

i++;

data[i]='x';

i++;

temp=a;

while(digits!=0){

x=(temp&mask);

x=x>>(set*4);

if(x<=9)data[i]=0x30+x;

else{

data[i]=0x41+(x-10);

}

digits--;

i++;

temp=temp<<4;

}

data[i]='\0';

}

you can download code blocks project here

I've also updated various ways you can use this function in code blocks example this way you can use it in your embedded system c code as well.

If it really helped you, please do comment your feedback and share it with your friends and colleagues.

C code to convert floating point value to ASCII array

2015-03-27T13:20:00.002+05:30

I was working on gyro/accelero sensor which required calculations to be done precisely.

This some compiler will not give me support to use my favourite SPRINTF function which makes everything easy to print floating point value in ascii format on uart. So I sat down using DEVC and made cody myself to print floating point. This code usually helps when you want to print on LCD.

Hope this helps you.
Example:
char datab[20];
convert(datab,-256.126,2);
printf("%s",datab);

CODE:

You can download DEV C project here
Thank you for reading.

If you like my post, please subscribe so you get the latest updates.

Taking address of "buffer" may require an extended pointer for this device

2015-03-26T20:32:00.001+05:30

Microchip's MPLABX IDE X16 Compiler gives problems on dspic33 series microcontrollers when doing memcpy or memset. Warning is generated such as : Taking address of "buffer" may require an extended pointer for this device for these functions. These also helped me to reduce errors for SD CARD functions, string functions which include UART communication. But I have noticed the warnings doesn't effect the code.

So I wrote my own functions for replacing these two:

A) MEMCPY function replacement: Just declare these functions in your code. Will work.

void my_memcpy(void *x, const void *y, unsigned int length); //Declaration

void my_memcpy(void *x, const void *y, unsigned int length)
{
while(length--)
{
*(unsigned char*)x++=*(unsigned char*)y++;
}
}

B) MEMSET function replacement: Just declare these functions in your code. Will work.

void my_memset(char *d, int value, unsigned int num ); //Declaration

void my_memset(char *d, int value, unsigned int num )
{
while(num--)
{
*(char*)d++=value;
}
}

Hope This helped you too.

Thanks for reading.

Generic LCD Driver for 16x2/ 16x4/ 20x2/ 20x4 HD44780 LCD Controllers

2014-12-31T00:54:00.003+05:30

Embedded Life introducing simple LCD interfacing using generic LCD driver designed to fit into any microcontroller you want to with some changes at IO level.

As inspired by arduino libraries. Now in todays world we go very low on details on how things really work in background. Sometimes speed of achievement is necessary to achieve certain goals in software and hardware.

Generic LCD driver is designed in such a way that you have to edit only few necessary changes to make it work on your microcontroller. So since basic IO functions differ for different microcontrollers and speed too, that is why I've not defined the basic IO functions. But examples will be updated every day for different microcontrollers.

So normally as I see this system as, the microcontroller is the brain here. Which hence communicates to LCD controller to display certain data you want to display.
The library functions contains 2 types of level functions:
IO Level functions where you have to modify them as per your microcontroller port syntax with some minor changes and providing some delay too (delay varies for different microcontroller frequencies).
API functions are designed for you to get access to microcontroller at top level and not to care whats going on below this layer. This are the functions you need to use in your coding.

(DOWNLOAD GENERIC LCD LIBRARY FROM HERE)

You need to know how the library works:
There is file inside called lcdconf.h
In this files,
LCD_LENGTH :Value is set to 16 for 16x2/16x4 LCD's. Value is set to '20' for 20x2/20x4 LCD's.

LCD_HD44780 needs be set to 1. Right now it supports only one type LCD controller but soon options to control LCD's with different controllers will come.

LCD_LINES: Value is set to 2 for 16x2/20x2 LCD's. Value is set to 4 for 16x4/20x4 LCD's.

INTERFACE_8_BIT is set to 1 by default. Means the controller databus will work in 8bit mode. If this is set to 0 the Interface will work in 4bit mode.

BACKLIGHT_CONTROL is set to 1 by default. If you are not using IO powered backlight control you can set it to 0.

In lcd.c there are IO level functions and API level functions.

API Level Functions:

LCD initialization function://Initializes lcd 8bit mode/ 5x8 character/ 2 Lines select/Display On
void api_lcd_initialize(void);

LCD print function: //prints data of given width on line, at cursor position.
void api_lcd_printf(BYTE line, BYTE cursor, CHAR8 *databuffer, BYTE data_length);

where,
line = unsigned char value for line (1,2,3,4) .
cursor = unsigned char value for cursor position (1,2,3....20).
databuffer = data pointer to the string to be printed. (max 16 or 20 per line)
data_length = number of characters in the string to be printed. (max 16 or 20 per line)

LCD clear function: //clears the LCD screen for given line.
void api_lcd_clearf(BYTE clear_sel);

where,
clear_sel = line to be cleared completely. (1,2,3,4)

LCD custom character setup:// The CGRAM data array is saved for your customized characters
void api_lcd_custom_character_ram(char *cgram);

where,
cgram = contains array of 64bytes of custom character data. (Max 8 custom characters. 8 bytes each for 1 character.)

LCD backlight control: //Can turn on/off the LCD backlight to save power.
void api_lcd_backlight(BYTE state);

where,
state = B_ON for backlight on, B_OFF for backlight off.

NOTE: THE LIBRARY WILL COMPILE WITHOUT ANY ERRORS FOR FIRST TIME. BUT THE FUNCTIONS WILL NOT WORK WITHOUT ASSIGNING PORT PINS ACCORDINGLY. SO KINDLY CHECK EXAMPLES HOW TO DEAL WITH PORT MAPPING. IT WILL GIVE YOU IDEA. ONCE THIS IS DONE. YOU WILL HAVE NO ISSUES TO PLAY WITH LCD.

You can Map the ports by checking out examples given below download.

Thank you for reading,

Macjan Camilo Fernandes

I²C for beginners made easy (Generic Study)

2014-12-22T21:28:00.002+05:30

AIM: To teach you how I²C works and how to implement it on any microcontroller to support your application.

BASICS: (THINGS YOU NEED TO KNOW)
1. I²C - means Inter - Integrated Circuit.
2. This protocol is designed by Philips Semiconductor known today as NXP Semiconductors.
3. You can have multiple masters/ multiple slaves but maximum 7 devices for one master.
4. It works on 2 signals provided Grounds of all devices are connected together. The two signals are SCL and SDA. Also VCC and GND in some cases are used for off board connectivity.

SCL - Serial Clock.
SDA - Serial Data.

Many Devices support I²C bus. Specially EEPROMs, most of the microcontrollers, IO expanders, ADC's and DAC's, Sensors and even Displays and so on.

How does the signals look like?
Whenever we need to study any protocol first thing you need to read is signal diagram. Most datasheets show the Frame Diagrams.

RED REGION: If SCL and SDA lines are both at logic 1. The I2C bus is assumed to be at idle state. That is no data gets received or transferred.

START REGION: To start communication from idle we need to set SDA logic level to 0 and after some delay set SCL to logic level 0. This region is also called S.

DATA TRANSFER REGION: To transfer the data, while SCL is at logic level 0 the data has to be set bit wise on SDA line. The transfer is done bitwise (Bit by Bit) from MSB to LSB. (MAX = 8bit).

Once data has been set on SDA line. The SCL line is bring up at logic level 1 to transfer data to slave or master and then SCL line is bough to logic level 0 to set the next bit for transfer. Once transfer is done for all data, the master must change the SDA line as input to read the SDA line for ACK (Acknowledgement) and NACK (No Acknowledgement). During ACK/NACK the SDA line of MASTER has to be input and also SCL line must be at logic level 1 and then 0 to transfer the ACK/ NACK bit to master. Once this is done the MASTER SDA line can be set as output.

ACK: To read this Set master SDA line as input (for bit banging mode only, for master with i2c feature don't need to change SDA line as input). Set clock SCL to logic level 1 and then logic level 0. (Clock delays are same throughout all data transfers). (The signal is at logic level 0 on SDA). This region is called A.

NACK:To read this do same as ACK. (Here the signal is at logic level 1 on SDA). This region is called N

SR: (Also known as START REPEAT) This is same as START REGION but with some changes.

This part of signal mostly occurs during reading from slave. After NACK is received, the slave releases the SDA line and so the master controls it back. Hence to make start repeat work the master must set the SDA line to logic level 1 after some delay turn the SCL line to level 1 and so after some delay repeat the START REGION procedure. Yes offcourse if the master has inbuilt i2c bus then it will take care of this. But in bit banging mode you need to know all of this. This region is called SR.

STOP REGION: Once all data has been transmitted or received the SCL line must be bought to logic level 1 and then after some delay you must bring the SDA line to logic level 1. This region is also called as P.

How do you implement all this regions into c code? This is where all your knowledge comes into play. This code below is for master i2c bus.

void i2c_idle(void)

{
    SCL=1;    //busy condition
    SDA=1;
    delay(100);
}

void i2c_start(void)
{
    SDA=0;
    delay(50);
    SCL=0;
    delay(50);
}

void i2c_repeatstart(void) //repeat start
{
    SDA=1;
    delay(50);
    SCL=1;
    delay(50);
    i2c_start();
}

void i2c_stop(void)
{
    SDA=0; //N_ACK = 1 so set SDA to 0
    SCL=1;
    delay(50);
    SDA=1;
    delay(50);
}
void i2c_clock(void)
{
    SCL=1;
    delay(10);
    SCL=0;
    delay(10);
}

void i2c_ack(void) //ack i2c
{
    BYTE ack;
    ack=SDA; //acknowledge
    i2c_clock();
}

This above method is bit banging mode. The minimum delay above I used produced 20uS(delay(1)). You can change this for suiting your purpose. To be on safe side I have kept min limit to 20uS which is max. 50KHz bus speed.

The i2C bus can still go low upto 5Mbps in speed. The above test is done for 100KHz bus speed.

Ideal for bitbanging mode in 8051 microcontrollers.

I have made tutorial for EEPROM 24LC512 interfacing to AT89C51/52 . You can check out the code files by clicking here

(Examples with more interfacing peripherals coming soon)

 
Thank you for reading. 

Macjan Camilo Fernandes

EEPROM Interfacing with 8051 using i2c (AT89C4051/AT89C51/AT89C52/AT89C52) Generic Driver

2014-12-21T18:13:00.000+05:30

WARNING: THE CODE HAS BEEN TESTED AND WORKING SUCCESSFULLY.

AIM: To make EEPROM interfacing to 8051 microcontrollers simpler with few functions pretested and no need further debugging. (AT89C4051/ AT89C51/ AT89C52/ AT89C55/ AT89S4051/ AT89S51/ AT89S52/ AT89S55 devices supported).

BRIEF DESCRIPTION:
Interface Type: I2C Bit Banging mode.
EEPROM Type: 24LC512 (Tested)
Max Size on Flash Memory: 564Bytes.
RAM use: 20Byte.
Microcontroller: AT89S52

TEST CIRCUIT:( KINDLY NOTE THE CIRCUIT ONLY INCLUDES I2C AND EEPROM CONNECTIONS. MICROCONTROLLER CONNECTIONS ARE NOT SHOWN)

How to assign pins inside code???

1. Go to eeprom.h
2. change this area highlighted in red here. Assign pins properly.

3. Include this files into your project.
4. Include eeprom.h in main.c
5. Make use of the functions given below and you are good to go.

Functions Added:

The functions below are the only functions you need to know for data reading and writing. The user has access to all 0x0000 to 0xFFFF addressing space.

To write data to specific address use this instruction:

void api_eeprom_write(BYTE addr_h,BYTE addr_l, BYTE data_b);

where,

BYTE addr_h = higher order of address.
BYTE addr_l = lower order of address.
BYTE data_b = data to be written.

No Return Value.

The size of all above variables is 8-Bit or 1Byte.

How to use it???
unsigned char test=0x26; //8bit variable
//enter test variable on eeprom at location 0x1022
api_eeprom_write(0x10,0x22, test);

BYTE api_eeprom_read(BYTE addr_h,BYTE addr_l); //Read data from specific address

where,

BYTE addr_h = higher order of address.
BYTE addr_l = lower order of address.

Return Value = Data at that address 8bit

How to use it???

unsigned char test; //8bit variable
//read eeprom at location 0x1022 and store the data into test variable
test = api_eeprom_read(0x10,0x22);

THE CODE IS AVAILABLE HERE

Further modifications will include page writes/reads and array writes/reads. (code will be releasing shortly)

Thank You for Reading,

Macjan Camilo Fernandes

Difference between Atmega8A and Atmega16A

2014-11-01T12:27:00.003+05:30

Today I will make you clear what's the difference between Atmega8A and Atmega16A microcontroller.

To understand this you will need to download both the datasheets by clicking here.
and

Lets begin with hardware wise:

Has two 8bit IO Ports and one 7bit IO Port. Altogether it makes 23 IO Pins available.
Has 6 channel 10bit ADC each (PDIP package)
Has AVR 8bit RISC Microprocessor working at 16MHz with 8KB Flash memory, 512bytes of EEPROM, and 1KB of internal SRAM.

Has four 8bit IO Ports and altogether makes 32 IO Pins available.
Has 8 channel 10bit ADC each (PDIP package).
Has 8bit AVR RISC Microprocessor working at 16MHz with 16KB Flash memory, 512bytes of EEPROM and 1KB of internal SRAM.

So In brief if you notice hardware wise the difference is in availability of number of IO pins, ADC channels and Programmable Flash Memory. So while choosing micrcontroller you need to make sure what type of application you want to use it in. Here are few points you can select microcontroller based on.

Does my application needs more IO's? Do I need external Interface say eg: LCD/ 7 Segment Displays etc.?
How big will be my coding? Do I need extra flash memory interms of programming needs?
How many analog inputs I'll be reading?

This questions will answer the hardware needs of choosing between atmega8a and atmega16a. Sometimes you need even more IO's then you can chose multiplexing methods and also I2C based IO expander IC's.

When you think your programming is based on C. I recommend you to take a microcontroller with more flash memory since C coding uses pointer based programming at times and may need more memory then when coded with assembly language.

Size of the application also plays major role in selecting microcontroller. Say you want to make use of just 2 IO's and one ADC to do checking on voltage and say set LED's accordingly if its high or low. This application is very small and you do not need such a microcontroller with so many IO's. If you have no choice and you got to choose between Atmega8a and Atmega16a then you should choose Atmega8 for this above application. (for real: I recommend attiny microcontroller which is even smaller version of AVR controller).

Lets begin software wise:

If you are using Atmel Studio 6 and above. You are asked to choose the microcontroller in beginning. You can that time select Atmega8a or Atmega16a. At this time, the software internally defines Atmega8a or Atmega16a. This hence automatically selects desired header files for the microcontroller you are working on.

So in-case of programming IO's you can use IO registers which are available on that microcontroller as you are aware the atmega8a contains lesser IO's then the atmega16a. So in atmega8a you will not have access to IO register A since the port itself is not there. Also Pin PC7 is not there.
In-case of analog channels you can only use 6 ADC channels. ADC channels 7,8 are not available on atmega8a.
Overall Programming size you will get is up-to 8kb. You have to make sure you do the coding efficiently in C here. For larger applications on atmega8a; I recommend to use assembly language.

Now secondly, interms of code transfer. Since the microcontroller architecture is matching and the difference is only between IO's, ADC's and Flash memory. We can easily transfer the c code you designed for atmega8a to atmega16a. But c code designed for atmega16a cannot be transferred to atmega8a because of less IO's and ADC's unless your application has the IO ADC and Flash requirements on atmega8a.

So,

Concluding from above: You can use the same hardware and can program with c language which you studied for any of one of these microcontroller. Atmega8a code can be transferred to atmega16a and atmega16a code can be transferred to atmega8a without issues unless the IO requirements are sufficient on atmega8a. the Internal AVR RISC architecture of microcontroller remains the same. This also applies to atmega32a which I have not included to explain.

In the names Atmega8a , atmega16a, and also atmega32a the red marked corresponds to Flash memory in KB and rest architecture wise is same for all.

Thank you for reading,

Macjan Camilo Fernandes.

Turn on LED On/Off from internet using Arduino UNO R3 based Webserver (mini IOT example)

2014-10-16T16:25:00.004+05:30

Aim: To teach basics in connecting Arduino Uno R3 to internet with Arduino Web Server and to turn On/Off LED using the same. The hardware network is designed for beginners and is not professionally suggested.

Things required:
Arduino Uno R3 board = 1 Qty.

W5100 Ethernet Shield = 1 Qty.

Ethernet/ LAN Cable = 1 Qty.
Jumper Wire (male to male) = 2 Qty.
Red LED = 1 Qty.
Resistor 220 Ohms = 1 Qty.
Standard USB Cable A Plug to B Plug for Arduino = 1 Qty.
Laptop with Windows 7 Operating System.
Internet connection (USB dongle or Cable). I got Tata Photon+ 3G

Softwares Required:

USB Drivers for Arduino
(DNS Update Client) (from No-IP)
on SourceForge.net

Accounts Required:

Knowledge Required:
Arduino Language.
HTML Language.
Google Drive.
Networking in Windows.

Block Diagram:

Connections shown through photographs:
(Green Jumper Wire corresponds to Ground / Yellow Jumper Wire corresponds to Digital IO Pin 6 Output)

My Web Server Setup

Red LED connected in Series with 22 Ohms for Current Limiting

Arduino connection for Ground and Digital Output

Now Open Arduino IDE.

Open ethernet web server file using ( File - Examples - Ethernet - WebServer )

In the Sketch first you will see includes of SPI and Ethernet. Since communication to w5100 Ethernet Chip is done through SPI Interface and so do the SD Card but that feature we will come in next tutorial. The ethernet shield configuration is configured for W5100 IC. I don't know if the header file works for other controllers since I've not tested them.


Basic Ethernet Initialization

Then we store the mac address to the ethernet chip which is given to you on the hardware otherwise you can use this given mac_address from example (0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED ).

Then store IP address of your arduino ethernet shield. Mine is (192.168.137.100) but you can modify this as per your configuration. For example my computer LAN IP address is 192.168.137.1 . So as per that configuration I had to adjust arduino Ethernet IP address. To change computer LAN Settings go to Control Panel - Network and Sharing Center - Change Adapter Settings - Local Area Connection - (Right Click) Properties - Internet Protocol Version (TCP/IPv4) - Properties - Select use follow IP address - Change IP address to 192.168.137.1 - Change subnet mask to 255.255.255.0 and click OK. Your LAN settings are done. You can now officially link your arduino to computer through TCPIP protocol.

Next comes Ethernet Server PORT. Usually the example states port as 80 but when you make your arduino available on web you usually should take port 8080

So rewrite

EthernetServer server(8080);

With this settings itself now you are ready to go on Local network. After uploading code to arduino uno. You can open Internet Explorer/ Firefox/ Google chrome browser on your desktop/laptop.

type in http://192.168.137.100:8080

You will be getting the browser page on LAN. The page will refresh every 5 seconds and will display analog input values which will get updated every 5 seconds as per page refresh.

Remember the code example includes HTML file which looks as below:

When you get this page on browser it will look like below:

But to understand what was sent to client computer (your PC) you need to Right Click - View Page Source

The above picture will tell you what you received from arduino ethernet. Now compare this to your arduino web server code. Did you notice?? The HTML file lines are getting printed in Client.println command which hence gets updated every 5 seconds which you will see as refresh 5 written.

To modify this use your HTML Skills to make your modifications as per your settings. I cant help you with the HTML coding because its totally new topic. You got to learn on your own atleast some simple stuff.

You can also download my code for turning On/Off LED.
You can view my page (Live) By

I have tweaked some changes in webserver example file provided by arduino IDE to support my needs.

Now upto here your setup will work only for LAN connections.

How to make it available online???

Since I'm using USB dongle (photon +) its IP address changes everytime I connect to the internet.

To tackle this problem you need to make account on No-IP website which I provided above.

To sign up:

Use hostname with ddns.net which is free. In this case I selected mine as embeddedlife.ddns.net

After doing this procedure. Sign In.

After signing in, click on manage host. You will see your domain name (embeddedlife.ddns.net in my case).

Click on modify. Select host type as Port 80 Redirect. This host is defined for server purposes so by default your port will be 8080.

Click on update host. And your job is done on this website. You can check all the features include on the website after mastering the whole idea.

Next is download DuC (DNS Update Client) you can find the link above in software requirements.

After installing. Run DuC as administrator. Enter user name and password.

You will get above information. Your present IP will be set in 3rd Tick mark. This IP in few minutes will be updated inside No-IP account using this software. To link host click on edit host/ select the domain then ok. Now with this settings embeddedlife.ddns.net is linked to my recent IP address. This IP address changes every time you reconnect or error on your USB Dongle. So to make this IP Static in nature we need to make use of this tool. Thank you No-IP.

But if you want permanent IP Address you can always ask your internet dealer for packages. Usually dedicated IP will cost you alot.

Now secondly,

You need to forward all the connections coming to your PC to Arduino because your Server lies there. Which can be done using Router only! With a method called port forwarding.

But I don't have a router connected to my computer!!! I have direct internet access through USB dongle, then what's the different method??

It took me days to find out what is an option here.

Well thank you to Sourceforge.net. From software requirements download PassPort Utility from above.

PassPort Utility looks like this:

Run the PassPort Utility as administrator. Then Click on service on menu. Install. It will install a service in (right click on computer) - Manage - Services. Check for service named : PassPort(Port forwarding) and click start if its not started.

Now come back to PassPort Utility Software and click on Define/view forwards. You will get the below screen:

Now we need to divert the incoming connection from internet to your arduino. That is done by editing source port as : IP Address visible on DuC. eg. on my computer IP was visible as 14.97.77.140 and I entered source address as 14.97.77.140 and port as 8080 since your domain will direct you to this address and server responds to port 8080. This all will happen provided you keep DuC running. The above IP address is dynamic IP of your USB dongle which changes when you re connect to internet. But using No-IP we are making it static in nature. So now enter Target port/host address as you programmed in arduino that is 192.168.137.100 and listens on port 8080. Select TCP.

And click Add. Then ok.

You can click on Start. Now PassPort Utility will act like Router and will divert port 8080 to your arduino.

(NOTE: DuC and PassPort Utility and Internet needs to be ON all the time and so your Desktop/Laptop)

Now you are ready to go live. Try your mobile or any other computer with internet to access your own page. Mine looks like this on mobile check below:

Did you notice the LED color changes?

I personally created a PNG file using my ms paint software and updated it on Google Drive under (share settings as view as public). So there are basically 2 PNG files. One where LED is off and another where LED is on. So basically you can use Google Drive for saving your image files and using it. To use images you select the image uploaded on Google file and on right side click on details. Copy the HOSTING address. This address will help you to print the image on your page. And not the share link Note it.

Now everything is up to you with modifying the HTML and looks and making your server look smarter.

Advantages with this method:

Easy Learning.

No router needed.

Possible way to create a webserver.

Without internet it acts like a local server and can be accessed locally through work network.

Can access your circuit using internet anywhere in the world.

Disadvantages with this method:

DuC and PassPort needs to be ON and so your Desktop. Overall power consumption is more. This setup is suited for Offices which need servers only during working hours and not meant for home automation.

So guys I hope you liked my tutorial on Web Server. But coming to my webserver. It is on only when I turn my computer On so never mind. Now you can make your own.

Thank you for reading,

LED ON/ OFF using Serial Commands on Arduino Uno R3

2014-06-15T19:28:00.001+05:30

For reference tutorial follow arduino website.

This is a sketch for Arduino Uno I have written which when commanded on serial port turns LED ON/OFF at pin 13 (On board LED) so you do not need any additional hardware to test this code.

Components required: Arduino Uno R3

Copy the sketch below and upload for testing:

#include "string.h"

void setup()
{
Serial.begin(9600);
pinMode(13,OUTPUT);
}

void loop()
{
int i;
char rx_buffer[10];
Serial.print("Enter Command = ");
for(i=0;i<=9;i++)
{
    while(Serial.available()==0);
    rx_buffer[i]=Serial.read();
    if(rx_buffer[i]==';')break;
}
if(strncmp("LED_ON",rx_buffer,6)==0)
{
    digitalWrite(13,HIGH);
    Serial.print("LED_ON;\n");
}
else if(strncmp("LED_OFF",rx_buffer,7)==0)
{
    digitalWrite(13,LOW);
    Serial.print("LED_OFF;\n");
}
else
{
    Serial.print("Command Faulty\n");
}
}

Commands to be entered:
LED_ON; -> To turn on LED
LED_OFF; -> To turn off LED
Anything else will respond Command Faulty.

Test screen(On Serial monitor):
Enter Command = Command Faulty
Enter Command = Command Faulty
Enter Command = LED_ON;
Enter Command = LED_OFF;
Enter Command = LED_ON;

Happy arduino programming

Create header files for AT89C51

2014-05-11T17:10:00.000+05:30

AIM: To help you understand how the header files and source files are made for ease of programming.

I've been asked questions many time regarding the header files and custom functions created for your own purpose say for Eg. to turn a port ON or to turn a particular port pin OFF. This basics extend so far you can create functions to most of the registers in 89C51 or any other microcontroller you want.

To begin with lets make sure you learn something useful at the end so I will have to explain you with some example. I'll start with PORTS. I'll create a header and a source file for PORTS of 89C51. This both files which also will be also knows as custom library files for your ease will help you make programming easy then before.
Lets create a project in keil for 89C51-> So here it goes. So open keil. This is how it looks,

Then Create a new project for your testing purpose. I have named the project as port. Select 89c51 as CPU. Then click ok.

Now this is important part. I like to separate headers and source files into separate folders. Makes easy to know where they are located when the project is large. So Click on target and you will find Source Group 1 so Right click on that folder then Remove Source Group 1. Now right click on target and create two new folders called Source and Header by selecting add group. Check the image below: (Check Left side for source and header folders inside target 1)

Click on Target 1-> Options for Target 1.
This are my settings for Target. 12MHz crystal, Use on - chip ROM. Check the image below:

Click on Output Tab later after this settings, tick mark on create HEX file. (HEX-80) format. Now you are ready to start with programming.
Now create new files main.c , port.h , and port.c .

In C programming "filename.h" files are basically called header files. This file contains mostly include files, variable declarations, function declarations, defines, etc. "port.h" will contain your function declarations and some include files needed to make those functions work. "port.c" file will contains the definitions of that function. This functions will resemble same as you will write in main.c so lets start with them. Create these three files and add them in respective folders. Check image below:

So to work with 89C51 microcontroller in Keil. First you need to know the include file made by keil itself. The register addresses are defined by keil header file. I mostly read "REGX51.h" It is in include folder inside keil compiler files (Folder Keil -> C51 ->Atmel ->REGX51.h). Please do read it. Because I will be using the same registers below.

So what functions do we want for the port? I have created these so far. Check below: (port.h below)

The above picture clearly explains what will be header file for your custom functions. You can name your function whatever you want. Plus you can do as many possible logic with it to get a outcome. Here I did few functions to set and clear port, also to set and clear pin on the port. So to make these functions work we need to create the definitions. So lets start with port.c:

So did you see what changes I have done. I have included port.h file in port.c file. It has to be done since the declarations have been defined there. Also notice the port.c file contains most of the definitions similar to main.c . Now lets use these header and source files for our multipurpose use. So I'll create a basic routine to test these functions on each port.

Did you see the changes I did in the main loop? Now I don't need to think much behind what ports are. Just my own functions are enough to know that this will set port and clear port.

You can view the files here: ( main.c) ( port.h) ( port.c)

Or you can download the keil project here (click here)

What are the advantages behind this technique?
1. Reduces code lines shows less complexity.
2. Very easy to debug and find errors.
3. The files can be copied and pasted into another project and can be used.

To make the code more fancy you can use this #define technique.
Right now you will write the function as port_set(1);
So,
#define PORT1 1
This by putting in port.h you can now write the above function as port_set(PORT1);
That makes code more user friendly and understandable.

Also case 1: in switch statement can be now replaced with above technique as case PORT1:

So apply this technique and create header and source files for each hardware unit of 8051. (timer, port, uart) etc.

So hope you learned how to create header and source files. This will also help you understand how the header and source files are made and to be used which are included inside the compilers and libraries itself.

Thank you for reading,

Macjan Camilo Fernandes

Delay function for PIC16F877A (delay in milli seconds)

2014-05-03T17:14:00.003+05:30

Aim: To teach how to create delay function in milli seconds using internal timer.

When I created milli second delay routine for 89C51 most of the readers told me what will it look like on PIC16F877A because they wanted precision timer for PIC microcontrollers too. So I'll explain you how to do it.

To create delay we need to know few things below:
1. To calculate timer variable depending on crystal used.
2. To enable timer 1 for delay operation using ISR (Interrupt Service Routine)
3. To create delay routine to based on above timer.
4. How to interpret 1 microsecond timer based on above study.

We will be using Timer 1 in 16- bit mode for creating delay application.
Lets look at timer 1 block diagram in details so that I can show you what you need to know here.

This is the logic diagram of timer 1 in PIC16F877A. You need to know that we are using 8MHz Crystal and no external Clock generators. So we need to ignore external clock generators. So if you check this block diagram above TMR1CS chooses which clock to select. So obviously our 8MHz clock so you need to set TMR1CS=0; so if you check it out this 8MHz clock is internally divided by 4 (FOSC/4), so this comes to 2MHz internally. When we are doing calculations we need to take this clock into consideration.

Prescalar is kept 1:1 since we do not want to change our frequency. Since this is an internal clock we do not need to synchronize so T1SYNC=1; then finally when these settings are done you turn the timer on by giving TMR1ON=1;

The timer counts get incremented in TMR1H, TMR1L registers. If we set this register with timer value we calculated using crystal information and generate exact 1KHz we can create 1ms delay in no time.

But this is not yet over. We need to know how this timer 1 control register looks so here it is:

So what will go inside T1CON register according to you for this settings???
Ans: T1CONbits.T1SYNC=1; //T1 needs to be on when delay function starts. We can't keep timer running.

Now we need to configure Interrupt registers since we need interrupt to be generated in exact 1ms delay.
So lets have a look at interrupt control register. (INTCON)

Here you need to set only 2 bits. INTCONbits.GIE=1;(Global Interrupt Enable Bit) to enable all the interrupts.
INTCONbits.PEIE=1; (Peripheral Interrupt Enable Bit) to enable interrupts related to peripherals.

Then, after enabling global and peripheral interrupts we need to enable timer 1 interrupt enable flag. That can be set from PIE register.
PIE1bits.TMR1IE=1; // Making this bit to 1 enables timer 1 overflow interrupt flag.

So finally you know all the registers to be studied to work with delay timer. Now lets work how to create a 1ms delay for 8MHz Clock (8MHz crystal used).

So I had said that we need to save timer preset value Tpreset in TMR1H and TMR1L register.

So 8MHz internally divided (FOSC/4) which gives us 2MHz frequency = Fosc;
Considering prescale is 1:1.
2MHz/2000 =1000; // 2MHz is divided with 2000 to give 1000 = 1Khz; 1/F = 1ms.
So since timer value in 16 bit register can go upto from 0 to 65535 and considering counts also go incrementing here. We will have to manipulate and put the count in such a way once it reaches 65535 will become 1ms interrupt.
So 65535 - 2000 = 63535 = 0xF82F in hex. And this Tpreset = 0xF82F;
So we need to make
TMR1H = 0xF8;
TMR1L = 0x2F;
Now we will get exact 1KHz since the count will increment from 0x0XF82F to 0XFFFF which will give us 2000 difference hence creating 1ms delay.

If you understood above concept properly what will be the Tpreset if Crystal is 8MHz and you wanted to create 1 micro seconds delay???
8MHz/4 = 2MHz = Fosc
2MHz/2 = 1MHz = 1uS interrupt (1/F=T)
65535-2 = 65533 = 0xFFFD in hex. So Tpreset = 0xFFFD
TMR1H = 0xFF;
TMR1L=0xFD;
This values if you put in my code ahead, this will give you 1 micro second delay.

You can use the below calculator for determining decimal value for TMR1 Register.

So lets proceed to use this technique to our advantage and create 1ms delay.

Check the code here (click here)

Or you can download MPLABX project here (click here)

This code will now generate 1000ms = 1 second delay and will blink LED to 1Seconds delay time using this wonderful timer method.

So remember how to make use of timer by setting up preset value in 16 bit timer register.

So all the best in programming with PIC16F877A. You can use this schematic for above demo purpose (click here)

If there is any query regarding timer let me know.

Macjan Camilo Fernandes (R&D)

Delay function for PIC16F877A (delay in milli seconds)

2014-05-03T17:14:00.002+05:30

PIC12F510 based Voltage Trigger Switch (Industrial)

2014-04-30T18:38:00.003+05:30

AIM: Based upon 0 - 10V input from the Analog In terminal; upon reaching trigger voltage triggers the Relay hence driving the third party device. LED Indicator or a Buzzer used as a second option.

I've designed this small device for demo how industrial circuits are designed. For instance the Supply voltage is always +24V. The Analog input voltage range is always from 0V - 10V.

First things are first, you should know all the sensors used in industries to design circuit for them. Most common of them include inductive sensors, proximity sensors, flow sensors, and most common limit switches. We going to use linear potentiometer sensor which is another type used for measuring distance etc.

There are many books online regarding the sensor selection and industrial sensors.

Things you will need to work with this project:
1. PIC KIT2 programmer or higher ICD
2. MPLABX software along with X8 compiler both by microchip.
3. Some knowledge about PIC12F510 ADC and GPIO.
4. Components

You can download PCB Gerber files here (click here) (PCB done with easily available components)

Components needed:
C2                            1              0.001uF
C1                            1              0.1uF
R5                            1              10K 1/4w
F1                            1              1A
R2,R3,R6                 3              1K
D1                            1              1N4007
R1,R4                       2              500E 1/4w
U2,U4                      2               2 Pin Terminal Block
Q1                            1    BC547
RLY1                        1              G5LE 10A 24VDC RELAY
U3                            1              LM158
U1                            1              LM7805
U5                            1              PIC12F510
J1                             1              3 PIN Terminal Block
SW1                         1              Tactile Switch

Secondly the circuit. Lets look around the schematic below :

The power supply section:
Includes Supply IN terminal. Most of the industrial automation circuits makes use of terminal blocks in their circuit where you can plug in multi - stranded wire. Since this device will be powered by external source (SMPS), we need not put much filters inside in our power supply regulator LM7805. This regulator is needed for supplying +5V to our microcontroller PIC12F510. We also need to provide fuse since this device will be used in industry, the fuse is a must to prevent short circuit accidents.

Analog input section:
The analog input section consists of dual op-amp LM158. It doesn't require dual power supply. But it has feature of internally dividing the VCC into half to use it as dual supply. This op-amp is used in non - inverting mode in such a way that output = 1/2 of input. This is because the input we going to use will only go up to +10v (analog output voltage of another device). And the Vref voltage of our PIC12F510 is +5V. The maximum input voltage converted will be up to +5V.

Microcontroller section:
The microcontroller section includes PIC12F510 microcontroller (widely used among hobbyists so I had to select it as example). You can use different microcontroller available in your market. The reset switch is to reset the microcontroller. The microcontroller has been software wise programmed to have internal oscillator working at 8MHz. So no external oscillator required.

Relay driver section:
The relay driver section includes npn transistor driver using BC547(most common). The relay used is G5LE base type (for pcb's). Has ratings of 10A, +24V dc. The diode is used for preventing back emf from the relay and to protect the circuit from damaging. You can replace the relay with Buzzer for alarm application. Using buzzer as alarm here will give rise to Voltage trigger based alarm as a new project.

Software Code: (compiled with MPLABX)
Please click here for code.
You can also download the project here along with the hex file.

The code has been explained inside. But you need to know this formula here

ADC is 8bit. Means 2^8=256 value max.
Vref = +5V (That is Vdd)
Vtrg = (Trigger voltage you want)
Value = Value you need to put in the if statement of trigger relay.
Value_reset = Value you need to put in if statement of reset relay.

Value = (256/5) * (Vtrg/2).

Value_reset = ((256/5) * (Vtrg/2))-10;

The reset value is kept little lower that the trigger value to avoid flickering of relay. This happens when the adc value is not stable at trigger voltage. The flakiness in analog read can reset or trigger relay continuously giving rise to chattering of relay.

The modifications:
1. Buzzer can be included in cases of Emergency Stop alert or Alarm.
2. LED indicator can be added for visual display of trigger.

So this is one of the example how to create industrial circuits. But this is not all of it. There are EMI EMC testing on these circuits so you need to add some filter diodes at input sides. Most of the IC's do contain the EMI filters.

Any more query regarding the project let me know.

Macjan Camilo Fernandes (R&D)

How to create delay function on AT89C2051/ AT89C4051/ AT89C51 for milli seconds delay time (V1.1 updated)

2014-04-29T16:07:00.001+05:30

Aim: To teach how to create delay in milli seconds using internal timer.

Delay has been very important part in programming. Many controllers need delays in milli seconds when the commands been transmitted eg. LCD. We can just send commands without delay involved.

To create a delay we need to know below things first:
1. To calculate timer variable according to crystal used
2. To enable timer for delay operation
3. To create delay routine which will use the above timer for operation.

We will be using timer 0 from AT89C51. Also timer 0 is common for all three microcontrollers mentioned above.

First we need to do is calculate the timer variable.

Since delay is in 1ms (1 milli seconds) we need to create 1KHz timer interrupt routine. In other words, 1KHz corresponds to 1ms since f = 1/T.
where f = frequency, T = time.

Say we are using 11.059MHz crystal for our microcontroller. To create 1KHz with the given crystal frequency we need to know that 89C51 timer 1 oscillator clock is divided by 12. So our actual clock will be 921.583KHz. We need to make sure we get 1KHz from this (921583/922) we get 1KHz. So we need to divide by 922

So 922 is the value we need to save inside the timer.

Now lets study how to start this timer 0.

We first need to know TMOD Register.

First thing is we need to operate the timer in 16 bit mode. That will be mode 1.

So TMOD = 0x01; // Because only last bit is set we get 0x01. (that is to enable mode 1).

Secondly, we need to enable the timer 0 interrupt. If you check the Interrupt Register IE below:

If you check the IE Register above, ET0 corresponds to Timer 0 interrupt enable bit.

We need to set that to '1'. In keil compiler the good thing is that this bits can be set directly by their names.

so we set ET0 = 1; // this enables timer 0 interrupt

But no interrupts will work if we do not enable EA bit which is Global interrupt enable bit.

So we set EA=1; // this enables global interrupts

Now comes the important part. Interrupt timer routine.

void timer_0 (void) interrupt 1 using 0 //timer 0 interrupt routine

{

// enter code here

}

Now this interrupt routine has parts.
void - no return type function
timer_0 - any name you desire for your timer interrupt routine
interrupt 1 - corresponds to interrupt type 1 (see diag below) which means timer 0 interrupt = 1
using 0 - corresponds to number for interrupt vector.
Check all this description below for more details regarding this: (RESOURCE = Keil Compiler Help)

Now next comes timer variable. We had calculated value 922 to generate exact 1KHz timer interrupt right?? We need to save this value interms of hex form in timer register.

Since timer will keep on counting, it will count upwards right? Say example 0x0000 -> 0x0001...0xffff and then reset back to 0x0000.
Since it will count upwards we must make sure we get 1KHz. So to get 1KHz interrupt we must subtract highest value of timer counter (0xffff) with the value we got to get the value to be entered in timer as a preset value.
So 0xFFFF (65535 in decimal) - 0x39A (922 the value we calculated above) = 0xFC65( preset value).
So you need to save this preset in timer 0 registers TH0, TL0;
Therefore, TH0 = 0xFC;
TL0 = 0x65;

So, everytime now the timer will start you have to make sure to enter the above preset into these registers and then start the timer. So when it reaches 0xFFFF the actual count will be 0x39A hence your interrupt will be exactly of 1KHz. Now lets take this to our advantage to create a delay.

Check the code here for the delay: Click here

To download the keil project and hex : Click here
The code will generate 1000ms delay -> then turn Port 1 ON -> another 1000ms delay -> then turn Port 1 OFF for delay demo purpose.

So, for different Crystal frequencies you will have to calculate the Preset value for the timer using above method and your universal precise delay is ready for service :)

Good luck in programming, hoping this helps many programmers.

Thank you for reading, awaiting queries from you.

Macjan Camilo Fernandes (R & D)

How to create delay function on AT89C2051/ AT89C4051/ AT89C51 for milli seconds delay time (V1.1 updated)

2014-04-29T16:07:00.000+05:30

If you check the IE Register above, ET0 corresponds to Timer 0 interrupt enable bit.

We need to set that to '1'. In keil compiler the good thing is that this bits can be set directly by their names.

so we set ET0 = 1; // this enables timer 0 interrupt

But no interrupts will work if we do not enable EA bit which is Global interrupt enable bit.

So we set EA=1; // this enables global interrupts

Now comes the important part. Interrupt timer routine.

void timer_0 (void) interrupt 1 using 0 //timer 0 interrupt routine

{

// enter code here

}

AT89C51 Based Object Counter using IR sensors and 4 Digit Seven Segment Display

2014-04-26T15:12:00.000+05:30

WARNING: I'm not responsible for any short circuit or damage you do to the components. The circuits are been tested well and working.

Count number of objects on a moving trailer and display on the seven segment display upto 4 digits with reverse counting.

Theory:

When production field started growing the number of people involved in doing manufacturing became more involved in cutting, drilling, packing, and counting. Counting has been very important since there was human error happening every time. Counting was possible when production count was less within a day. But since the production count went above 1000 for some companies they had to make some solution regarding counting. Many companies introduced this simple method of object counting. I've sketched you how the object counter placement looks like in an industry for counting purpose. You must have already figured out where the object counter is, didn't you :).

Object counter basically has 2 IR sensors and 2 IR transmitters. On the left side of the picture you can see 2 red IR beams coming towards the receiver. They are transmitters. The Object blocks one of the beam, hence predicting which direction it has come. This also means we can do reverse counting with it. Only when the object passes from two beams we conclude the count as +1. The count is generated by microcontroller 89c51 (before totally logic was used), and then displayed on seven segment display. You can add on indicators like buzzer for generating sound as soon as object passes by.

When designing the counter we need to satisfy the 2 above cases.
CASE 1: Object entering from Right to Left( Considered as Forward motion). Forward motion has to be considered as ( + 1 count). So every time this motion happens we need to count up and show on the display. In this condition, beam from t2 is blocked hence s2 doesn't get the beam hence triggers the pulse which we need to save and wait for t1 to be blocked and s1 to trigger the next pulse to increment the count. The count will continue till maximum limit set inside the code.

CASE 2: Object entering from Left to Right (Considered as Reverse motion). Reverse motion has to be considered as ( - 1 count). So every time this motion happens we need to count down and show on the display. In this condition, beam from t1 is blocked and hence s1 doesn't get the beam hence triggers the pulse which we need to save and wait for t2 to be blocked and s2 to trigger the next pulse to increment the count. The count will continue till minimum limit set inside the code.

NOTES:
In both cases the IR transmitter and receiver are kept at same distance (Max. tested distance = 2m apart). The beam from transmitter has to fall on receiver. So before testing the equipment make sure they are aligned. I used Red transparent bright beam LED in place of IR to check if the sensor is aligned.

Secondly, make sure the IR LED's are working. To test that is simple, turn your camera ON and see if you can see the beam coming out of your IR LED's. If not, you need to change it.

Schematics:

Lets have a talk on this hardware. This hardware includes 5 major blocks marked in rectangular areas. They are:
1. AT89C51 microcontroller circuit.
2. Seven ( 7 ) segment display and buzzer circuit.
3. IR sensor circuit.
4. IR Transmitter circuit.
5. Power Supply Circuit.

Coming to the microcontroller circuit. AT89C51 is 8 - bit microcontroller (uC) with 4KB flash which is exactly what we need. This uC also has sufficient IO's for our purpose. Extra un used IO's can be internally modified for LED indication for debug purpose. It is configured to work on 11,059,000Hz (11.59MHz) frequency. Reset Switch is used to reset the controller hence resetting the counter. So no extra switch needed for this operation. The 11.059MHz Crystal used is a 3 Pin Resonator

This crystal doesn't need external 22pF resonators so saves space. But if you want the tradition two pin crystal do use, there is no harm. You will have to add two 22pF on either pins of crystal to ground.
The microcontroller works on +5V pure DC. Make sure no fluctuations come through AC to DC source.

The Seven Segment Display has 4 digit seven segment digits LT542 is a Common Anode Type where the LED segments anodes are all connected to one. So we need to light up using the cathodes. Or in other words making 0 or Ground. The schematic itself shows how the LT542 looks internally. and also the segments a,b,c,d,e,f,g,dp. So before using the seven segments try to light them up first and see if all segments are working properly. This can be done by connecting Common anode to (+2V) and the segments a,b,c,d,e,f,g,dp to ground. A good one will light all up. Bad one will create problem in displaying so don't use it. BC557 transistor is used to drive the LT542 display. In microcontroller section Resistors R2 to R9 are current limiting resistors to protect LT542 segment from burning. How they are calculated??

Voltage to drive one led segment Vled = 2.2V.
Current through that led segment Iled = 12mA.
Voltage supplied by BC557 Vcc = +5V
Therefore, Resistance to protect one led segment Rled = (Vcc - Vled)/Iled.
Which comes to 233.33 Ohms on calculation ~ 220 Ohms close value available in market. So use that.

You must be wondering why just 7 data lines for 4 Seven Segment Display? They has to be 7 x 4 data lines right? Well to save all that trouble and extra components we use the method called TDM (Time Divison Multiplexing). In this method, for a particular given time each seven segment has been given a time slot. And during that time slot the data lines will be assigned to it software wise. Let me explain you through the diagram below.

TDM is divided into 4 slots for time T1, T2 , T3 , T4. For now Ttdm is calculated roughly to be 0.0906mS. That means each segment gets updated at 0.227mS rate.

During time T1, you must make sure Q1, Q2, Q3, Q4 transistors are not driving any segments. This is made to ensure data lines are not by any chance get linked to other segment. Or the numbers will display wrong. So while segments are disabled set the data lines with ' unit ' data calculated from counter value. Then turn Q4 ON, hence driving UNIT seven segment. This will display UNIT value.

Upon the next time slot T2, disable again Q1, Q2 ,Q3 ,Q4 transistors to eliminate duplication of digits on other segments. Then send ' tens ' data on the data line calculated from counter value. Then turn Q3 ON, hence driving TENS seven segment. This will display TENS value.

This continues till all digits are displayed and the steps are repeated at 0.0906ms rate. The changing rate is so fast it makes human eye almost look like proper whole 4 digits being displayed without problem. TDM saves lots of component space and cost.

Next, IR sensor Circuit contains TSOP1736 IR sensor has IR photo detection response of 36KHz. The sensor produces low output upon IR detection, otherwise when no IR is detected the sensor remains ON.
This sensor is then driven by BC557 transistor for proper biasing which is then given to input of microcontroller. This microcontroller inputs of AT89C51 are external interrupts IO. So they can be internally configured to interrupt upon any trigger from the sensor. This you will learn inside the software.

The IR transmitters contains the famous 555 timer astable multivibrator ticking at 36KHz that is blinking the IR LED at 36KHz since that is the response frequency of the IR receiver. You can use 1 or 4 IR LED's based on range or distance between both IR transmitter and receiver. R19 to R26 can be calculated based on Voltage and current rating of the IR LED. I have not put this values but you can find for your self and then put the corresponding Resistance value.
Formala R = (Vcc - Vled)/Iled.

Next is power supply circuit. It uses IC regulators to give +12V and +5V separately. Overall current will be below 1A so transformer output of 12V 1A is capable to handle this rating.

Now coming to software:

Kindly Click here for the code. The Code is written in C on Keil compiler. You can download the project by clicking here.

The explanation for the code has been given in details using comments inside code itself.

Improvements to be done:
1. Increasing of Digits can go upto another 15 digits with the remaining available IO's. Extra driver circuit will be required and some changes in the calculations and time slots.
2. Adding LED indicators for panel besides buzzer can be used.
3. Alarm trigger on certain count can be implemented using keypads.

This device can also be used as visitor counter for one door only. (assuming one door for the room to enter and exit, provided initial state of the room has no people inside.

You have officially understood how object counter works. Congratulations.

Thank you for reading. Any query related to this article let me know.

Macjan Camilo Fernandes (R & D)

Turn LED On wireless using Jennet Protocol with JN5148 Microcontroller Module

2014-04-21T19:29:00.002+05:30

WARNING: I'm not responsible for any short circuit or damage you do to the components. The circuits are been tested well and working.

This is the module I was using JN5148-001-M00. This can go upto 25Meters.
Lets go wireless.

But before understanding what I'm about to do, you need to know some basics.
This Microcontroller uses wireless IEEE182.15.4 protocol or ZigBee Protocol developed by Zigbee Alliance. You can read history more on wikipedia. This protocol has been designed for low power applications, low data rate, and where communication security is concerned. The maximum range it can go was once 20meters, but with external antenna support it can go upto 1km to 4km.

When I started my first project during my MSc time, I used JN5139-001-M00. We had named it Temperature monitoring using ZigBee Network with mesh topology. Trust me, I was so blacked out just like you (assuming you are reading this blog) so do my classmates including my teachers since zigbee was newly introduced and there was no help available much. Also we had to travel far away for buying the modules and the FTDI was very expensive that time. There was no online buy facility.

What we will learn in this topic:
1. Hardware Schematics
2. Software
3. Jennet
4. Coordinator (MASTER)
5. End Device (SLAVE)
6. Compiling and Programming.

Our Network block diagram:

Brief description:
In this network there are two devices with similar hardware schematic. But the assignment is different. One device is programmed as Coordinator and other device is programmed as End device. The Switch SW on end device when clicked will wireless send command on Coordinator to turn LED ON on Coordinator. When You click switch SW on Coordinator, it will send wireless command to end device and will turn LED ON. So with this example I can show you two way communication. You need to reset both the devices to start again. (THIS IS JUST FOR COMMUNICATION BASICS)

Schematic Diagram for both coordinator and end device are same:

IMPORTANT NOTE:
1. Grounds for both FTDI circuit and module circuit is same.
2. +5V_USB and +3.3V_FTDI must not be connected to any power supply.
3. +3.3V_FTDI and +3.3V must not be shorted to each other. This is done to prevent extra load of FTDI when UART or Programming is not in use.
4. The above schematic is for just one device. You need to make 2 devices for testing.
5. You need 3.3V power supply. You can buy it online.

Read more on FTDI setup by clicking here.

Now you are completely ready with hardware. You need to make 2 PCB's for 2 devices to keep them far apart.

Coming to the software you need to download software from here.

I'm going to use JN-SW-4041 Eclipse Integrated Development Environment to write programs and compile them and Flash programmer tool to burn the program into the chip. Kindly focus on these two.

The Eclipse Platform looks like this :

To create new project we need to follow some steps:

First we need to create project. For that click File -> C Project. Enter File name as "test_me" or whatever you want it to be and select empty project. Then Click finish.

Now what you need to do is download template for JN5148 for JENNET from jennic website which can be downloaded by clicking here JN-AN-1061-JenNet Application Template

Download the zip file and also the application note. Yes keep the zip file extracted.

Now You need to do is right click on project in project explorer and then click on import. Then click on General -> File System. Now browse the above extracted template -> Then Select All - >Finish. If asked to replace some files or folders then click "Yes to all".

Now you will see like this below:

Now you are all set for programming JN5148 Microcontroller. Now Lets begin with JENNET.

I'll explain you the basic functions in this template:

PUBLIC void vJenie_CbConfigureNetwork(void) will have all basic variables which are related to wireless network to get configured like eg: Channel, Network ID or PAN ID, Device ID and many more.

PUBLIC void vJenie_CbInit(bool_t bWarmStart) will initialize mostly the Utilities or Peripheral Devices and also acts just like void main(void) from embedded c .

PUBLIC void vJenie_CbMain(void) is just like a loop which will keep on going. So you need to follow those Enumerations and start your program inside APP_STATE_RUNNING.

PUBLIC void vJenie_CbStackMgmtEvent(teEventType eEventType, void *pvEventPrim) contains JENNET protocol stack related activity. This includes Searching for neighboring device, adding of device, leaving of device, registering of device etc.

PUBLIC void vJenie_CbStackDataEvent(teEventType eEventType, void *pvEventPrim) contains mostly data related events. If data received or getting transmitted the code will be processing through here. This is main area of interest to us later.

PUBLIC void vJenie_CbHwEvent(uint32 u32DeviceId,uint32 u32ItemBitmap) is are hardware interrupt call function. For now tick timer and Switch will be generating interrupts.

For Coordinator Settings:

1. Set up PAN ID to 0x1234. (common->config.h)

2. Device ID must be 0x0000

3. No services needed.

4. No registration needed.

5. Configure IO's for Switch and LED.

6. Transmit and Receive implementation.

Lets begin:

You need to know GLOBAL NETWORK PARAMETERS to configure your coordinator. To know that Click here and go to page 161. You need to assign variables to configure your JENNET network here.

So what do we need??

gJenie_PanID = 0x1234 (also called Network ID)(only to be set to coordinator)

gJenie_NetworkApplicationID = 0x12341234; ( For network Application Identification)

gJenie_Channel = 11. (11 is STD channel In India)

gJenie_ScanChannels = 0x00000800. (Set 11th bit to select 11th channel)

gJenie_MaxChildren = 1. (We are using only one End device so 1)

gJenie_RoutingEnabled = TRUE;

gJenie_RoutingTableSize = 100;

gJenie_RoutingTableSpace = (void *)asRoutingTable;

Now open AN1061_JN_Coord -> Source ->AN1061_JN_Coord.c

and clear what is there in PUBLIC void vJenie_CbConfigureNetwork(void) and enter the above parameters.

Now to configure IO for Switch and LED we need to know Jennie Peripheral Interface functions Click on JPI of same above pdf.

To set IO direction void vJPI_DioSetDirection(uint32 u32Inputs,uint32 u32Outputs);
Since or Switch is on DIO20 and LED is on DIO17. Configuring gives
vJPI_DioSetDirection(0x00100000,0x00020000);
eJenie_Start(E_JENIE_COORDINATOR) will start the coordinator stack and will enable the network.
Once network is enabled the E_JENIE_NETWORK_UP enumeration will be set.
You need to put this in PUBLIC void vJenie_CbInit(bool_t bWarmStart) becauses this is like void main(void) in embedded c.

After initializing the code will jump to PUBLIC void vJenie_CbMain(void) where you need to disable the watchdog because we don't want to restart at the movement.
So once the network is up your you need to set:
eJenie_SetPermitJoin(TRUE); which will enable permission for end device to join.
So after this you are ready to transmit and receive data.

I have removed Register Services from the application since I'm not interested in Security right now.

Now you will be in continuous loop in estate of APP_STATE_RUNNING in PUBLIC void vJenie_CbMain(void). You need to put switch read input function here to scan the switch.
if((u32JPI_DioReadInput() & 0x00100000)>0)
{
//data send code here
}

To send data in air eJenie_SendData(uint64 u64DestAddr,uint8 *pu8Payload,uint16 u16Length,uint8 u8TxFlags); function is used where:
u64DestAddr Address of the destination node. For a broadcast or to send data to the Co-ordinator, this parameter must be set to zero (for a broadcast, u8TxFlags must also be set appropriately).
*pu8Payload Pointer to the data to be sent.
u16Length Length of data to be sent, in bytes (for limits, see above).
u8TxFlags Sets the transmission options. These options are detailed in Table 2 on page 165. The values can be logical ORed to simultaneously specify more than one option.

So our function to send to our end device will be:
uint8 *payload;
eJenie_SendData( 0, payload, 1, TXOPTION_BDCAST);

So now the above code will look like:
case APP_STATE_RUNNING:
{
        /* do all necessary processing here */
        if((JPI_DioReadInput() & 0x00020000)>0) //Now since upon switch read is true, broadcast the message in air
        {
            payload[0]=0x01; // Consider 0x01 means Switch was pressed
            eJenie_SendData( 0, payload, 1, TXOPTION_BDCAST)
        }
}
break;

So from above you are ready to do transmission to end device upon network up.
Now lets work on Receiving part.
Lets go to PUBLIC void vJenie_CbStackDataEvent(teEventType eEventType, void *pvEventPrim)
You need to add here two important variables which will store the received data.
tsData *psData = (tsData *) pvEventPrim;
uint8 *pu8Data = psData->pau8Data; //assign received data to this register.

Then in the state event your this case has to be like this:

case E_JENIE_DATA: //Your data from end device will be received here so do the processing here
{
        vUtils_Debug("Data event");
        if(pu8Data[0]==0x02) //0x02 is transmitted data from End device.
        {
            vJPI_DioSetOutput(0x00020000, 0); // set LED ON on receive
        }
}
break;

Thats it!!! For the coordinator. Its so simple isn't it to setup coordinator. I was struggling for many months just to send and receive.

Now lets work on the End device. End device also has similar main functions like coordinator:

PUBLIC void vJenie_CbConfigureNetwork(void) will have all basic variables which are related to wireless network to get configured like eg: Channel, Network ID or PAN ID, Device ID and many more.

PUBLIC void vJenie_CbInit(bool_t bWarmStart) will initialize mostly the Utilities or Peripheral Devices and also acts just like void main(void) from embedded c .

PUBLIC void vJenie_CbMain(void) is just like a loop which will keep on going. So you need to follow those Enumerations and start your program inside APP_STATE_RUNNING.

PUBLIC void vJenie_CbHwEvent(uint32 u32DeviceId,uint32 u32ItemBitmap) is are hardware interrupt call function. For now tick timer and Switch will be generating interrupts.

Now changes in PUBLIC void vJenie_CbConfigureNetwork(void) will be different.
You need to put these:
gJenie_Channel              = 11; //Channel 11= network channel select
gJenie_ScanChannels = 0x00000800;
gJenie_NetworkApplicationID = 0x12341234; //Network app ID of coordinator to be joined
gJenie_RoutingEnabled    = FALSE; //End device cannot add nodes.
gJenie_EndDevicePingInterval=1; //1 = 100ms ping time

So in end device you will enter the same format like you did in Coordinator accept now Data transmit will be
uint8 payloadt
eJenie_SendData(0, payloadt, 1, TXOPTION_SILENT);
Silent TX option will disable acknowledgement interrupts.
and to receive data from the coordinator you need to do this changes:
case E_JENIE_DATA: //Your data from end device will be received here so do the processing here
{
        vUtils_Debug("Data event");
        if(pu8Data[0]==0x01)
        {
            vJPI_DioSetOutput(0x00020000, 0); // set LED on on receive
        }
}
break;

To compile, Right click on Project Folder-> Set Active -> AT1061_JN_Coord to build Coordinator,
and Right click on Project Folder-> Set Active -> AT1061_JN_EndD to build End device.

You can download hex file using Flash Programmer. Here is the Screen Shot:

I had to modify the old Flash Programmer file to show you how it looks.(the latest one goes beyond my screen and About and Program keys are not visible. Sorry for Inconvenience. This will do explain you how it looks when the device gets detected. You get to see the Device name : JN5148, Flash used, Mac Address 64 Bit. The MAC address are unique for each module and you should not change them. Browse the Hex files from Build Folder of Each Device and Program them separately.

To set in programming mode you need to know:
Press Prog Switch -> Hold
Press Reset Switch -> Hold
Release Reset Switch
Release Prog Switch.
Now it will be in programming mode. Your Flash programmer will now detect the module.

After programming. It will still be in programming mode so press Reset Switch again to Run the code.
To debug furthur: You can read more stuff about JENNET and implement your own models of networking and analysis. You can also connect FTDI and see how my code works using virtual terminal.
Messages will be coming no terminal regarding internal functionality. vUtils_Debug( "text") will display text messages on UART for extra debugging.

You can download the files from here.

When both the Devices are programmed, you are ready to test.

Best of luck, you now know the basics of JENNET and to work with JN5148.

Note: For my MSc. Project I used to only transmit data from End Device to Coordinator. That data was 8 Bit ADC value of Temperature. The data was then shown on virtual terminal using serial UART.

Any Questions or Queries let me know.

Macjan Camilo Fernandes (R & D)

Embedded Life

Raspberry Pi Pico SDK Installation Guide for Windows PC

What do we need to learn?

What does Raspberry Pi Pico Hardware contains?

Installation of software's required

Installation of PICO SDK:

Understanding important files for compilation and folders.

Creating your first project folder. This is how your project should look like.

ARIES 3.0 Flash Programming Issue with Arduino IDE

Precision delay function for Nucleo STM32F746ZG

#include "stm32f7xx.h"

volatile uint32_t delay=0;

void delay_init(void);void delayms(uint32_t n);

void TIM2_IRQHandler(void){ TIM2->SR&=~(1); if(delay>0)delay--; //decrement every 1 ms if delay is greater than zero}

As you can see the delay is perfectly 100ms as expected. But is it?

Nucleo - F746ZG basic programming using TrueSTUDIO 6.0 for ARM

AIM: To teach you basic programming on Nucleo - F746ZG development board using TrueSTUDIO 6.0 and c programming. Also to write a simple code for LED blinking and test it on the hardware.

Things needed:

Working Summary:

Reference Documents:

Step by step Procedure:

You can download project workspace here below:

Arduino Due programming using Atmel Studio 6

AIM: To teach you alternate way programming Arduino Due using Atmel Studio 6 and c programming. Also to write code for LED blinking and test it on hardware.

Things needed:

Working Summary:

Step by Step Procedure:

Lets write simple code for LED blinking:

You can download entire files done here below:

Knock sensor using MMA7361 and Arduino UNO R3

AIM: To be innovative with accelerometer sensors and teach you how to use them. (With CODE + Connection Diagram given below)

How do I achieve m/s2 from output voltage of the sensor?

Things needed:

Connection diagram:

Download the Arduino code and needed images here:

DOWNLOAD HERE

DOWNLOAD CODE

READ MORE:

1.Why tap / knock sensor?

2. What are we using to build hardware?

3. Hardware working?

4. What to take care of during coding?

Making of the lamp pictures:

Final outcome:

3 Channel Simple PWM Example for AT89C51 (Revision 2.0)

Where do I start learning embedded systems?

C code to convert Integer into ASCII HEX

C code to convert floating point value to ASCII array

Taking address of "buffer" may require an extended pointer for this device

Generic LCD Driver for 16x2/ 16x4/ 20x2/ 20x4 HD44780 LCD Controllers

I²C for beginners made easy (Generic Study)

EEPROM Interfacing with 8051 using i2c (AT89C4051/AT89C51/AT89C52/AT89C52) Generic Driver

Difference between Atmega8A and Atmega16A

Turn on LED On/Off from internet using Arduino UNO R3 based Webserver (mini IOT example)

LED ON/ OFF using Serial Commands on Arduino Uno R3

Create header files for AT89C51

Delay function for PIC16F877A (delay in milli seconds)

Delay function for PIC16F877A (delay in milli seconds)

PIC12F510 based Voltage Trigger Switch (Industrial)

How to create delay function on AT89C2051/ AT89C4051/ AT89C51 for milli seconds delay time (V1.1 updated)

How to create delay function on AT89C2051/ AT89C4051/ AT89C51 for milli seconds delay time (V1.1 updated)

AT89C51 Based Object Counter using IR sensors and 4 Digit Seven Segment Display

Turn LED On wireless using Jennet Protocol with JN5148 Microcontroller Module

void delay_init(void);
void delayms(uint32_t n);

void TIM2_IRQHandler(void){
TIM2->SR&=~(1);
if(delay>0)delay--; //decrement every 1 ms if delay is greater than zero
}