Many members of Microchip’s families of 16-bit microcontrollers provide native IrDA standard support via their UART modules. This greatly simplifies the hardware design, which basically means that the microcontroller requires only Infrared Transmitter/Receiver.

The app note gives an overview of three IrDA protocols:

• IrCOMM 9-Wire Cooked
• OBEX
• IrCOMM 3-Wire Raw

MICROCHIP’S IrDA® STACK TOOL is the tool which will create project files required to use the Microchip IrDA Standard Stack. It will also indicate which library file to include in the project, based on the selected protocol and device type.

Drawing 1. (large view)

The AN1071 app note, source code and Microchip IrDA Standard Stack libraries are available for download from the Microchip website.

The bootloader for dsPIC30F/33F and PIC24H/24F devices is used to load and run an application on the target device. The bootloader consists of two applications:

• Target side bootloader application which must be programmed into dsPIC30F/33F or PIC24F/24H program memory prior to bootloader operation.

• Host PC bootloader application which communicates with the target side bootloader.

The bootloader parses the program HEX file and then copies it into the appropriate program and EEPROM memory (if present) on the target device via the communication channel (UART, CAN, etc.). The bootloader target application is located in the dedicated program memory region, starting at address 0×100 (for dsPIC30F devices) or 0×400 (for all other device families). On start-up, the bootloader reads program memory address 0×600 (for dsPIC30F family) or address 0xC00 (for all other device families), which contains a bootloader delay value. If the bootloader fails to detect UART activity within the time period specified by the delay value, it suspends itself and transfers execution to the user application located at program memory address 0×602 (for dsPIC30F family) or address 0xC02 (for all other families). On the other hand, if the bootloader detects UART activity before it suspends itself, it programs both EEPROM (if present) and program memories with the data it receives from the bootloader host application via UART interface. The bootloader host application parses the HEX file containing the user application (generated by MPLAB® IDE and sends this data to the bootloader target application via UART. The bootloader host application also supports additional features, such as read of program and EEPROM memories.

More datails at AN1094 Application Note.

Because buzzers have a narrow bandwidth, the quality of sound is rather poor, and some frequencies sounds louder whereas other are attenuated.  But, some quite simple melodies can be played, like this first notes of Beethoven’s “For Elise”..    

Drawing 2. (large view)

 /*************************************************

buzzer.c

*************************************************/
#include <16f877a.h>
#fuses xt, nowdt, noprotect, nolvp, noput
#use delay (clock=4000000)

int i,j;

play(pitch, note){
 for(j=0;j<note;j++){
   for(i=0;i<15;i++){
    delay_us(pitch);
    output_high(pin_d0);
    delay_us(pitch);
    output_low(pin_d0);
   }
 }

}
main()             
{
const int pitch_C6=478;
const int pitch_Db6=451;
const int pitch_D6=426;
const int pitch_Eb6=402;
const int pitch_E6=379;
const int pitch_F6=358;
const int pitch_Gb6=338;
const int pitch_G6=319;
const int pitch_Ab6=301;
const int pitch_A6=284;
const int pitch_Bb6=268;
const int pitch_B6=253;
const int pitch_C7=238;
const int pitch_Db7=226;
const int pitch_D7=212;
const int pitch_Eb7=200;
const int pitch_E7=189;
const int pitch_F7=179;
const int pitch_Gb7=169;
const int pitch_G7=159;
const int pitch_Ab7=150;
const int pitch_A7=142;
const int pitch_Bb7=134;
const int pitch_B7=126;
const int pitch_C8=119;
const int pitch_Db8=113;
const int pitch_D8=106;
const int pitch_Eb8=100;
const int pitch_E8=95;

const int quarter_note=50;
const int half_note=100;

play(pitch_E8, quarter_note);
play(pitch_Eb8, quarter_note);
play(pitch_E8, quarter_note);
play(pitch_Eb8, quarter_note);
play(pitch_E8, quarter_note);
play(pitch_B7, quarter_note);
play(pitch_D8, quarter_note);
play(pitch_C8, quarter_note);
play(pitch_A7, half_note);
play(pitch_C7, quarter_note);
play(pitch_E7, quarter_note);
play(pitch_A7, quarter_note);
play(pitch_B7, half_note);

play(pitch_E7, quarter_note);
play(pitch_A7, quarter_note);
play(pitch_Bb7, quarter_note);
play(pitch_C8, half_note);

}

play(pitch, note) functions pulses the microcontroller’s output D0 in certain frequency for some certain time. Frequencies of piano scale can be found on the Internet.

Statement  const int pitch_C6=478;  is basicly the half of the period (1/f)/2 which corresponds to the frequency of sound (C6 here). It is not very accurate, because some time microcontroller uses for execution, but more imortant are intervals – the diffrences in pitch between notes.

Source code for PIC-01 Development Board and hex files:
buzzer.c (.zip)
buzzer.hex (.zip)

The project uses typical PCF8583 application. Because on the PIC-01 Development Board there is already an I2C device (an I2C EEPROM memory with the address set to A0A1A2=000), the A0 pin has been set high.

The PCF8583.h library contains three functions:

• init_PCF8583();
• write_PCF8583(BYTE address, BYTE data);
• read_PCF8583(BYTE address);


//--------------------------------------------------------
// Library for a pcf8583p - RTC/Calendar with 240x8bit RAM
// and I2C interface
// Pin Layout:
// |
// | 1: OSCI Oscillator input | 8: VCC +5V |
// |
// | 2: OSCO OScillator output| 7: !INT Interruption output |
// |
// | 3: A0 I2C Address | 6: SCL EEPROM_SCL and Pull-Up |
// |
// | 4: VSS GND | 5: SDA EEPROM_SDA and Pull-Up |
// ------------------------------------------------
//
// PCF8583p Slave I2C Address
//
// 1 0 1 0 0 0 A0 R/!W
//
//--------Pin definition--------//
#define PCF8583_SDA PIN_C4
#define PCF8583_SCL PIN_C3 #define PCF8583_WRITE_ADDRESS 0xA2 //Pin A0 High
#define PCF8583_READ_ADDRESS 0xA3 #ifndef PCF8583_WRITE_ADDRESS
#define PCF8583_WRITE_ADDRESS 0xA0 //Pin A0 Low
#define PCF8583_READ_ADDRESS 0xA1
#endif #use i2c(master, sda=PCF8583_SDA, scl=PCF8583_SCL)void init_PCF8583() {
  output_float(PCF8583_SCL);
  output_float(PCF8583_SDA);
}BOOLEAN PCF8583_ready() {
  int1 ack;
  i2c_start();
  ack = i2c_write(PCF8583_WRITE_ADDRESS);
  i2c_stop();
  return !ack;
}void write_PCF8583(BYTE address, BYTE data) {
  while(!PCF8583_ready());
  i2c_start();
  i2c_write(PCF8583_WRITE_ADDRESS);
  i2c_write(address);
  i2c_write(data);
  i2c_stop();
}BYTE read_PCF8583(BYTE address) {
  BYTE data;while(!PCF8583_ready());
  i2c_start();
  i2c_write(PCF8583_WRITE_ADDRESS);
  i2c_write(address);
  i2c_start();
  i2c_write(PCF8583_READ_ADDRESS);
  data=i2c_read(0);
  i2c_stop();
  return(data);
}

byte sec,min,hour,year,month,day,weekday;char const weekday_names[7][4] =
{
{"Sun"},
{"Mon"},
{"Tue"},
{"Wed"},
{"Thu"},
{"Fri"},
{"Sat"}
};void main(void)
{
lcd_init(); //lcd start
lcd_init_custom_chars();init_PCF8583();while(TRUE)
{
delay_ms(100);
lcd_gotoxy(1,1);

}

For further development, it would be sensible to include set_time() and set_date() functions and using interrupts.

All files available here:
rtc.c (.zip)
rtc.hex (.zip)
PCF8583.h (.zip)

2. A little bit of theory.

The RC5 is Philips’ standard for infra red communication. It is widely used for remote controls in consumer electronics.

The RC5 uses Manchester coding. It is a form of data communications line code in which each bit of data is signified by at least one transition. Manchester coding is considered to be self-clocking, which means that accurate synchronization of data stream is possible. Each bit is transmitted over a predefined time period. Manchester codes have a transition at the middle of each period.

The RC5 code uses a modulation of a 36kHz IR carrier frequency. The code is 14-bit long. A 5-bit address and a 6-bit command are preceded by 3 control bits.

Drawing 1. (large view)

The first two start bits are both logical ’1′. The third bit is a toggle bit. This bit is inverted every time a key is released and pressed again. The next 5 bits represent the IR device address, and the following 6 bits represent the command. Addresses and commands are sent in the MSB first order.

3. Hardware.

The TSOP1736 is a miniature receiver for infra red control systems. It works in its typical application circuit. The U1 output pin is connected to the RB0 pin of the PIC microcontroller. The output pin of the U1 is normally high. Receiving an infra red signal pulls the output low and the microcontroller can decode the information in an interrupt call.

Because the PIC uses an interruption on RB0 input, the LED jumper on the PIC-01 Development Board should be removed.

Drawing 2. (large view)

4. Listing.

The output of the TSOP1736 is normally high and the RC5 code on its output is inverted. A low signal on the PIC input calls an interrupt routine. The microcontroller waits for a high level and times how long the low state has remained. If the time has been 800-1000us, the PIC starts decoding. It reads the input approximately every 1.78ms and writes data into a buffer. After that the address and command are displayed on an LCD and sent through the RS232.

The code was written in C and tested on the PIC development board by LoginWay.

//—————————————————–
//rc5.c
//—————————————————–

#include<16f877a.h>
#use delay (clock=4000000)
#fuses xt,nowdt,noprotect,noput,nolvp
#use rs232 (Baud=9600,xmit=pin_c6,rcv=pin_c7) //RS232 transmission setup
#include”lcd_new.h”

int counter,i,com,adr;
int16 buffer;

#int_ext //interrupt
int_IR()
{
counter=0; //reset counter and buffer
buffer=0;
disable_interrupts(int_ext); //disable interrupts

while(!input(pin_b0)) //wait for high level
{ delay_us(15);
++counter; } //time how long has been low
if(counter>=38&&counter<=45) //if from about 800 to 1000 us
{ //do routines
delay_us(200);
for(i=0;i<13;i++) //13 following bits
{
if(input(pin_b0)) //if the input high
{bit_set(buffer,0); //set the LSB and shift left
buffer<<=1;}
else //otherwise just shift
buffer<<=1;
delay_us(1740); //wait for naxt bit
}
buffer>>=1; //shift 1 right because of last reading
com=buffer&0b00111111; //command is 6-bit long; ignore the rest
buffer>>=6; //shift 6 right
adr=buffer&0b00011111; //address is 5-bit long; ignore the rest

//display on an LCD
printf(lcd_putc,”\fAddress:%u\nCommand:%u”,adr,com);
printf(“A%uC%u”,adr,com); //send bytes to the rs232
delay_ms(150);} //wait
return(0); //return to main
}

main()
{

lcd_init();
while(1)
{
enable_interrupts(int_ext); //enable external interrupt
ext_int_edge(H_to_L); //falling edge
enable_interrupts(global); //enable interrupts
}
}

5. Usage.

You can connect your PIC-01 Development Board to the PC through an RS232 serial straight-through cable. To check your program use the Hyper Terminal. Set the appropriate COM port and set the transmission on 9600bd, no parity, 1-bit stop, no flow control.

You can use your RC5 remote controller to control some of your computer applications like WinAmp and Windows Media Player.

To find out more follow the links below.

The TSOP1736 data sheet.
RC5.hex (.rar) file is available here.
Here you can find WinAmp plug-in and some instructions how to install it.
Some useful information about the IR remote control.

This is an example how to use integrated Analog to Digital Converter (ADC) of the PIC16F877A. The code was written in the CCS C and tested on the PIC-01 Development Board.

2. The ADC.

The PIC16F877A microcontroller has a 10-bit 8-channel integrated Analog to Digital Converter. In the analog to digital conversion the ADC can use either on-board RC oscillator or divided clock signal (Fosc). The freqency can be chosen in programming from Fosc/2, Fosc/4, Fosc/8, Fosc/16, Fosc/32, Fosc/64. The voltage input range depends on the reference voltege on inputs Vref+ (RA3) and Vref- (RA2). If the inputs are not connected the reference volage ranges from Vss to Vcc.

3. Circuit.

There is a 4.7k pot installed on the PIC-01 Development Board for the purpose of the ADC. The pot is connected to the RA0 input and between the GND and Vcc of the power supply.

4. Listing.

The program was written in the CCS C and uses the PIC16F877A standard library. The RA0 pin has to be set as the analog input. The ADC uses the internal RC oscillator.

The ADC has the 10-bit resolution, which means that the 0-5V range is divided between 210 = 1024 levels. It means that 1-bit represents 5V / 1024 = 0.0048V = 4.8mV voltage.

The voltage read from the RA0 input is displayed on the PIC-01 Development Board’s LCD in the format “Voltage = X.XX V”.

//————————————————————
//
// acd.c
//
//————————————————————-

#include<16f877a.h> //Device
#fuses xt,nowdt,protect,noput,nolvp //Fuses
#device adc=10 //10-bit ADC
#use delay (clock=4000000) //4.00 MHz
#use rs232 (Baud=9600) //RS-232 parametres
//(only for printf function)
#include”llcd_new.h” //LCD driver

main()
{

float c;
lcd_init();
set_tris_a(0b000001); //RA0 anlog
setup_adc(adc_clock_internal); //internal clock
setup_adc_ports(ra0_analog); //RA0 analog input
set_adc_channel(0); //set channel

while(1)
{
c=read_adc(); //voltage conversion
delay_ms(150); //10-bit = 1024
lcd_gotoxy(1,1); //0-5 V and 1024 levels
printf(lcd_putc,”Voltage = %1.2f V “,(c*5)/1024); //calculate voltage
delay_ms(150);
}
}

Files are available here:
adc.c (.zip)
adc.hex (.zip)