For those folks looking for a place to get started with developing electronic products, check out our starter kits that have everything you need. started.

#include <pic.h>
 __CONFIG(FCMDIS & IESODIS & BORDIS & UNPROTECT & MCLRDIS & PWRTEN & WDTDIS & INTIO);
int i;
int j;
main()
{
PORTC = 0;
TRISC0 = 0;
TRISC1 = 0;
TRISC2 = 0;
TRISC3 = 0;
 j=0;
 while (j<3)
 {
     for (i = 0; i < 5500; i++);
          RC0 = 0;
     for (i = 0; i < 5500; i++);
          RC0 = 1;
     for (i = 0; i < 5500; i++);
          RC1 = 0;
     for (i = 0; i < 5500; i++);
          RC1 = 1;
      for (i = 0; i < 5500; i++);
          RC2 = 0;
     for (i = 0; i < 5500; i++);
          RC2 = 1;
     for (i = 0; i < 5500; i++);
          RC3 = 0;
     for (i = 0; i < 5500; i++);
          RC3 = 1;
     for (i = 0; i < 5500; i++);
          RC2 = 0;
     for (i = 0; i < 5500; i++);
          RC2 = 1;
     for (i = 0; i < 5500; i++);
          RC1 = 0;
     for (i = 0; i < 5500; i++);
          RC1 = 1;
     j=j+1;
 }

j=0;
while (j<5)
{
     for (i = 0; i < 8500; i++);
          PORTC=0b001001;
     for (i = 0; i < 8500; i++);
          PORTC=0b000110;
     for (i = 0; i < 8500; i++);
          PORTC=0b001001;
     for (i = 0; i < 8500; i++);
          PORTC=0b000110;
j=j+1;
}

}

The three timers are similar to each other in many ways but are different in some respects.  Below is a list of each of the timer features from the datasheet.

TRM0

• 8-bit timer/counter
• Readable and writable
• 8-bit software programmable prescaler
• Internal or external clock select
• Interrupt on overflow from FFh to 00h
• Edge select for external clock

TMR1

• 16-bit timer/counter which consists of two 8-bit registers
• Readable and writable (TMR1H:TMR1L)
• 4-bit software programmable prescaler
• Internal or external clock select

TMR2

• 8-bit timer/counter
• Readable and writable
• 4-bit software programmable prescalerInternal or external clock select
• Prescale options include 1:1, 1:4, 1:16
• Postcale options include 1:1, 1:2, 1:3, 1:16
• Internal clock only
• Output (before prescaler) is fed to the SSP module for an optional shift clock.
• Can be set to automatically compare it to a value you determine.

Each of the timers can be configured separately and can be used for different purposes within your application.  One of the nice things about these is that they run on their own in the background while your code is off doing something else.  They “tap you on the shoulder” in the form of an interrupt to remind you to go and do something.  You can also read them or reset them at any time.  These timers are essentially binary counters that start at a value you determine and keep running until you shut them off.  If you’re not familiar with a binary counter it looks much like this…

clock pulse 1  00000000
clock pulse 2  00000001
clock pulse 3  00000010
clock pulse 4  00000011
clock pulse 5  00000100
clock pulse 6  00000101

and so on

The counter keeps increasing after every clock pulse until it “overflows”.  Overflows means that when the counter is all 1′s and another 1 is added, there is no place for the carry bit to go.  This generates and interrupt and the timer is reset to all 0′s again.

Now lets write a little routine that uses one of our timers to blink an LED at 1 second intervals.  We’re going to use the CCS compiler for this example and once again use the PIC16F777.  We’ll use TMR1 for this task and take I’ll take a moment to point out a couple of things before we get to coding.

- TMR1 counts from 0 to 65535

- On the next count it resets back to zero and sets a bit in the TMR1IF (Timer 1 Interupt Flag) on the PIR1 register.

- If we run the internal clock at 20Mhz we know that the program counter and the pulses that drive the clock are equal to 1/4 of the internal clock speed of each clock count.  That means that the TMR1 clock runs a 20Mhz/4=5Mhz.

- A little more math and we find that each clock pulse take 1/5Mhz seconds to comple.  That’s .2us for each count of TMR1

- Another piece we need is how long until the timer overflows.  From what we know so far it’s .2us x 65536 = 0.0131

- Since the last piece resulted in such a short time until overflow, we could probably use a prescaler to slow it down a bit. Using the 1:8 prescale which divides our clock we get 5Mz/8 = 625KMz which is 1.6us per count of TMR1.  With that we have 1.6us x 65536 = 0.104856s wich is how long it takes to overflow the clock.

Now, with that information we know that if it takes 0.104856s to overflow the clock.  If we let the clock overflow 10 times we will have taken up 1.04856s.  Well that’s pretty close to what we wanted but lets say we had to get that close to 1s.  What could we do?  Well, remember that TMR one is writable.  That means we can preload a value into TMR to get us a little close.  I’m not going to show all the math on this part but if you solve this equation …

clock cycles = (0.1s)/((20Mhz)(1/4)(1/8)) = 62500

You’ll see that if we could overflow the clock after 62500 cycles rather than 65536 we would have consumed exactly .10 seconds.  So the value we need to preload in is (65335-62500) = 3035.

The code that puts it all together… 

#include <16F777.h>
#fuses INTRC,NOWDT,NOPROTECT
#use delay(clock=2000000)
unsigned int counter = 0;
setup_port_b (ALL_DIGITAL);
#int_timer1

void timer1_isr() {
disable_interrupts(INT_TIMER1); //Turn off interrupts
set_timer1(3035);                                 //Load preset
counter = counter +1;                           //Increment Counter
clear_interrupt(INT_TIMER1);
enable_interrupts(INT_TIMER1);  //Enable the TMR1 Interrupt
}

void main(void){
 SET_TRIS_B( 0×00 );                       //Set Port B to all Outputs
 setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);  //Timer with internal clock and 1:8 prescaler
 enable_interrupts(GLOBAL);
 enable_interrupts(INT_TIMER1);

test: 
if (counter == 10){
 counter = 0;                                              //Reset the counter
 OUTPUT_TOGGLE(PIN_B1);
}

goto test; 

} 

We start out telling the CCS compiler which device we’re using and set some of the config bits.  We also set port B to all outputs, initalize the variable COUNTER, and declare out timer1 interrupt.  The main part of the program sets up the timer with the internal clock and the prescaler we talked about.  The interrupt is enabled and then we begin the testing of the variable COUNTER.  Remember that the TMR1 clock is running all the time now that we’ve set it up.  The test loop checks to see if we’ve overflowed it 10 times.  We know how many times it overflowed because we’ve set up an interrupt routine which increments COUNTER each time if overflows.  When COUNTER reaches ten, we toggle B1.  So with an LED and appropriately sized resister on B1 we would see the LED light up for 1s and then turn off for 1s.

In CCS there are simpler ways of accomplishing this task of lighting the LED for 1s on and 1s off.  We could use the delay function build into CCS to simplify our code.  We only did it this way to demonstrate how the TMR1 operates. Hopefully I’ve shed a little light into the world of PIC timers using CCS and you can feel comfortable using them in your designs.

Non-Polarized Capacitors

Polarized Capacitors

1.0uF	10uF	100uF	1000uF
1.5uF	15uF	150uF	1500uF
2.2uF	22uF	220uF
3.3uF	33uF	330uF
4.7uF	47uF	470uF
6.8uF	68uF	680uF

]]> http://beginnermicro.com/blog/common-capacitor-values/feed/ 0 http://beginnermicro.com/blog/14-bit-pic-instruction-set/ http://beginnermicro.com/blog/14-bit-pic-instruction-set/#comments Thu, 21 May 2009 16:52:37 +0000 admin http://beginnermicro.com/?p=334 The majority of devices in the PIC12 and PIC16 Midrange devices use this instruction set. It’s very similar to the 12 Bit PIC Instruction Set but the increased opcode width allows 128 registers and 2048 words of code to be directly addressed.

resistorcolorcode24

Create a folder, and extract the contents of the zip file into it.  Double click the setup.exe file and you’re all set.

Circuit Board
The circuit board can be made with any of the freeware PCB software programs such as expresspcb.com. Just copy the layout below. The traces can all fit on the bottom side of the board.

  The parts list is short and most of these parts are available from various
sources such as jameco.com or digikey.com.

Parts List
U3 – MAX232N Serial Chip
C1, C2, C3, C4 – 1uf 100v Electrolytic Capacitor
J1 – DB9 9-pin D-Sub connector
5 pin, SIP header
2 pin, SIP header
RS232 Circuit Board

Assembly Instructions
1. Insert C1, C2 C3 and C4 into the board as shown below and solder in place.

2. Insert J1 9 pin DB9 connector and solder leads in place.

3. Insert the 16 pin socket. Make sure the “U” shape in the top of the socket lines up with the tiny “u” in the circuit board outline. Per the drawing below. Solder the leads in place. Insert the 16 pin MAX232 chip in place
making sure the “u” lines up per the picture below.

4. Insert the 5 pin SIP header at the end of the board and solder
5. Insert the 2 pin header at the side of the board and solder.

Now you are ready to connect your PIC to your PC.

As with most things that we set out to do, we need to understand the components that we’re working with.  We don’t need to become an expert on LED’s to use one but some basic understanding is helpful.  A good place to start with understanding an electrical component is the datasheet.  A popular LED is the red 4mm leaded package so we’ll work with that one.

Before we get started, it’s important to point out that an LED is a Light Emitting Diode.  This means that it is essentially a diode that lights up.  And with diodes we know that current can only flow in one direction, that is, the direction the diode is pointing.  If you turn it around, no current will flow, and it will not light up.  When it’s used in its proper orientation, it will pass current, have a voltage drop, and give off light.

The first thing you’ll see in the datasheet is the package drawing.  This is, of course, helpful in giving you a feel for the size of the key features of the component but I’d also like you to notice the leads.  LED’s have two leads called the Anode and the Cathode.  The Anode is the positive terminal and the Cathode is the negative terminal.  The longer lead is the Anode.  This will help you to properly insert your LED into your breadboard or PCB with the correct polarity.

Another feature of the package is that when you look at the LED from the top, you’ll notice there’s a flat side which corresponds with the shorter lead or Cathode.  The schematic for an LED is shown below.  Sometimes an LED schematic symbol will be circled but I’m showing the default symbol used in PCB Express Schematic.

I’m not going to go into such topics as Luminous Intensity and Wavelengths in this tutorial but may discuss it in a future article.   It’s not that these topics aren’t important, it’s just that my goal here is to get you up and running.  With that said, lets move on to sizing your current limiting resistor.

What’s a current limiting resistor?  Well, it’s the resistor in the small circuit shown below.

Its purpose is to “limit” the current in the circuit so that the LED is fed the proper level for operation.  So how does it do that?  Let’s take a look at this equation referred to as Ohm’s Law.

V = IxR

V = Voltage expressed in Volts
I = Current expressed in Amps
R = Resistance expressed in  Ohms

A slight modification to this equation results in the expression …

R = V / I

So if you know the voltage and the desired current, you can calculate the resistance needed to make that happen.

So how do I know what V and I are?  Well, let’s go back to the datasheet.  You should see a chart similar to the one below.

This chart shows the LED’s characteristic relationship between Forward Voltage and Forward Current.  These two values are exactly what we’re looking for.  This not only shows the operating range of current and voltage but shows how one affects the other.

One good practice when picking values is to pick values near the middle of the range.  This will give you a nice safety margin on both sides.   Let’s go back to our LED circuit for a moment.  This time, I’ve declared what my battery voltage is.  You need to know what this is going to be to select an appropriate resistor.  For our circuit, we have selected 5 Volts for the battery.

Now keep in mind that your circuit may not look exactly like this one.  Yours may look like the one below.

If your output pins on your PIC are running at 5 volts then your circuit is essentially the same as the one with the battery.  If we’re talking about a PIC though, I know one more piece of information which is important.  I know that the max current we should have is 20mA.  This is the datasheet max for PIC devices.  If we go beyond this value for too long, our PIC can get a little toasty.

So after we know our voltage we know all the following…

-    Our source voltage is 5 Volts
-    Our max current is 20 mA
-    The resistor will have a current drop
-    Our LED will have a voltage drop
-    I know that the sum of the drop of the Voltage across the Resistor and the LED will equal 5 Volts.

Let’s go back to our LED Datasheet chart above.  If I pick a value in the middle of the range, say 2 Volts, what is our current (I)?  I’m seeing about 8mA which is well within our max of 20mA.

So, with a voltage drop across the LED of 2 volts that gives us a voltage drop across the resistor of 3V (5 V – 2 V = 3V).  Now we can use our equation for Ohms Law to calculate the value of the resistor that will give is a 3 V drop.

R = V /  I
R = 3 V/  8 mA
R =  375 Ohms

So what we’re looking for is a 375 Ohm resistor, which I can tell you without even looking that it doesn’t exist.  What we need to do is find the closest value that does exist and recalculate our values to make sure we don’t exceed our requirements.

The closest standard resistor value to 375 Ohms is 360 Ohms for a ¼ Watt 5% tolerance resistor.  Let’s recalculate using that value and make sure our current is within our operating range.

I = V / R
I = 3 / 360
I  = 8.33ma (Good)

Even though I’m pretty sure we’re OK, let’s go ahead and calculate the power that will be consumed by the Resistor in the circuit.  The equation for that is…

P = VxI
P = 3V x 8.33mA
P = 0.025 W (Good since limit is 0.25)

Now keep in mind that that if you consistently use the same power source and similar PIC’s, you don’t need to recalculate this every time.  Just use the same type of LED for most of your projects and buy a bag of resistors of the appropriate value.

I tried to explain all this stuff to my son after he systematically worked through a chunk of my red LED’s.  He nodded and smiled as I worked through the math but clearly he just wanted me to tell him what resistor to use.  I handed him a bag of 360 Ohm resistors and went on my way.