For display, it’s using a Philips PCD8544 Graphical LCD. It features a whopping 84 x 48 pixels of resolution to ensure true clarity when playing Space Impact or Snake II

Apparently now you can buy a module with this graphical LCD on it for around RM 10 shipped from China.

Well, if you have a Nokia 3310 lying around you can rip out its’ LCD but take note that its a pain in the butt to solder.

This module I got has everything in it including the cool white backlight. Yes, backlight is important.

The difference between Graphical LCD and a normal LCD like I’ve used in this article is that you can selectively turn on or off every pixel and form your desired image. In a typical LCD like the HD 44780, you can only send specified ASCII characters and display corresponding texts.

Like most recent electronic components, this PCD8544 Graphical LCD runs on 3.3V logic. If you’re using a 5V microcontroller (ex. Arduino Uno), you’ll need a level shifter like 74HC4050. If not, you’ll fry this LCD right away.

A level shifter converts a 5V signal to a 3.3V signal. It’s a pretty simple IC to use.

Vcc connects to 3.3V and this IC is capable of level shifting 6 channels. The ‘A’ pin connects to the 5v MCU and the ‘Y’ pin connects to the GLCD.

The connections are as below :

pin 7 – Serial clock out (SCLK)
pin 6 – Serial data out (DIN)
pin 5 – Data/Command select (D/C)
pin 4 – LCD chip select (CS)
pin 3 – LCD reset (RST)

It’s not that much of a hassle to use a level shifter, you can build the entire circuit on a small breadboard.

I’m using Adafruit’s Library and modified the sample sketch to display bitmap images.

I found a software that can convert your typical JPEG, GIF, PNG or BMP images to binary, meaning ’0′ and ’1′s so that you can turn on or off individual pixels on the graphical LCD.

It’s called Image2GLCD.exe and it can be downloaded here –> http://www.avrportal.com/?page=image2glcd Credits to Jirawat Kongkaen for an awesome app.

Follow the settings shown above and click on Save. A file called Image2GLCD.c will be generated and in it you will find the image bits.

Copy this into your Arduino sketch and to display them just issue this command.

display.drawBitmap(0, 0, img, 80, 45, BLACK);

img being the name of your char variable. Remember to follow it up with display.display();

Here’s a demonstration video :

http://www.youtube.com/watch?v=y6Fvxi58Sjk

Download Code

http://www.youtube.com/watch?v=C6_ZEk9Jri0

Servo motor provides angular control to users, and unlike normal DC motors, it can only rotate from 0 to 180 degrees. It is very accurate and are often used in robotic applications.

Normally every servo motor has 3 connections, 5V (Red), Ground (Black) and Signal (White). The signal is connected to Digital Pin 9 of the Arduino.

As requested by one of my dear readers, I have made a simple Visual Basic program that will control the servo motor that is connected to an Arduino.

The Visual Basic and Arduino codes can be downloaded below.

Download Code

There are many types of relays but the most commonly used ones are electromechanical relays. They are cheap, simple and provide very good isolation between the control circuitry and the connection.

The diagram below shows the inner workings of a typical electromechanical relay.

The control circuitry is connected to a coil in the relay, and when the relay is energized, it will create a temporary magnetic field that will cause the relay contact to close and complete the circuit on the other side of the relay (usually a high voltage circuit).

Relays usually come in a box shape, like the ones I got below.

On the left is a 5V relay and on the right is a 24V relay. What this means is that the relay on the left requires just 5V to energize the relay coil while the one on the right requires 24V. Depending on the application, a 24V relay may be used if lets say a microcontroller wants to detect whether there is a 24V input.

These relays are rated to conduct up to 240V AC @ 10A or 30V DC @ 10A.

Below is a schematic diagram on how to connect a relay, I used an LED to display whether the relay is turned on or off.

Since this is a very simple circuit, I built it on a donut board.

The relay requires 3 connections, 5V, Ground and an Output pin from a microcontroller. The two connections on the screw terminal block will be shorted when the relay is turned on.

I plan on using Bluetooth to control the relay, so I used a bluetooth module highlighted in my previous post.

I programmed the Arduino to turn the relay on or off upon receiving an ‘o’ input. It will also print out the status of the relay. You can download this code at the end of the article.

Here is a video demonstration :

http://www.youtube.com/watch?v=AwLw7Db32TI

Download Code

Persistence of vision or POV in short is commonly found in electronic projects and there are a multitude of kits that you can buy out there.

The electronics club in my college wanted to make a hands-on lab for the juniors and my lecturer chose the POV project. He bought a kit as a sample and I had to reverse engineer it so that we can make the kit ourselves and save a whole lot of money.

Here’s the kit from Nixie Electronics.

And it costs a whopping RM 240 (or USD 80) !

Why buy when we can make it ourselves Let’s begin.

Using EAGLE, I draw out the schematics and also the PCB.

I designed the PCB to fit in a standard 25cm by 15cm board. I can make two sets of PCB using one board.

Printed out the PCB layout on a transparency sheet and the fun begins!

Exposing the UV board to fluorescent light for about 10 minutes. Used a heavy glass to press on the transparency sheet.

Because the board is quite big, I shifted the light source to the other side at around 5 minutes to ensure every part of the board gets an even exposure.

After exposure, the board is immersed in a sodium hydroxide solution to wash off the exposed photoresist layer.

Next, the board is immersed in a ferric chloride solution. Ferric chloride reacts with copper to form copper chloride. In other words, the copper on the board will dissolve in the ferric chloride solution but the photoresist layer that is covering all the tracks will protect the copper underneath from dissolving, thus resulting in copper tracks formed on the board.

Half way through the process. You can see the parts without the photoresist layer are being dissolved.

Do not dispose the ferric chloride solution by pouring it down the sink or drain! Find a proper chemical disposal service or at least just store it in a plastic bottle for the meantime.

The PCB in its’ full glory after the etching process is complete.

Got myself a pretty nice handsaw to cut the PCB.

Stanley MiniHack, can be found in most hardware shops for around RM 10.
Product link : http://goo.gl/7TU68

Almost perfect cut.

Drilling holes for components to go through.

To mount the DC motor, I had to go get some screws from a specialised nuts and bolts store. Couldn’t find it at a regular hardware shop.

Fitting the DC motor on the PCB. Thank god I got the measurements correctly when drawing the PCB. All the screw holes lined up perfectly.

The board with all the components on.

The spinning PCB. I used blue super-bright LEDs instead of regular ones.

Testing the PCB.

Now comes the hard part. The issue now is getting power to the spinning board. Because the board will constantly spin, you can’t just solder jumper wires.

We have to make use of the rotating spindle of the motor to transfer the power because it moves together with the spinning board.

Noticed that I carried a track to one of the screws on the motor? That is ground. The body of the dc motor is actually electrically connected to the spindle.

So that is half the work done, what about 5V?

We can create another layer on the spindle by first insulating part of it. I devised my own way that is to use shrink wraps. Bought the smallest diameter available.

Cut it to about half of the spindle’s height and apply heat (use lighter or match stick). It will shrink to the size of the spindle nicely.

Wind an exposed copper wire around the shrink wrap.

To transfer 5V to the outer part of the spindle, let’s turn to the PCB first. There are two big square pads beside the motor. They are connected to 5V.

Now we need to solder something to the pads that will make a connection to the outer part of the spindle. Take note that the spindle must be free to move.

I sacrificed a pen and took out its’ spring. Stretched it out and cut to the correct length.

The spring is actually made out of a wire that has elastic tension. We can make use of that to create a tension so that it is always in contact with the outer part of the spindle.

With that sorted out, we can proceed to mount the spinning board on the motor.

First, connect the ground to the inner part of the spindle. I used the wire connector (I wished I knew the proper name). See the picture below.

Took out the inner connector to use it to secure the ground wire to the spindle.

And the 5V connection to the outer part of the spindle. It will be quite a squeeze to get a soldering iron in between.

The last step is to drill holes for the mounting bracket. It is just a regular L bracket that can be found in all hardware shops.

Quite a tight fit, might need to change the PCB layout a bit in the next revision.

I haven’t figured out what to use for the base yet. Might need to use the mechanical lab to fabricate a heavy steel base for this. In the meantime, I just use a G clamp to secure it to a table.

Let it spin

http://www.youtube.com/watch?v=3AlAlqrqlu4

This project utilizes a PIC16F84A to blink the LEDs to form the characters.

The code can be downloaded below.

Download Code

Thanks for reading.

Below is a simple circuit that uses an ordinary push button to light up an LED. Normally I’ll need a pull-up resistor as shown in the red box, but with the built-in pull up resistors, I can totally remove that part and save myself a resistor and some hassle when routing PCBs.

As an example, I’ll be using the sample sketch found in the Arduino IDE. It’s located under Examples -> 02. Digital -> Button.

The only difference was I added a line that enables the built-in pull up resistors.

digitalWrite(buttonPin, HIGH);

See the video below to see it in action :

http://www.youtube.com/watch?v=cN-Av8_hT5Q

The only downside is, it doesn’t have built-in pull down resistors.

This shouldn’t be too much of a problem because the normal practice in electronics will be to use pull-ups and detect LOW signals.

I used the same exact sample code from the Arduino IDE. You can find it in File -> Examples -> LiquidCrystal -> SerialDisplay.

Just connect the TXD and RXD pins from the Bluetooth module to the Arduino. TXD to RXD and vice versa.

The circuit.

Here’s a video of me sending texts to the LCD from my computer through Bluetooth.

http://www.youtube.com/watch?v=9MTBTpbgShM

The module has a built-in GPS antenna and also the Skylab SKM53 chip.

The moment when I tried to plug the module on a breadboard, I realised that the pitch of the pins is not of regular size, its 2mm instead of the standard 2.54mm that we all get used to. Bummer. (Pitch is the distance between each pins, the standard distance is 0.1 inch which also translates to 2.54mm)

I had to make a PCB that will convert it into the standard 2.54mm pitch.

Without a laser printer, I had to trace the PCB on a transparency sheet.

As usual, I’m using the photoresist method.

Applying some minor corrections before etching the board.

Had to draw some dots to guide my drilling process.

The final product.

I’ll admit that it’s not the best soldering work. Just wanted to get it up and running.

I modified a sketch that I found online to display the GPS data on an LCD.

The sketch requires two libraries :

1. SoftwareSerial (included in Arduino 1.0 and above)
2. TinyGPS

Download Sketch

The GPS module takes around a minute to get a lock on the location. The LCD will then display the latitude and longtitude of the current location.

To find out where the corresponding latitude and longtitude is, you can enter it into the search bar of http://maps.google.com in the form of latitude,longtitude.

I found the shop at Lot S-084 on the Second Floor.

I was hoping it to be as big as Ace Hardware in Mid Valley.

The first thing I stumbled across is the Arduino shelve. Finally, a proper retail store selling Arduinos, no worries about warranty issues, online purhase and postage. I asked the salesperson and they confirmed that the Arduinos do come with a 1 year warranty.

Looking close, the prices are quite steep, though they come in retail boxes and there might be some goodies in it (I’m not really sure though).

Arduino Uno R3 for RM 139.90. I got it for around RM 100 online from an official distributor.

Proto Shield for RM 69.90. Honestly I think it should be a bit cheaper since the shield doesn’t really contain any electronic components, apart from an LED.

Below the Arduino shelve, I can see some unique stuff that we don’t get to buy over here previously.

Kits from Make magazine. Check out the price for the Ultimate Microcontroller Pack.

My favourite thing about the RadioShack store is their electronic components rack. It looks like those racks they use in car workshops. Everything is clearly labelled.

Another rack.

RadioShack branded multimeters. Prices are quite reasonable, considering that RadioShack stuffs have a considerable amount of quality.

And I found something, I watch the EEVblog on YouTube and he reviewed many multimeters and found out that the best one for under USD 100 is the Extech one. Nice to see that it’s now available at a retail store.

Finally, some electronic kits and sensors.

Overall, there are not many actual RadioShack stuff in the store, almost half of it are things that are already available over here. They sell thumb drives, wireless routers, handphone cases, audio/video cables and basic hardware tools. Only half of the things in the store would catch the attention of electronic enthusiasts.

I wish that they would bring over more stuffs that are available in the US. Having said that, it’s still nice to see some rare items on sale and I hope that the RadioShack name will stay in Malaysia for some time. (Info : This is not the first time RadioShack set its’ foot in Malaysia, they have stores in Bangsar back in the 90s but it didn’t caught on.)

If you’ve got time do drop by and check them out

The price is USD 8.60 which translates to around RM 27. Dealextreme provides free shipping too but the only downside is it’ll take two weeks. From my research, this is the cheapest way to get wireless communication to an Arduino. Other solutions will easily cost more than RM 100.

Received it exactly two weeks in my mail, comes with a female-to-female jumper cable just in case if the user decides to place the bluetooth module away from the Arduino.

Close-up shots.

From the picture above, there’s only four pins to be connected. Vcc, GND, RXD and TXD. Vcc can be anywhere between +3.6 to +6V as stated and GND is connected to.. ground.

The RXD pin will be connected to the Arduino’s TX pin, which is Digital Pin 1 and the TXD pin will be connected to the RX pin, which is the Digital Pin 0.

Pretty simple logic, the Bluetooth module RXD pin receives signals which are transmitted by the Arduino’s TX pin and vice versa.

I’ve decided to go the lazy way by connecting the module straight on a breadboard.

I’ve also included an LED on Digital Pin 13.

Because my computer didn’t have a built-in Bluetooth module, I have to get a Bluetooth USB adapter.

To test out the Bluetooth module, I wrote a simple code which will toggle an LED on or off according to the instructions sent from the computer. Sending a ’1′ will toggle the LED on or off. Other characters are not accepted.

Here’s a demonstration video

http://www.youtube.com/watch?v=B7pcEL8Wcmg

Download Code

http://www.youtube.com/watch?v=O5yD_u8CIEI

The Hardware

• Atmel ATmega328P Microcontroller with 32kB Program Memory and running at 16MHz
• Philips PCF8574A IO Port Expander
• Maxim DS1307 Real-Time Clock
• 16×2 HD44780 Monochrome LCD with Blue Backlight
• UM66 Melody IC
• 4×3 Numerical Keypad
• LM7805 Voltage Regulator

Features

• Display Time in 12-Hour AM/PM Format
• Display Date in dd/mm/yyyy Format
• Display Day
• Set Alarm Time
• Set Date
• Set Time
• Menu Based Navigation System
• Anti-Sleepiness Alarm Function
• Auto Generated Day Function

The Making of the Digital Alarm Clock

This Digital Alarm Clock project started its’ life on a breadboard, and with a brand new ATmega328P MCU bought from Cytron.

Together with the Microcontroller, I bought the UC00B USB to Serial adapter to program the MCU using the Arduino IDE.

To make it work on the Arduino platform, the microcontroller must have the appropriate bootloader. There are many ways to burn the bootloader but I settled on the ArduinoISP method (using my Arduino Uno R3).

I made a video on the bootloader burning process.

http://www.youtube.com/watch?v=NsGTJKQIEsM

After successfully burning the bootloader, I can now use the Cytron UC00B USB to Serial adapter to upload code into the MCU.

With the basic Arduino circuit done, I can start the programming and also assembling other hardware components.

To read more on how to make your own Arduino on a breadboard, read this post

Next, I made some special push buttons so that the user can identify its’ function more easily.

Here’s how I assembled these push buttons.

http://www.youtube.com/watch?v=tFRikvcH5B0

I ended up using 4 breadboards to completely construct the prototype circuit.

Writing the Code

First and foremost, I should mention and give credit to a few libraries that I’ve had to use in my code.

• Wire by Arduino (Source) : Establish I2C connection to/from the PCF8574A and DS1307
• LiquidCrystal by Arduino (Source) : Interface with the HD44780 LCD
• I2CKeypad by Angel Sancho (Source) : Interface with the 4×3 Keypad through the PCF8574A
• TrueRandom by Peter Knight (Source) : Generate true random numbers for the random math question

Other than the libraries mention above, the code is solely written by yours truly.

It is 1,029 lines long, and takes up around 16kB of program memory. It took me close to 50 hours to come up with this.

My initial idea of using an ATmega16 to cut cost was scrapped because this code and the bootloader takes up around 18kB of  program memory, which is more than the 16kB capacity of the ATmega16.

Designing the Schematic and PCB in Eagle 6.2.0

I chose to use the Eagle software to design the schematic and PCB because the library is huge and it’s simple to use (IMHO).

This is the final revision of the schematic :

Initially, I plan to make a dual layer PCB but because of time constraint, I had to settle for a single layer PCB.

This is the final revision of my PCB.

I’ll admit that I used autoroute, and it’s not that smart, so I had to give it a bigger workspace to work on. Thus I’m using a 25cm by 15cm PCB.

Printed the PCB layout on a transparency sheet to mask the PCB from UV exposure.

I’ve wrote a post before this on how to make your own PCB. You can read them here

The end result.

Tour of the Board

At the centre of the board is where all the magic happens, ATmega328P MCU, DS1307 Real-Time Clock and the PCF8574A IO Port Expander.

There is also a backup battery for the DS1307 Real-Time Clock IC. Even if the power runs out, the ‘clock’ will still continue to tick.

The 6 Buttons. Menu, Back, Forward, Cancel, OK and Alarm ON/OFF.

At the bottom left is the 4×3 Numerical Keypad for user input. It is used for setting the time, date and also answering the math question.

At the top left are the buzzer, the UM66 Melody IC, and a 10k potentiometer to adjust the LCD Contrast.

Lastly, at the left hand side of the board is the programmer port, where I can plug in the UC00B USB to Serial adapter to upload a new code into the ATmega328P.

Features

Menu-Based Navigation System

The user can press the Back and Forward button to scroll through the Menu. To select the desired function, press Enter.

Anti-Sleepiness Alarm Function

To turn off the Alarm, the user has to answer a simple math question. The alarm will not turn off until a correct answer has been entered. The question is generated randomly everytime the alarm rings.

Auto Generated Day Function

To set the date, the user doesn’t have to enter the Day. The code has an algorithm that will determine the correct Day that corresponds to the date entered.

Project Costing

Below is a list of all the components that are used in this project and also their cost. So much money!

The total cost shown below does not even reflect the true amount of money I spent, there are things like troubleshooting cost, buying new components to try out, soldering cost, flux, damaged components, etc.

Looking aside the cost, I’m thankful that I’m able to complete this project and I did learn alot from it.

I hope you’ve enjoyed reading this post as much as I’ve did during the making of this project.

Thank you

It is sold for RM 55 but I managed to grab it for only RM 1 cent! Thanks to their 1 cent promotion

I managed to get other amazing stuffs as well. Back to the BBFuino.

The BBFuino is not a complete Arduino in the sense that it needs an external USB to Serial adapter. In their website, they stated that it works with their UC00A or UC00B. I only bought the UC00B because it’s cheaper. However, in the User’s Manual, they did not mention how to connect the UC00B to the BBFuino.

The UC00B.

Here’s my hand-drawn schematic

I did not have a female to female jumper in hand so had to resort to this.

Here’s a video on uploading a simple blink sketch to the BBFuino.

Next post will be mounting an 8×2 LCD on the BBFuino

Now I will address one of the issues of making your own Arduino. On the Uno boards, there’s an IC which is responsible as a USB to serial converter and it makes it possible to program the Arduino and also communicate with it from the computer. The problem here is the IC is an SMD (Surface Mounted Device). The R3 uses an ATmega 16U2 while the older revisions uses the 8U2.

Then, what about the older Arduinos? The Duemilanove? Still no luck, it uses a FT232RL chip, which is also an SMD.

To make it easier, I’ll show you an alternative. Just get a ready made USB to Serial chip

There are so many of them online, but I’ve decided to get it from Cytron because their service is top-notch.

It’s called the UC00B. Only RM 19.00. Link here.

Close-up.

Installation is pretty easy. Just download the driver from Cytron’s website and execute the installer. Here’s what you’ll see in the device manager after installation.

With this done, we can concentrate on the Arduino.

There are many schematics available online for constructing an Arduino on a breadboard, but after an extensive research and some personal modifications, I’ve come up with this.

You can download the EAGLE schematic file here.

Here’s the constructed circuit on a breadboard.

Without the connections to the UC00B, the circuit is in fact very simple.

There are many ways of connecting the UC00B to the breadboard but I’ve gone the lazy way

Finally to test it, just upload a simple blink sketch.

If it says Done uploading means the Arduino is working fine.

I hope this post is helpful to those who want to go into the Arduino world but can’t afford a full fledged Uno board.

Have a good day

In this post I’m going to focus on the heart of an Arduino, the Atmel ATmega 328P.

A brief introduction on this little beast.

• 8-bit MCU
• 32kB Flash Memory
• 1kB EEPROM
• 2kB SRAM
• 23 general purpose IO lines
• 6-channel 10 bit ADC
• SPI and I2C capabilities

The ATmega 328P first appeared on the Arduino Duemilanove where it replaces the ATmega 168 which has a smaller program memory.

I tried to get one from Jalan Pasar but it costs RM 40+, an outrageous price. Decided to get it online from Cytron together with the USB to UART adapter which I will highlight in the next post.

Ordered on Saturday, arrived on Monday morning.

The ATmega 328P, they even applied a sticker on it to clearly show the function of each pin. Some may like it, some may not but I don’t mind it at all. Thanks Cytron

To burn the bootloader on the new chip, you need another Arduino. In this demonstration I used my Uno R3.

First things first, before we start, we need to upload the Arduino ISP sketch into the Uno R3. I uploaded the one from the 0023 version because the 1.0 was giving me problems.

Next, following the guide found on the official Arduino website (here), here is the blank ATmega 328P MCU connected to the Uno R3.

Now fire up the Arduino 1.0 IDE, under Tools and Programmer, select Arduino as ISP.

To start the process, simply click on Burn Bootloader.

This will take some time, here’s a video of the whole process.

When the TX and RX lights stop flashing, it’s done.

To test it, I swapped the original ATmega 328P on my Uno R3 to the new one I just got from Cytron.

It works! Stay tuned for Part 2 where I’ll be assembling a full circuit on the breadboard and program it using a USB to UART converter.

I bought this because it has 5 digits on a single package and it looks much neater than the individual 7 segment displays.

The reason why I wrote this post is not so much to show the display but rather to highlight a technique called multiplexing.

I will start by showing you the pins of this 5 digit display.

In a single digit 7-segment display, there are 8 connections, the 7 individual connections for the 7 LEDs and also one ground connection (for common-cathode type). But does that mean if we have 5 digits we need to use 40 pins? (5 digits x 8 connections)

From the picture above you can see that this 5 digit display only has 22 pins, and even then, not all are used for the 5 digits. Some are for the decimal points and the colon. In fact for the 5 digits, we only need 12 pins. How do we make it work?

This is a pinout diagram that I’ve drawn out myself (I can’t find any information about this particular display on the Internet).

There are only 7 pins which controls the 7 segments on ALL of the digits but at any one time these 7 pins can only control a single digit. To decide which digits to control, we use the top right-most pins, sending a low on one these pins means selecting that particular digit to be controlled. Sounds confusing?

Let me try again. In simple words, we can only change or display one digit at a time. But with the sheer speed of microcontrollers, we can display each digits one after another so quickly that the human eye can’t notice and will appear as if all digits are on at the same time. This method is called multiplexing.

I’ll probably do a video soon to explain more about multiplexing and how it works but for the meantime here’s a demonstration on making the display show all 5 digits at the same time.

It’s been a long time since I used a PIC microcontroller.

And the 5 digit 7-segment display. Only 14 connections used.

Finally, the code which made it all work.

I used 1ms of delay to display each digit and that is fast enough to fool the human’s eye. Any faster than that will cause distortion and any slower than that will cause the digits to flicker.

The whole circuit in action. The display is actually adequately bright but the camera didn’t really do it justice.

A dark shot.

Now I’m off to write an assembly code to interface with the DS1307 Real Time Clock IC. Stay tuned

•  Real-Time Clock (RTC) Counts Seconds, Minutes, Hours, Date of the Month, Month, Day of the week, and Year with Leap-Year Compensation Valid Up to 2100
• 56-Byte, Battery-Backed, General-Purpose RAM with Unlimited Writes
• I²C Serial Interface
• Programmable Square-Wave Output Signal
• Automatic Power-Fail Detect and Switch Circuitry
• Consumes Less than 500nA in Battery-Backup Mode with Oscillator Running
• Optional Industrial Temperature Range: -40°C to +85°C
• Available in 8-Pin Plastic DIP or SO

The DS1307 IC has only 8 pins and the pinout are as follows :

Because the DS1307 communicates through I2C interface, we need two pull up resistors for both the SDA and SCL channel. I used 10k in my circuit.

For the crystal, the datasheet states that it needs a 32.768kHz Quartz Crystal. You will usually find these on digital watches.

The DS1307 needs a coin cell battery to provide backup power in case the power on the main circuit goes off, for instance when the user is changing the battery of the device. The coin cell battery is connected to Vbat and GND.

I got this coin cell battery holder, it’s for the CR2032 type.

And a cheap battery to go with it.

A coin cell battery is usually rated at 3V but I got 3.3V out of this guy. A quick read on the datasheet confirms that it’s alright.

Here’s the DS1307 IC set up on the Arduino Prototype Shield.

I found a well written library called the RTClib and in it there’s an example sketch which sets the time on the DS1307 IC. Upon the first power up, the DS1307 will start counting from 1/1/2000 0:00 which is not right, so we need to set it up to the correct date and time. We’ll only need to do this once as long as the coin cell battery is not removed.

What this code does is basically sets the time and date according to when the sketch is compiled. Of course there will be a slight delay from the time the code compiles and it is fully uploaded to the Arduino. I think it’s less of a problem on the newer Arduinos that are using the Atmel 8U2 and 16U2 as the upload times are significantly faster.

The code will read the time and date from the DS1307 and display it on the Serial Monitor.

Now that I know the time and date is correct, I went on to build a fully independent circuit. Which means the circuit is not in any way connected to a computer.

Used an LCD to display the time and date and the circuit is powered by a 9V battery.

With the RTClib, the programming is made so much easier and I can go as far to say that it’s cheating. LOL. To be frank, I’m still very new and don’t have much knowledge on the I2C communication. With such good libraries on the Arduino platform, it has made me kind of lazy

I have thought of building a permanent digital clock circuit on a PCB and I’m still deciding on what power source to use so that the batteries doesn’t need to be changed often. To do that I need to know the power consumption so I hooked up the circuit in series with the multimeter and measured its’ current usage.

Around 67mA. It’s not much but I think I can get it lower by using a 7 segment display. I think I’ll try this on a PIC microcontroller too to compare their power consumption.

Till then

Usually for the digital pins, we write instructions such as digitalWrite(13, HIGH). To do that with analog pins, simply use digits 14 to 19.

Pin 14 being Analog 0, 15 being Analog 1 and so on. Or you can just write digitalWrite(A0, HIGH).

Here’s a simple sketch to test that out. Turn on an LED that’s connected to Analog 0.

The proof.

What about Digital Inputs? Just treat the Analog pins like they’re digital by using pins 14 to 19 or A0 to A5.

I wrote a sample sketch to test whether the Analog pins can be turned to Digital inputs. When the button is pressed, the LED will light up for two seconds.

Ta-da!

No digital pins were used in these tests

I got the inspiration from the example Twitter sketch in the Ethernet Library. I just modified it so that now it displays the feeds on the LCD instead of the Serial Monitor.

The sketch.

Did you notice the sketch size? 16kB! I think this is the first time I’m using that much. Probably because I’m using both the Ethernet and LiquidCrystal library. If I have an older Arduino with ATmega 168 I won’t be able to do this anymore.

In the sketch I had to change the usual pin assignments for the LCD. Because the Ethernet Shield is using pins 10, 11, 12 and 13, I had to avoid using these for the LCD. Also I tried not to use pin 4 because that’s reserved for the SD card on the shield.

This is how it looked like, two shields on top of the Arduino Uno.

Notice that my home made shield is tilted? This is why.

I made the Prototype Shield before I got the Ethernet Shield. I did not expect the Ethernet port to be that high. The board is now hitting on the port. Luckily, the contact between the pins are still good and all I have to do is to apply some cellotape to prevent the pins from shorting out. Time for Home Made Prototype Shield R2?

Another angle.

When mounted on the Arduino Uno itself, it’s fine though there’s just less than 1mm of clearance.

Lesson learnt. In my next revision of the Prototype Shield, I have to take into account of other type of shields too.

Thanks for reading. Take care

This shield only supports MicroSD cards but other 3rd party shields support normal SD cards as well. And with the new Library, SDHC and MicroSDHC cards are supported too

The card slot on the official shield is spring loaded, which means push to insert and also push to eject.

I’m using a standard microSD card. I believe it’s Class 4 judging by the write speeds.

To test it out, I loaded the SD CardInfo sample sketch and on my first try, it didn’t work. Later I found out that I also need to provide external power higher than 5 Volts. I used a 9V battery. I suspect that it’s the 3.3V voltage regulator. All voltage regulators have a minimum voltage input rating, they are usually around 2 Volts higher than its’ regulated voltage.

After applying sufficient voltage, this came out.

Oh yeah, the SD Library only supports FAT filesystem. Make sure you’ve formatted the card before putting it in the Arduino.

To test out the capability of the SD Library, I made up a simple circuit that consists of a push button and the Arduino will log how many times the button is pressed.

Here’s the code.

And after a few pushes of the button, I read the card with my computer.

The log file.

The abilities of an Arduino are endless. The question is, is there anything that the Arduino can’t do?

I made an unboxing video for it, though it may be boring to some of you but I hope it’s at least informative

The box.

The header pins are gold plated.

The Wiznet W5100 chipset, the heart of the Arduino Ethernet Shield.

The Ethernet Shield stacked on top of the Arduino Uno R3.

The Shield also includes a microSD card slot and it is supported by the official SD Library.

The 10/100 Ethernet jack.

To test it, I used a sample sketch found on one of the articles on homebrew-tech.com,
Arduino R3: Testing Ethernet Shield R3.

Before that, I plugged in an Ethernet cable from the Shield to my switch.

Basically, the Arduino serves up a webpage where the user can turn an LED on or off.

The LED is connected to Digital Pin 8.

More exciting projects coming soon

I’m doing this so that I can practise my soldering too. I will be using a pre-made PCB because it’s quite a simple circuit.

This is called a strip board because it has strips of copper on it so that any component that is on the same column will have electrical connection with each other.

I bought a few of these as spares and stored them for a long time, and they oxidised. I need to rub those off with a sand paper before soldering anything on it. The difference is simply like night and day.

I’ll be using an old parallel cable from my 1998 HP printer.

On one end is a DB-25 port, which plugs into the computer.

And on the other, a DB-36 port which plugs into the printer. This port is of no use so I’ll be getting rid of it.

Pried the case apart and revealed the individual wires.

I won’t be cutting the port header off so soon. I’ll refer to the schematic, cut and solder each wire individually before moving to the next one. That will minimize confusion because there’s just too much of them.

The parallel port cannot provide power, so I need to pull 5 Volts from the USB port to power up the LCD. I cut off the USB cable of one of my faulty mouse to be used on the PCB.

I just need three components. A 16 pin female header, 10k potentiometer and an LCD of course.

These are what I used to solder. A Hakko 20W soldering iron, some random solder sucker and a roll of solder wire.

The end result. I used zip ties to secure the cable to prevent any external force from pulling the cable off the PCB.

What’s left is to plug in the LCD and turn on the computer

Lights off.

You can actually do a lot of things with LCD Smartie. To find out more, you can check it out at http://lcdsmartie.sourceforge.net

Thanks for reading

It’s a paper based keypad and it costs less than RM 7. Perfect for my needs. Another plus point about this keypad is I don’t need to solder any wires or headers on it.

It already comes with a female header and all I need to do is to plug in a male-to-male header into it. That will make it easier to be plugged into a breadboard.

Remember this circuit?

It’s the 7 Segment circuit from two posts ago. Now I plan to add in the keypad to display the digits according to what I press on the keypad.

Unfortunately, I ran out of digital pins. I didn’t expect this day to come so soon, I thought the Arduino Mega is overkill but now I understand why some people prefer it over the Uno.

From the picture, you might think that the pins are just enough. But actually it’s not. I’m already taking the first two digital pins which are RX and TX and they have 1k of resistance from the MCU’s pin.

Since I don’t have the luxury of owning a Mega, what I can do is to make use of my two Arduinos, the Uno and the Nano. I connected the keypad to the Nano and program it to talk to the Uno through serial communication.

Connecting it is pretty simple, the TX pin from the Nano goes to RX on the Uno and RX from the Nano goes to TX on the Uno. Basically just inverting them.

I also linked both the 5V and Ground together so that they can share the power source. All I need to do is to either power up the Nano or the Uno.

Here is the code I wrote for the Uno,

and the Nano,

Two Arduinos working hand in hand

And finally, here’s a demonstration video.

Thanks for reading

I received two emails, stating that my article is featured on the front page and both of these emails gave me a free Pro account.

They are giving me a 1 year Pro membership and another 3 months Pro membership for free. So I’ve decided to give away the 3 months Pro membership to one of my lucky readers

What is a Pro membership? These are some of the highlights found on the Instructables website.

Since I have only one Pro membership to give away, I’ll select the first person who writes me a comment below

Please write down your real e-mail address in the field before commenting.

Lastly, I would like to say a big thank you to the kind people at Instructables.

I’ve decided to show the circuit construction in a video for the convenience of my readers. Without further ado, here it is.

As mentioned in the video, I used a common anode 7 segment display. What this means is, to turn on a specific LED, the microcontroller have to send a LOW signal. To turn the whole 7 segment display off, all of the pins have to be set HIGH.

Here’s a simple pinout diagram I found on the internet.

With that in mind, I wrote a function to properly display digits and also to clear the whole display if desired. Here is the code.

There are many interesting things that a 7 segment display can do. In the next post, I’ll be showing an example of it

Thanks for reading.

My aim of this project is to create my own Arduino Prototype Shield. With the PCB done, it’s time to turn to the components that will be mounted on the board.

Nothing spectacular, just some connectors and a mini breadboard.

There’s a reason why I chose a dark blue breadboard. The truth is I’m very particular about colour schemes. When possible I’ll always coordinate the colours in the things that I buy or make, for example my desktop computer that I assembled myself. Everything in it has to be in the right colour or matching colour. I guess I have colour OCD lol.

Coming back to this project, the PCB that I bought is actually yellow in colour but unfortunately, I can’t find it in any other colour. It looks absolutely disgusting. This is a PCB I did in college.

I have no control over that project because we were required to follow instructions. But this is my own project so I’ve got to do something about it and I bought this.

A white spray paint. I wanted a white – dark blue – black colour scheme. I think it’ll look awesome

This is the board after painting. Took a full day to dry because I applied a very thick coat. It actually looks very shiny but the camera did not pick that up.

Then I drilled holes for the components to go through and soldered the components.

Pardon my soldering skills. It’s been a long time since I used a soldering iron, I’ve been relying on breadboard too much these days.

This is how it looks like the right side up.

The last step would be to stick the mini breadboard on it.

Here is the final product in a few angles.

The Arduino Prototype Shield mounted on my Arduino Uno R3.

Lastly, I did this just for laughs. Arduino on an Arduino lol.

That’s the end of my project and I hope that you’ve enjoyed reading it. Thank you

In the last post, I showed the entire process of etching the photo resist layer. Now what’s left of the photo resist layer (green in colour) is the actual PCB layout.

Beneath the photo resist layer is the copper layer and from the picture above, they are still intact. Our aim is to actually get rid of the copper layers that are not covered with the photo resist layer. Any copper that is hidden below the photo resist layer will remain intact in the etching process.

I bought this bottle of ferric chloride etchant for only RM 6.

It’s pretty concentrated so a small amount would suffice. Always use a plastic container because this stuff is corrosive.

Dipped the whole board into the solution and the whole process took about 20 minutes. It took so long because I did not heat up the etchant. The trick of doing this properly is to leave it for 4-5 minutes and then agitate it for 30 seconds and then repeat the process again and again till all the copper layers are etched away.

This is how it looks like when the process is complete. All of the unwanted copper areas are gone and now what’s left are those hiding below the photo resist layer.

I tried to wash it off with water but it didn’t work. So I went to a pharmacy to get this.

The pharmacy guy looked at me suspiciously and asked me what do I want to do with it. If I told him that it’s for my electronic project sure it’ll take some explanation. I just told him that I need to fill up my first aid kit lol.

By the way those swabs are soaked with rubbing alcohol and they’re exactly what I needed. The box contains 100 swabs and it costs RM 6. And it really works.

The board with all of its copper glory.

That’s it for Part 2. In Part 3, I’ll be posting the final steps in making this board an Arduino Prototype Shield.

In the mean time, here’s a teaser for you all. Try and guess what I’ll be doing and post it in the comments section below.

Thank you

Part 3 is up. Read it here.

That is a colossal amount of money for something so simple. So I took the challenge to make this myself. I bought all of the tools needed for this process and if you’ve not checked it out, you might want to read this first.

I found an Eagle PCB file for this at the arduino website and I did some modifications like adding my own name on it.

Then I tried to print it out on a transparency paper but it didn’t turn out well.

It didn’t turn out well because I printed it using an inkjet printer. The ink will dry up very quickly and the printing will fade in just a matter of minutes. To do this properly I need to print it with a laser printer or any printer that uses toner, not ink. Unfortunately I don’t have such luxury so I have to get it done outside.

I print them out on a normal piece of A4 paper first and went to a photocopying shop to ask them to print it out on my transparency paper. Believe it or not most shops were not willing to print on transparency paper because they worry that it might get stuck in their machines. I finally get it done at a shop near my house and that’s the 5th shop that I tried. Thank God the owner was kind enough to try it after some persuasion.

This is the result. It’s a million times better than what my printer can do.

I printed a few examples of the same circuit on the transparency paper and I stacked two of them on top of each other to get a perfect image.

The preparation is done and now it’s time to go into a dark room for the rest of the process. When I said dark room I meant a room without any fluorescent or sun light. It is just like developing camera films the old school way. I can have a light but it must not be fluorescent, white or sunlight. Single coloured lights such as red, blue or yellow can be used. I’m using an old spotlight and it uses a traditional yellow bulb. My webcam automatically turned on its’ white balance mode and the light appears to be white but in fact it is yellow.

I opened up the PCB packaging and the PCB is covered by a blue sticker to prevent it from accidently exposed to light. This blue sticker also allows me to draw some lines to guide me when cutting the PCB to length.

The protective blue sticker layer.

Tried to be as accurate as possible but the low lighting condition doesn’t help at all.

Used a small hand saw to cut it. I did this in my room and now the floor is covered with dust. Bad choice of work area.

Sanded off the rough edges using an 80 grit sand paper. The roughest I can find. Looks pretty decent to me.

Now it’s time to peel off the protective layer (the blue sticker).

I must now stick the transparency paper on it as quickly as possible to avoid any unwanted exposure.

To properly press the transparency paper against the PCB, I used my sister’s photo frame.

Set my phone’s timer to 8 minutes to properly expose the board. I’m using a normal fluorescent lamp so that’s why it took so long. If you’re using UV light, 90 seconds is more than enough.

The waiting begins.

While waiting, I prepared the etchant for the photo resist layer. Just mixed some sodium hydroxide crystals with water. Two to three teaspoons is enough.

After 8 minutes I took out the PCB and dipped it into the etchant solution. Constantly agitated the board in the solution for around 10 minutes and the unwanted areas were washed off. Here’s the final result.

I’ll continue this in the next post. The next step will be to etch the unwanted copper areas. Stay tuned

Part 2 is up. Click here.

I made the PCB shown above in college, it was for an IR Transmitter and Receiver project. I’ve always wanted to make my own PCB at home but couldn’t find the time and resources to do it until now.

The first thing I bought was a hand drill, it is necessary to make holes for the components to go through the board. It retails for RM 65 and it doesn’t have any warranty. Fingers crossed.

The drill is pretty simple. No speed adjustments or a trigger, just an on/off switch.

Comes with 0.5, 1.0, 1.5, 2.4 and 3.0 mm drill bits.

I’ll be using only the 1.0mm drill bit. It’s large enough for most components to through. So far I’ve not been able to find any shops that sells 1.0mm drill bit, I’ve got to be extra careful with it for now.

Next are the PCBs. I’m planning to go down the photo-resist route so I bought the appropriate type. They cost RM 11 each.

This board can also be exposed using normal fluorescent light. It takes longer though, around 6 to 10 minutes as stated.

I’ll be using my mum’s reading light. It uses a fluorescent lamp tube.

Next, is the etchant chemical for the photo resist coating. They are actually sodium hydroxide, so I bought them in the crystal form. Don’t show it in front of a police, it looks very suspicious lol. Just mix it with water and you’re good to go.

Finally, this is the ferric chloride acid for etching the copper layer. They cost RM 6 per bottle.

A word of warning for those who are using this. Do not pour it into your sink or drain after using. It is poisonous and corrosive. Doing so will only cause it to end up in your drinks or food in the future. Collect all of the used chemical and send it to your local chemical disposal shop.

I already have in mind what I’m going to make, it’s going to be exciting I should be posting an update on the PCB making process in a few days. Stay tuned.

I don’t have much knowledge in the 555 Timer but from what I’ve read so far, it has 3 modes of operation. They are monostable, bistable, and astable. In this demo, I’ll be using the astable mode because it can provide a square wave oscillation at pin 3. With that, I can do a simple flashing LED circuit like I’ve done in the past with both PIC and the Arduino. Only this time there’s no microcontroller and programming involved.

In a microcontroller, we can program it to flash the LED in any desired intervals but for the 555 Timer, the intervals (or the oscillation frequency) is based on the resistor and capacitor values used in the circuit. Actually I’m still not familiar with how to calculate it, so I went to look for a schematic online.

This circuit uses a 1uF capacitor but unfortunately I don’t have it, so I played mix and match with all the resistors and capacitors I have to get a low enough frequency that the LED flashes can be seen by the eye.

Somehow I ended up using two 100uF capacitors in the circuit and I will report back why. In the meantime, here’s a video showing how the circuit works.

Thanks for reading

To produce sound, we need a speaker. Normal speakers are overkill in this simple demonstration, so I dug out a computer buzzer from an old Pentium II PC and to my delight, it still works!

It has two leads, positive and negative. On the other end, there’s a pin header where normally it’ll be plugged into a computer motherboard.

To overcome that, I’ve used two jumper cables to connect it to the Arduino. I’ll be using the Uno R3 because these jumper cables can be plugged straight into it. Positive to Digital Pin 8 and negative to Ground.

I wish that I can write my own code to produce a melody but unfortunately, I’m not musically inclined so I used a sample sketch from the Arduino Cookbook.

So, here it is, playing Twinkle Twinkle Little Star

The purpose of this project that I’m doing is to solve this once and for all. With the push of a button, a fake screenshot of Excel will be immediately shown on your screen. Of course this button can be placed anywhere on your desk, I will most likely place it near the floor where I can gently hit it with my foot to trigger it. In the video I have the button on the breadboard to make it easier for me to demonstrate. Without further ado, here’s the video.

As mentioned in the video, I’ve written the program in Visual Basic. The program is very simple, once it detects that the button is being pressed, it will launch another form and that particular form will display the full screen image.

Here is the main program.

Once it is launched, it will automatically start running and receiving serial data from the Arduino.

And when the button is pressed, it will launch a new form that will display the full screen image. Here’s the new form.

If desired, the image can be changed, perhaps to a screenshot showing Microsoft Word?

Finally, we still need to program the Arduino to send data over the serial port.

Besides the reason stated above, this project can also be useful if the user wants to leave his/her computer for a moment and wish to hide what they’re doing.

Lastly, I should mention that I will not be held liable for any decline of productivity in your office

Thanks for reading.

Currently, the only programming language that I’m familiar with and is able to create a GUI (Graphical User Interface) Program (aka not the white text on a black background program) is Visual Basic. I’ll be using the Express edition since it’s free. Who doesn’t like free stuff?

In this demonstration, I’ll be creating a simple program in Visual Basic 2010 that allows the user to turn an LED On or Off on the Arduino. The LED is connected to Digital Pin 13 of the Arduino Uno.

Don’t freak out cause I didn’t use a resistor for the LED. This particular type of LED I bought has very high impedance, I’m not worried that it will burn out.

I wrote a code for the Arduino so that it can receive instructions from the computer.

I enclosed the 1 and 0 with inverted commas because the value that I’ll be sending from the computer will actually be in ASCII.

Here is a screenshot of the program written in Visual Studio 2010 Express.

The serial port baud rate is set to 9600 and the Arduino Uno is using COM4. Visual Basic 2010 comes with the SerialPort function, so it’s pretty simple to program.

Here is a video demonstrating how the program and the Arduino work together.

Thanks for reading

Download Code

I’ll be using a HD44780 character LCD to display the voltage output and a 10k potentiometer to vary the input voltage going into the analog input. The Arduino analog inputs can only take in maximum of 5 Volts. Any higher than that you’ll risk burning the Arduino.

Here’s the code :

That’s what I love about Arduinos, it is really really simple to program. The Arduino library is huge and you will often find what you need in the library without having to write your own. Oh yeah, this is the circuit and I’ll compare the readings with my trusty voltmeter in real-time.

I’m starting to like the Arduino Nano and I find myself using it more often than my Uno. If you haven’t read my previous posts about Arduinos, I do have two Arduinos, the Uno R3 and this, the Nano V3.0. First, is because the Nano plugs into a breadboard which is perfect for prototyping and secondly, the Uno R3 is expensive and I don’t want to risk ruining it if I did anything silly.

Without further ado, this is a video showing how the code works :

Thanks for reading

First and foremost, we must have a clear picture on what the built-in ADC is doing. Think of it like there’s a little guy living inside the chip that’s doing all the conversion process. By default it is off, and the user need to ask it to ‘wake up’ to execute the conversion. Here’s a flow diagram to better illustrate the ADC process.

The flow diagram above does not include the configuration but I’ll cover it as I go. Having a rough picture of the ADC process is essential for understanding the ADC on the PIC16F877A.

Now, onto the configuration of the ADC. There are only FOUR registers that you need to understand to configure the ADC. They are ADCON0, ADCON1, ADRESH and ADRESL. The two most important ones are ADCON0 and ADCON1. ADRESH and ADRESL are just the registers where the ADC stores the result of the conversion.

ADCON0

The user has to select the correct clock conversion. The period must be at least more than 1.6us to obtain an accurate conversion. For example, I’m using a 4MHz crystal oscillator on my PIC16F877A. So if I select Fosc/2, thats 2MHz and the period is just 500ns and it’s far less than the 1.6us required.

What if I select Fosc/8? That will give me 0.5MHz and the period is 2us. That is more than 1.6us so it can be selected. So, my ADCON0 is now 01xx xxxx.

Now onto selecting the Analog Channel. The ADC can only have one input at a time so the user must select which pin he/she wants to use.

Referring to the PIC16F877A pinout diagram,

These are the Analog Channels available. Let’s say in my circuit I have an input into Analog Channel 3 (which is also PORTA bit 3), so I have to set ADCON0 to 0101 1xxx.

Lastly, we will set all these bits to 0 because this is just the initialization, the actual program has yet to start (Later in the code I will individually set these bits to enable ADC). So that makes ADCON0 to be 0101 1000.

ADCON1

The ADFM bit determines how the result of the ADC is justified. The ADC on the PIC16F877A has 10-bits of resolution, so of course a single register (that has 8 bits) is not enough to contain the 10-bits result. Therefore, two registers are required to store the results. ADRESH and ADRESL (H is the high byte while L is the low byte).

Two registers will allow us to store up to 16 bits, but since there are only 10 bits, we have the flexibility to align it right justified or left justified. Hopefully you will get the picture from the diagram below.

Storing the result in left justified mode is weird and unusual but it gives the user flexibility. Let’s say my application does not need the 10-bit accuracy, 8 bits is more than enough. So I can just take the result in ADRESH and ignore the remaining two least significant bits in ADRESL (you cannot ignore the two highest significant bit because that will cause the result to be inaccurate). That makes it easier to move values to other registers. Yes, the accuracy of the result will be slightly affected but it is not so critical in applications where you don’t need accuracy, like my ADC Demo shown here. So, now the value of ADCON1 is 0xxx xxxx.

Next is the ADCS2 bit. Earlier, I calculated that Fosc/8 is adequate, so I selected it in ADCON0. But for Fosc/8, we need to set the ADCS2 bit in ADCON1 also. So, the value of ADCON1 will be 00xx xxxx.

Lastly, the most important part of the ADC configuration is to select the mode for each Analog channel. As shown before, we have Analog Channel 0 to 7. All these inputs can either be set to analog or digital. Referring to the table above, if we don’t need any analog inputs and require more digital pins (let’s say for a few LCDs), we can set the PCFG3:0 bits to be 011x. But in this case we do need the Analog inputs, so for simplicity we will set all of them to be in analog mode. Therefore, our final value for ADCON1 is 0000 0000.

One important thing to note is that I’ve selected Vdd as the Vref+ and Vss as the Vref-, that means that my conversion range is from 0V to 5V. If you need it to be other than that, you can set a custom Vref value by choosing other configurations of PCFG3:0.

That should be it for the configuration of the ADC on the PIC16F877A. I hope this will help you to get started. Thanks for reading

Yes I’ll try. From all the Arduino programming, hopefully I’ll know a thing or two on how to write in C.

But first, when installing MPLAB, make sure that you have installed the Hi-Tech C Compiler also, you will be prompted when the MPLAB installation is done.

Next, when creating a project file, choose the Hi-Tech Universal Toolsuite. In it you will find the C Compiler.

That’s about it when creating a project. I’ll attempt to re-write my assembly code for the ADC Demo I’ve done in a previous post.

I’m using a 10k potentiometer to vary the voltage going into Analog Channel 0. The ADC will convert that voltage input and store it in ADRESH. From there, the code will decide how many LEDs will turn on. The higher the input voltage, the more LEDs will turn on. Without further ado, let’s get to the code.

Here it is and it took me quite a while to write this simple code. Done some heavy googling to find equivalent functions for set bit and clear bit. I’ll try to explain the code line by line. Also, I have tested this code on the actual hardware and it works just the same like my old code written in assembly language.

First I got the set bit, clear bit, flip bit and test bit function code from an online forum. For the initialization, we need to include pic.h and htc.h. That’s where all the function is from. Now instead of calculating the delay manually, we can use the delay function. But of course the compiler needs to know what is your oscillator frequency. I’ve set it to 4MHz because that’s what I’m using. The delay function is given by _delay(in seconds), __delay_ms(in ms) and __delay_us(in us). That’s far more easier than using assembly code.

The configuration of the ADC is self-explanatory. The following infinite while loop is to test whether the ADC conversion is completed or not. If completed, the code will start testing the values of ADRESH to determine how large it is and correspondingly decide how many LEDs to turn on.

If the value of ADRESH is more than 40, the 1st LED will turn on. If the value of ADRESH is more than 80, the 2nd LED will turn on. That goes on in increments of 40 until it reaches 200. Yes I know 255 is the maximum but I don’t need accuracy in this code, this is just a demo to show the capabilities of the ADC.

I hope this will help some of my readers out there. If you have any questions, feel free to ask me. I’ll be glad to answer them (if I can ).

Have you ever gone to the Arduino.cc website and stumbled across graphical schematics like these :

And also the schematics I’ve drawn in a previous post? :

I will go as far as to say that it’s kinda cute lol. You can draw all the above using Fritzing. Not only that it can do graphical schematics, it can also do normal schematics and PCB design. The library is not huge but it’s sufficient for simple circuits.

When I’m presented with schematics that are made out of boxes and lines, I often get confused and it will take me some time to get the picture (I hope I’m not the only one lol). For example like this :

Most of the time these schematics are only available in one colour, black. For some that are used to looking at schematics (or have done so for the most part of your life) then it should be a piece of cake. But what if you could present it graphically? It will be easier for yourself and everyone too!

When you launch Fritzing, you will be presented with a breadboard. You can start designing your schematics by just transferring what you have on your breadboard, don’t need to figure out the connections again. Not using breadboards for your prototype? Don’t worry you can use perfboards too.

I’ll show you some of the interesting library files available in Fritzing.

Arduinos? No problem. Uno, Nano, Mega, Mini and even the Ethernet Shield are available.

These are common components such as RCL, inputs and outputs.

There are also a variety of ICs available.

Unfortunately, the library for PIC microcontrollers is still under development but I’m sure it will arrive soon.

And lastly, the best thing about Fritzing is it’s FREE! Go download it now at fritzing.org.

So I got my new Uno R3 and the first thing I did was trying to burn a bootloader onto the Nano.

“Hi, my name is Uno and I’m from Italy. Nice to meet you.” says the Uno. I like to think that electronic items have personalities. Lol.

Back to the burning the bootloader. I followed the schematics on the arduino.cc website and here is how to set it up.

So I fired up the Arduino IDE and it failed again. Done all sorts of tinkering and couldn’t get it to work. At this point, I assumed that the Nano is a goner. So, I played around with the Uno for some time and chucked the Nano back in its’ box.

Today I had some free time so I took it out again and decided to check every single connection on the Nano’s PCB by referring to the official schematics.

This was extremely tedious as all the components on the Nano are SMDs (Surface Mounted Device) and the pins are notoriously small. It made my multimeter’s fine tip probes looked like they’re giants.

I soldiered on and all was well until I reached pin 29 of the ATmega 328 (there are 32 pins in total!). That is the RESET pin and when I used the continuity test, it detected that the RESET pin is shorted to ground all the time. No, it shouldn’t do that, it should be pulled high. So I looked around to find any soldering faults that made the RESET pin shorted to ground (praying to God that it’s not a PCB design fault).

Lo and behold, I found this. On the left side of the Nano, there was a tiny solder joint between the GND and RESET pin. This was causing the chip to be on RESET all the time. The below picture is after I fixed the solder joint.

I removed it easily by using a pen knife and you can see the leftover in the picture above. That is some poor soldering by the folks in Hong Kong (I suspect China but Hong Kong is China, so yeah China lol). Testing the pins again and I no longer find that the RESET pin is shorted to ground. Hopefully this is it.

Connected it to USB and immediately the ‘L’ led lit up and blinked, that’s a good sign. So I uploaded the blink sketch and it was successful. Praise the Lord

This has been a frustrating journey in the world of Arduinos. I regretted buying it from Ebay just because it was cheap. I spent so much time tinkering with it and there was once I mistakenly shorted 5V with Ground and a diode blew. I had to remove it and solder a jumper wire between the two pads.

It’s not pretty but at least it works. Now I should be more careful not to do anything silly.

But in the end, it was a happy ending and the Nano came back to life. To commemorate the revival of the Nano, I’ve done this.

The moral of the story : Don’t get anything that’s ‘too good to be true’ on Ebay. It usually doesn’t end well.

Long live the Nano!

I ordered an Arduino Nano V3.0 on Ebay. The seller is from Hong Kong and it took around 2 weeks for it to arrive. It’s not a genuine Arduino though, at only USD 15 (RM45) it’s very cheap so I didn’t put much thought into it.

So came the day it arrived and I was very excited.

I knew the Nano was small but I didnt expect it to be this small. An old RM1 coin is bigger than it.

So I plugged it into my computer and it detected the FTDI chip (that’s a USB to serial converter chip built into older Arduinos).

The driver installed fine and I tried to upload a sketch through the Arduino IDE (the latest version 1.0 btw).

Immediately, an error code was shown and after a quick search, that is a common error code for device not found.

I looked on the Internet for hours, and then I stumbled upon this forum which says pre 2009 models did not properly ground the TEST pin (pin 26) of the FTDI chip.
And, true enough on the PCB it’s printed year 2009, and to double-check I used the continuity check on my multimeter and detected no connection at all to ground.

Feeling furious and was about to contact the seller, I continue to read the forum and some people managed to make it work by just jumping pins 26 and 25. Miraculously, pin 25 is ground and all I had to do was jump the two pins. Being an SMD, it was easier said than done. I took a good 15 minutes to form a tiny blob of solder between pins 26 and 25.  (I wish that I can show you a picture of it but my camera is absolutely useless in macro mode). So I fired up the Arduino IDE again, and it failed, still showing the same error message.

Feeling frustrated, I contacted the seller immediately and he insisted that he tested my unit before sending it out. I didn’t want to waste any money shipping back my unit to him, so I soldiered on and searched the Internet for more answers. Finally, I found the culprit, my unit did not have the bootloader installed.

In short, the Arduino is actually just a platform utilizing an already established Atmel 328 chip. To program the Atmel chip by itself, you don’t need a bootloader. But once the Atmel chip is plugged into the Arduino platform, it needs the bootloader so that the Arduino IDE can detect it and subsequently upload sketches into it. If the Atmel chip has the correct bootloader, upon powering up the Arduino, the built in LED (which is connected to Digital Pin 13) will blink as a sign to confirm that it has the bootloader. Mine doesn’t blink at all. The only LED that lights up is the Power LED. It had to be the missing bootloader.

In the official Arduino site, arduino.cc, there is a cheap, almost free way of burning a bootloader into the chip. It’s called Parallel Programmer. You can read more about it here. Basically, the user just need to connect some resistors from some of the pins on the Parallel port to the ICSP header on the Arduino. Below is the schematics taken from the website :

Looks simple. Since my new computer doesn’t have a Parallel port in the Rear IO, I had to dig out my old parallel port header bracket (Thank God that my motherboard still has a parallel port header) and I connected it to the Arduino with a few jumper wires. Tested the connections with my multimeter and it’s solid.

It’s a mess but I’ll do anything to revive my Arduino.

Fired up the IDE again and selected the burn bootloader mode. It failed again. Apparently, the Parallel programmer method is not always consistent and might work for some people only. I guess I’m the unlucky one. There are only two options left now, getting an Atmel chip programmer or getting another Arduino to flash the bootloader on this one. I chose the latter one for an obvious reason, at least I still have an Arduino if all else fails.

Feeling afraid and skeptical towards non-official Arduino boards, I opt for the official ones which are Made in Italy and comes with a nice box (and a few stickers, like you get from buying an Iphone). So I placed an order right away for the latest Arduino Uno R3 and it costed me RM 105 (painful I know). Well at least the Uno R3 doesn’t use the FTDI chip anymore.

I bought it from an official distributor listed on the Arduino.cc website. ( I have already received the Uno R3 but only able to write this post now).

The Arduino adventure continues… (Part 2 is up, you can read it here)

As parallel ports are getting more rare each day, computers start losing parallel ports and electronics will have to move on to a new interface. LCD Smartie is a relatively old project but because of its’ popularity among computer enthusiasts, it still lives till today. To give you an idea on how old it is, the latest stable release was on March 2007. That’s almost five years ago!

In the electronic prototyping world, Arduinos are very popular hence there are many people who tried to use it as a bridge between the computer and the LCD. Not only that, the older Arduinos had FTDI USB to Serial chips built-in and it allowed the Arduino to receive instructions from LCD Smartie. Though newer Arduinos like my Uno R3 doesn’t use FTDI chips anymore, the ATmega 16U2/8U2 still allowed seamless serial communication to and from the computer so LCD Smartie should work fine too, or at least in my mind. Well, doesn’t matter, I’m here to find out.

I’ve tried some LCD Smartie sketches available online and I found that this worked the best.

This is how I connected the LCD to the Arduino.

And finally, configure LCD Smartie to use the matrix.dll plugin and set it to the correct port.

That’s about it and the LCD on the Arduino should receive instructions from the LCD Smartie software.

This is a video to show that the LCD works flawlessly, just like when it was connected through the parallel port.

Thanks for reading

To program a MCU to interface with an LCD is relatively simple once you’ve read the datasheet. But unfortunately the LCD that I bought was from China and it uses a HD44780 compatible controller (aka HD44780 rip-off) and the timing’s a bit off. That’s why when I tried to use it with a PIC MCU I couldn’t get it to do what I wanted. Oh yeah did I mention that the datasheet is only available in Chinese? (Yes, I’m a banana and I can’t read chinese )

I tried to google translate it but the words just doesn’t sound right. So I thought why not try it on the Arduino and use the built-in LiquidCrystal library. Lo and behold it worked. I’ve done some googling and found out that the LiquidCrystal library has a very wide compatibility with numerous HD44780 compatible controllers.

I uploaded the SerialDisplay example so that the Arduino can read inputs from my keyboard and display it on the LCD.

Again like I’ve mentioned before, the capability of the Arduino to send and receive data from a computer is invaluable. Remember in the previous LCD Smartie post I mentioned that if you don’t have a parallel port on your computer (like a laptop) you can use USB but you need to go through a MCU? In the next post or so I’ll write about how to use LCD Smartie through Arduino. You can now check out the post here.

In the meantime, here’s a video showing the Arduino interfacing with the LCD.

This came all the way from…. Singapore. I bought some pre-made jumper cables on Ebay for only RM 7.50 after conversion.

In the pack there are 70 pieces of jumper cables as claimed by the seller, I have yet to count it myself but so far it looks pretty much like 70 cables.

Comes in a variety of colours.

The cables are quite consistent in length and quality.

Using my brand new jumper cables, I reconstructed my PIC16F877A ‘Development Board’ and it looks so much better.

I’ll go off now to count these cables

First and foremost, I should mention that I did not come up with the idea, nor the programming of this code. I’m using the program and code from an open source project called xoscillo. Please check out their website here.

With that in mind, there are only few things you need to get started. The most important is of course your Arduino. You also need an audio cable (3.5mm male to male), some jumper wires, crocodile clips, a 500 ohm resistor, a 10k potentiometer to vary the amplitude, a breadboard to build your circuit, and also a computer.

In the video, I connected my computer sound card to the Arduino because I don’t have a function generator. I’m using the sound card to produce different waveforms using a software. If you have your own function generator, it’s better to use that instead of a computer sound card. And if you want to use a software, simply google ‘software function generator’ and you will find a few there.

For those who are using a software and their computer sound card, make sure that you turn off all audio enhancement features. For my sound card, I need to turn off the X-Fi Crystalizer and also the EQ. This is to avoid any signal distortion.

Next, connect a 3.5mm male to male cable to the speaker output of the sound card, and on the other end, use two crocodile clips to connect the ground and left/right channel. You only need one of the channels (left or right) so it’s your choice. The pinout is as follows.

Then connect ground to the ground of the Arduino and left/right signal to either Analog Input 0, 1, 2 or 3. Make sure that the input goes through the resistor and the potentiometer first before going into the Arduino.

The hardware setup is done so let’s turn to the software. Go to the xoscillo website and download their lastest code and program (it will be in a zip file). In the zip file you will find two files, ArduinoOscillo.pde and XOscillo.exe. Extract both files to your desktop for convenience.

The .pde file actually contains the firmware to run your Arduino as an oscilloscope. To upload the firmware, simply open it with the Arduino IDE and click Upload. Note : This firmware does not work on Arduino 1.0, you need to open it with an older version, such as 0022 in my demo video. After uploading is done, simply run the included program called XOscillo.exe. Have fun

Here are some screenshots.

The sketches that were used in the video are as follows.

Thanks for reading

On the Arduino, not all the digital pins can do PWM. As you can see in the photo below, only pins 3, 5, 6, 9, 10 and 11 have PWM capabilities (at least on the Uno).

Duty cycle of a square wave is calculated by the percentage of the period of highs over the total period. This is a chart taken from the Arduino website.

In the Arduino IDE, the PWM function is given by analogWrite(). For example, analogWrite(9, 127) gives a 50% duty cycle wave output at Digital Pin 9.

To demonstrate the effects of PWM, I’m going to use an LED. For every push of a button, the duty cycle will increase, thus making the LED brighter. In the code, I’ve also implemented switch debouncing but it’s quite sketchy and I think it can be improved (I’m still new at this).

Yeah it’s expensive but it’s a genuine Arduino board and not 3rd party ones. Moreover, this is the latest revision of the Uno, the R3.

Here is the package.

Genuine Arduino Uno R3 made in Italy.

Some close-up shots using my HD-5000 webcam.

Connected the Arduino and installed the correct drivers. This is how it shows up in Device Manager.

Now, to test it by loading the blink sketch.

For those who knows C or C++, you will definitely feel at home when writing sketches on the Arduino IDE. If you noticed, the IDE does have a built-in delay function, just specify the time in ms in delay(). In this case I used delay(1000) which means 1 second of delay. Much easier than programming a PIC MCU.

This is the video of the Uno R3 in action.

More posts about the Arduino coming soon.

As you can see from the screenshot, LCD Smartie can handle almost anything on your computer. It can display CPU usage, RAM usage, check your e-mails, check RSS feeds, monitor Internet speed, view your songs and with extra plug-ins, it can do even more.

The first step is to connect the LCD to the computer. For simplicity, the computer must have a built-in parallel port (LCD Smartie doesn’t support USB to Parallel adapters). For non-geeks, here’s a background on parallel ports. Parallel ports are almost history now. It was on computers since the 70s and it is used to connect printers (mainly) to the computer (just think of it like USB). I was born in 1990 and I had the privilege of using parallel ports till I got a new printer in year 2003. Parallel ports suddenly went extinct and printers started using USB. This was understandable because USB is much faster and the port is much simpler (only has 4 pins compared to 25 pins and this increases reliability). I remembered my printer started printing garbled words and it turns out that the cable was wearing out. No such things happening now eh? Oh yeah, here’s how a parallel port looks like.

For unfortunate users that don’t have a parallel port on their computers, the LCD can be interfaced by a microcontroller and the microcontroller can be connected to the computer through USB. That’s another topic but for now let’s focus on parallel ports. I’ve wrote a new post about this, you can read it here.

For laptop users, most certainly your laptop does not have a parallel port (unless you have a laptop more than a decade old). For desktop users, if you don’t see a parallel port, don’t lose hope yet. This is the back of my desktop. No parallel port right?

If you have a modern desktop computer, most likely the back of it looks somewhat similar to mine. These days manufacturers pack all sorts of IO ports like HDMI, DVI, SPDIF, Firewire, E-Sata, etc and no wonder they do not have room for a parallel port. Now, the manufacturer can choose to just omit the port from the system or create a parallel port pin on the motherboard so you can add a PCI bracket. Luckily mine still has the pin on the motherboard and I can get a PCI bracket like this to add a parallel port to my computer.

To check if the pin is present, go look on the surface of your motherboard for this, it will be marked LPT :

If you still can’t find it, the last resort is to get a Parallel PCI card like this but it might not work due to different chipsets, etc.

Do take note that your computer must have a PCI slot for this to work (new motherboards do not have any PCI slots and PCI is NOT PCI-Express).

Ok, now to connect the LCD to the parallel port, refer to the schematics below :

If you’re a geek (or rather an old one like me), you will find a parallel cable lying around your house. I dug one out of my old printer box and it’s a DB25 to DB36 type. Initially I thought it was no good but the small pin holes on the DB36 is perfect for inserting a jumper wire in it, the hole size is just right. Here’s what a DB36 parallel port look like :

You can still buy parallel cables in Lowyat around RM10 to RM20 depending on the length. If you plan to use the LCD on a breadboard, buy the DB36 type so that you can insert jumper wires in it.

This is how I connected the LCD to the parallel cable.

It’s a mess but at least it works  Oh yeah, you need an external 5V power supply for the LCD. The parallel port doesn’t provide any power.

Here’s a video of LCD Smartie in action :

Try out LCD Smartie and have fun!

Apparently a paper box is too costly but thank God it arrived in one piece.

The connector shown does not come with the LCD, I bought it separately so that I can solder it and use the LCD on a breadboard.

Here is the back of the LCD.

Usually this LCD is used with a microcontroller but it can also be used on a computer. So, I tested the LCD by connecting it to the computer and it works perfectly.

I will cover on how to use this LCD on a computer in the next post.

This is how I connected the circuit on a breadboard :

What I had in mind to display the results of the ADC is to have 5 LEDs and the higher the input voltage, the more LEDs will light up. I have a 10k potentiometer to vary the input voltage going into PORTA,0 which is also Analogue Channel 0.

For eagled eyed viewers, you might notice that I have another resistor (550 ohms) before the 10k pot and I’ve done that to prevent excessive current from going into PORTA,0 when the pot has 0 resistance. This will indeed affect the max voltage going into PORTA,0 and it’s no longer 5V so I should set a different +Vref value. But I couldn’t be bothered because the voltage drop on the 550 ohms resistor is just 0.26V. I don’t need accuracy here anyway.

So let’s get to the initialization.

Bank 1

TRISA,0 is set to allow input for Analogue Channel 0
TRISD is cleared to allow output to LEDs

ADCON1 is cleared. Result is right justified because I’ll just take the higher 8 bits for simpler calculation. This will not affect the accuracy much. I wanted clock conversion to be Fosc/8 to get > 1.6us of minimum conversion time (I’m using a 4MHz crystal here). AN0 to AN7 is set to Analogue mode. +Vref is 5V and -Vref is 0V.

Bank 0

ADCON0 is set to ’0100 0000′ to select Fosc/8 and Analogue Channel 0.

That’s about it. And the rest of the code can be seen below.

The video below will show how the code works.

It’s popular among students, hobbyist and even engineers because it’s cheap. I got it for only RM23 and oddly enough that’s cheaper than its’ little brother I mentioned in a previous post, the PIC16F84A. Another reason is the sheer amount of input and output pins available on this MCU. Among other things, this MCU also has Analog to Digital conversion capability without the need of an external chip.

Together with this MCU, I also got myself two crystal oscillators, 4MHz and 20MHz. These frequencies are very common, or at least what I’ve seen so far.

As usual, I’m going to test the MCU by doing the blink test. For randomness, I’m going to use the 4MHz crystal to build my circuit. Accompanying the crystal are two 15pF capacitors.

Checking the datasheet, I should use XT for the Oscillator mode.

Here’s a video of the PIC16F877A in action.

Maybe I’ll test out the ADC and report back in the next post.

So, in my free time I went online to search for tutorials and tried to learn EAGLE myself. Initially the learning curve was very steep but after some time when I’m familiar with the software interface I felt comfortable. At times I really do feel that EAGLE is more user-friendly than Protel (maybe that’s because I was using a very old version of Protel in college). Soon I felt confident so I tried to design a PCB for my Electronic Dice project (you can read more about it here) but before I start, I want to explain why EAGLE is so popular among students and hobbyist.

The biggest difference between EAGLE and Protel/Altium is it’s FREE. They do offer the Light Edition as a freeware and of course it has some limitations but for personal or educational purposes, these limitations will not bother you at all. In their website, they listed the limitations and there are only THREE!

1. The maximum PCB area is only 10cm by 8cm.
2. The user is only limited to designing PCBs with top and bottom layer (most of us use bottom only anyway).
3. The schematic editor is only limited to one sheet.

To read more about it, go to their website. If you need to design PCBs that exceed these limitations, you can opt for the education version which is cheaper. For me, the Light Edition is more than enough so let’s get to it.

When you launch EAGLE, you are welcomed with the Control Panel where you can find your project files, view the library, edit the design rules, and etc.

To start, create a project and then a new schematic file. For any PCB software, you have to design the schematics first and then the program will generate a board file. Here is my completed schematics.

Then, just click on the Board button on the top toolbar and EAGLE will automatically generate a board file. The user still have to arrange the components on the board according to their liking. Then, the user have to route the connections either manually or by using the Auto Route feature. For small projects I recommend using manual routing for tidier results. Also, I added a ground plane to avoid wasting copper during the etching process (I personally think that ground planes make the PCB look very cool). Here is the finished product.

I wanted a silkscreen so I isolated the unwanted layers and here’s how it looks like.

Not forgetting the most important part, the bottom layer of the PCB.

Lastly, these are the final images to be printed out (I’m not planning to do a PCB based on this project, I did this just as a practise).
Note : The below images are enlarged to 150% for better viewing.

If you’re into electronics I highly recommend learning/using EAGLE to design your PCBs. It’s FREE :)

When turned on, all the LEDs will light up and the user have to press and hold on the button to roll the dice. Once the user lets go of the button, the rolling will stop and the dice pattern will be displayed. The LEDs will light up in the same pattern as a traditional dice for easy reading.

Here is how it’s connected :

And here’s the assembly code (for curious ones, I edited the asm file using Notepad++).

Before uploading it into the hardware, I was required to perform a software simulation first to show that the code is correct and functional.
Here is a video of the simulation :

And as expected, it works flawlessly, so here it is in the actual PIC16F84A :

Apparently rolling a dice is hard work, now we can just push a button

As shown above, there are two types of 7 segment displays, common cathode and common anode. Both of them produce the same results, it is just how you operate them.
Generally people do prefer the common cathode because sending a logic ’1′ will light the LED up while sending a logic ’0′ will turn the LED off. That is the standard convention. The common anode is the other way around.

So I thought I will get myself the common cathode version to make things simpler, so I went to the shop and bought it. When I came back, I tried to light it up but it just won’t light up, I thought maybe I got a defective unit. When I’m about the give up, I tried reversing the polarity and it lit up. The seller gave me the wrong type. If Jalan Pasar is near I won’t hesitate to go and exchange it for a correct version but it’s not. It’s not worth it to go all the way just for a RM1.50 part. Well, since I have not tried using current sinking on a MCU before, why not right. (A MCU output can either be current-sourcing or current-sinking, current-sourcing means that the pin will provide positive voltage while current-sinking means that the output pin can act as a ground, receiving current). This also means that now to turn on the LED I must program the MCU to send a logic ’0′.

I connect the 7 segment display to the PIC16F84A and wrote a corresponding look-up table.

The 7 segment display will display a different number every time the push button is pressed.

A 10ms debouncing is implemented to avoid any logic corruption. The 10ms delay is calculated using the program that I wrote. To find it, click here →.

Here is a video of the 7 segment display in action.

Sorry again for the poor video quality. The video looked fine before I uploaded it to vimeo. I shall try and see how I can improve the quality.

Just ordered an Arduino online and while waiting, I went to the Kinokuniya bookshop in KLCC to get this book :

It’s been a long time since I had a proper self-learning book. So far I’ve only bought 3 self-learning books excluding this one. My memory of those books are so fresh that I can even recall what, when, where and how much I bought them.

I bought my first self-learning book when I was 10. It was HTML for Dummies. It costs only RM10 because I got it at the MPH Clearance Sale. Finished the book in 2 months. Next, was a Macromedia Dreamweaver book (now Macromedia is called Adobe, oh im old) and I bought that when I was 11 after I mastered HTML. This was a little more expensive at RM 60 and I got it at Popular Petaling Street. Lastly, it was a Java Programming book and it was thicker than both of the previous books combined. I got it for RM15 at a flea market in Amcorp Mall when I was 12. Didn’t manage to finish the book till today because of UPSR and secondary school. I just realized how secondary school ate up all my time that I don’t even have my own free time to explore and discover.

It’s OK, my passion’s back and I shall conquer this book. Till then.

Let’s say the MCU is running at 4MHz. That’s a period of 250 nanoseconds. And every instruction cycle takes 4 periods. That’s 1 microsecond per instruction. If the programmer wants to make a delay of 5ns, that’s simple. Just execute the nop (no operation) instruction 5 times. But what if it’s 100ns or even 1 second? That’s where instructions like decfsz comes in. We can create longer delays by compounding a short section of delay. The idea is there but we need to manually calculate the number of times we should compound the short delay. That is why I wrote this program to simplify the calculation.

First and foremost, I should mention that I got the inspiration from a delay calculation program found on the Cytron website. The program was written by Kong Wai Weng in October 2004. I saw some improvements that have to be made so I wrote a new one myself.

The program is written in Visual Basic 2010 and should work fine on Windows 7, Vista or XP. For linux users, it will even run on Ubuntu or Debian with wine installed. The main highlight of my program is that the user can see the delay subroutine being generated and the program can copy the subroutine to the clipboard by just clicking a simple button. That way the programmer can paste it over at the MPLAB IDE without having to type the long subroutine code and substituting the values of d1, d2 and d3 manually.

For those wondering how the program works, basically the user have to use the trial and error approach. There are three values of d1, d2 and d3, so the user have to try and guess these numbers, and slowly adjusting them to match the delay duration they desire. I tried to write the program in a way that it can predict the values of d1, d2 and d3 but it will consume a lot of processing time as the computer have to try each possible combination of d1, d2 and d3. That’s 255 times 255 times 255 which is 16.6 million possibilities. And not to mention that it has to be run with a few decimal point so as to get a closer value (which will be rounded off in the end). I figured out the code but most of the time it just locks up the program because the process is just simply too long.

Finally, I hope the program is useful to you. To download it, click on the button below.
To show your support, ‘Like’ my website. If you’ve come across any bugs and errors while using the program, please inform me at waihung@waihung.net.

Thank you.

DOWNLOAD
.exe  110KB

I went to a shop in Pudu which was recommended by my lecturer and they did not carry the normal 4MHz variant. Instead they had only the 20MHz ones which were more expensive at RM30. That is alot for a small microcontroller. I bought it anyway because I can’t find it elsewhere.

This version I bought supports up to 20MHz, that doesn’t mean that it supports only 20MHz, it will work just fine with any frequency lower than that.
For the fun of it, I decided why not run it at its’ maximum frequency, so I bought a 20MHz crystal as well to see what this baby can do.

Connecting a crystal to a microcontroller is different compared to RC circuits. The crystal is connected to pin OSC1 and OSC2 and also requires two 15pF capacitors.
According to the datasheet, you can use any capacitors ranging from 15pF to 33pF in HS mode.

And, when writing the configuration code, the oscillator mode have to be set to HS (High Speed).

Let’s try this new microcontroller with the obligatory blink test.

The LED is connected to PORT B bit 0 and it turns ON and OFF in an interval of 1 second. In the next post, I will show how I calculate the delay subroutine.
In the meantime, here’s a video of the microcontroller in action.

Pardon me for the poor quality of this video. I’ll get a better camera soon.

More projects coming soon using the PIC16F84A.

This is essentially just an OEM version of the official Microchip Pickit 2 Programmer.
The original version could have easily cost more than RM100.

Together with this programmer I also bought a ICSP Universal Socket so I can directly plug it into the breadboard for easy debugging.

The connection schematics are as follows:

Do take note that the above connection is to operate the PIC Microcontroller at 800kHz.
I’m using the PIC16F84A for this test.

The software detected the PIC16F84A and all there’s left to do is to load a HEX file and click Write.

Besides programming the MCU, the programmer can also power up the circuit by just ticking the check box on the VDD section.
If desired, the VDD voltage can be varied from 2.5V to 5.0V.
It won’t go any higher than 5.0V because that is the maximum the USB port can provide.

At half price, the Pickit2 programmer is only RM 25 and the breaboard is only RM 7.50.
To share shipping costs, I ordered for my friends as well.

I had to have 2 breaboards because the price is just too hard to resist.
Having extra breadboards allows me to have extra workspace for my future projects.

The next time Cytron is having sales I’m gonna start ordering at 12am because these things do run out quickly.

Do visit http://www.cytron.com.my to see what they have to offer.

There are cheaper ones around RM20 but those looked like it’s gonna break after a few use.
I was told that these cheap multimeters are quite accurate when measuring low voltage or current.

Let’s put it to the test shall we.

This is the LM7805. It’s a 5V voltage regulator, its’ sole purpose is to downscale any high voltage (as high as 35V) down to just 5V while limiting current flow to 1A.

But if you plan to go any higher than 20V, a heatsink is highly recommended.

Let’s plug it into a breadboard and use a 9V battery as the input for this simple test.

As you can see, the reading is exactly 5.00V. I’ve put it to other tests as well and this multimeter is quite accurate for my needs.

If you are eagle-eyed, you may notice that I’ve put the reading on hold. That’s because it fluctuates between 5.00V and 5.01V.
This is not the multimeter’s fault, I did not put any capacitors to stabilize the voltage.

I’ve been using it for over two months now and it’s holding up well.