CCS compiler PIC microcontroller variable baud rate.

[irfan ahmad]

hi every one.
i want to use rs232 communication in ccs compiler
and want to set baud rate value from adc input.
can anybody help me

 

[betwixt]

That's a strange thing to do but if it's what you want:

1. read the ADC
2. put the ADC value into the baud rate generator.

For example if you are using PIC16/18 series devices, read the ADC and load the result into SPBRG.

Brian.

 

[irfan ahmad]

well i want to read data from a device which have not normal baud rate like 1200 , 2400, 4800 , or 9600 etc.
i want to use 16f877a .
in data sheet SPBRG 99H this register is used for baud rate generation generator.
i want to know
what are maximum and minimum values for SPBRG REGISTER.
is this register completely used for baud rate not for further use.
suppose i am using 20mhz crystal

 

[jayanth.devarayanadurga]

The USART section of datasheet shows a table containing SPBRG values for different Fosc. If you use Fosc 20 MHz then in the table you can see SPBRG values for 20 MHz when BRGH = 0 and also BRGH = 1. You should consider the percentage of error in baudrate for different baudrate for a particular Fosc. You cannot have any desired values.

 

[irfan ahmad]

i want variable baud rate like adc value

 

[betwixt]

SPBRG is an 8-bit register so it can hold any value from 0 to 0xFF (255 decimal). Each value will produce a different baud rate according to the formula in the data sheet. SPBRG sets a division ratio from the master clock so values that require fractional division are not possible. The BRGH bit also controls whether the clock is divided by 4 or 16 to help you set the speed you want.

If you need ANY baud rate to be selectable, within the limits of the electronics, you have to select synchronous mode and provide an external clock on RC6. How you generate that clock is up to you.

Brian.

 

[jayanth.devarayanadurga]

With which device your variable baudrate system interfaces? The other system should also be able to communicate with the baudrate you use in your system. If the other system is PC then how will you set its baudrate?

 

[irfan ahmad]

thanks every one.
this is my code prototype code without variable resistor.
//

//spbrg=207 at 300 baud rate
//spbrg=103 at 600 baud rate
//spbrg=51 at 1200 baud rate
//spbrg=25 at 2400 baud rate
//spbrg=12 at 4800 baud rate
//spbrg=25 at 9600 baud rate

//#include <18F4620.h>
#include    "16f877a.h"
#device adc=10
#use delay(clock=4000000) 
#FUSES NOWDT                    //No Watch Dog Timer 
#FUSES NOPROTECT                //Code not protected from reading 
#FUSES BROWNOUT                 //Reset when brownout detected 
#FUSES PUT                      //No Power Up Timer

#locate  rcsta=0x18
#locate  txsta=0x98
#locate  spbrg=0x99

#USE RS232(baud=4800,xmit=pin_c6,rcv=pin_c7)//timeout=100,errors)
//#USE RS232(baud=300,xmit=pin_c6,rcv=pin_c7,timeout=100,errors)
/////////////////////////////////////////////////
void  main()
{
while(true)
{
char count,C,temp1=0,temp2,temp3;

temp1=txsta;
temp2=rcsta;
temp3=spbrg;
setup_uart(9600);
printf("working");
printf("spbrg value= %u  %u  %u "temp1,temp2,temp3);
putc(13);
delay_ms(1000);
}
}

 

[betwixt]

I'm not sure what #locate does in your compiler but that code uses a fixed baud rate and doesn't use the ADC at all. Perhaps we are misunderstanding what you are asking for.

Brian.

 

[irfan ahmad]

#LOCATE is used to access in ram memory registers .
using #LOCATE i am able to access baud rate control registers .
now just adc reading and limits are required .
i will post code after accessing complete task.

 

[betwixt]

I don't use CCS but it seems strange that you have to tell it where some of the registers are. Isn't that information in the '16f877a.h' file ?

Brian.

 

[irfan ahmad]

this is device.h

//////// Standard Header file for the PIC16F877A device ////////////////
#device PIC16F877A
#nolist
//////// Program memory: 8192x14  Data RAM: 367  Stack: 8
//////// I/O: 33   Analog Pins: 8
//////// Data EEPROM: 256
//////// C Scratch area: 77   ID Location: 2000
//////// Fuses: LP,XT,HS,RC,NOWDT,WDT,PUT,NOPUT,NOBROWNOUT,BROWNOUT,NOLVP
//////// Fuses: LVP,CPD,NOCPD,WRT_1000,WRT_800,WRT_100,NOWRT,DEBUG,NODEBUG
//////// Fuses: PROTECT,NOPROTECT
//////// 
////////////////////////////////////////////////////////////////// I/O
// Discrete I/O Functions: SET_TRIS_x(), OUTPUT_x(), INPUT_x(),
//                         PORT_x_PULLUPS(), INPUT(),
//                         OUTPUT_LOW(), OUTPUT_HIGH(),
//                         OUTPUT_FLOAT(), OUTPUT_BIT()
// Constants used to identify pins in the above are:

#define PIN_A0  40
#define PIN_A1  41
#define PIN_A2  42
#define PIN_A3  43
#define PIN_A4  44
#define PIN_A5  45

#define PIN_B0  48
#define PIN_B1  49
#define PIN_B2  50
#define PIN_B3  51
#define PIN_B4  52
#define PIN_B5  53
#define PIN_B6  54
#define PIN_B7  55

#define PIN_C0  56
#define PIN_C1  57
#define PIN_C2  58
#define PIN_C3  59
#define PIN_C4  60
#define PIN_C5  61
#define PIN_C6  62
#define PIN_C7  63

#define PIN_D0  64
#define PIN_D1  65
#define PIN_D2  66
#define PIN_D3  67
#define PIN_D4  68
#define PIN_D5  69
#define PIN_D6  70
#define PIN_D7  71

#define PIN_E0  72
#define PIN_E1  73
#define PIN_E2  74

////////////////////////////////////////////////////////////////// Useful defines
#define FALSE 0
#define TRUE 1

#define BYTE int8
#define BOOLEAN int1

#define getc getch
#define fgetc getch
#define getchar getch
#define putc putchar
#define fputc putchar
#define fgets gets
#define fputs puts

////////////////////////////////////////////////////////////////// Control
// Control Functions:  RESET_CPU(), SLEEP(), RESTART_CAUSE()
// Constants returned from RESTART_CAUSE() are:
#define WDT_FROM_SLEEP    3   
#define WDT_TIMEOUT      11   
#define MCLR_FROM_SLEEP  19   
#define MCLR_FROM_RUN    27   
#define NORMAL_POWER_UP  25   
#define BROWNOUT_RESTART 26   

////////////////////////////////////////////////////////////////// Timer 0
// Timer 0 (AKA RTCC)Functions: SETUP_COUNTERS() or SETUP_TIMER_0(),
//                              SET_TIMER0() or SET_RTCC(),
//                              GET_TIMER0() or GET_RTCC()
// Constants used for SETUP_TIMER_0() are:
#define T0_INTERNAL   0
#define T0_EXT_L_TO_H 32
#define T0_EXT_H_TO_L 48

#define T0_DIV_1      8
#define T0_DIV_2      0
#define T0_DIV_4      1
#define T0_DIV_8      2
#define T0_DIV_16     3
#define T0_DIV_32     4
#define T0_DIV_64     5
#define T0_DIV_128    6
#define T0_DIV_256    7


#define T0_8_BIT      0     

#define RTCC_INTERNAL   0      // The following are provided for compatibility
#define RTCC_EXT_L_TO_H 32     // with older compiler versions
#define RTCC_EXT_H_TO_L 48
#define RTCC_DIV_1      8
#define RTCC_DIV_2      0
#define RTCC_DIV_4      1
#define RTCC_DIV_8      2
#define RTCC_DIV_16     3
#define RTCC_DIV_32     4
#define RTCC_DIV_64     5
#define RTCC_DIV_128    6
#define RTCC_DIV_256    7
#define RTCC_8_BIT      0     

// Constants used for SETUP_COUNTERS() are the above
// constants for the 1st param and the following for
// the 2nd param:

////////////////////////////////////////////////////////////////// WDT
// Watch Dog Timer Functions: SETUP_WDT() or SETUP_COUNTERS() (see above)
//                            RESTART_WDT()
// WDT base is 18ms
//

#define WDT_18MS        8   
#define WDT_36MS        9   
#define WDT_72MS       10   
#define WDT_144MS      11   
#define WDT_288MS      12   
#define WDT_576MS      13   
#define WDT_1152MS     14   
#define WDT_2304MS     15   

////////////////////////////////////////////////////////////////// Timer 1
// Timer 1 Functions: SETUP_TIMER_1, GET_TIMER1, SET_TIMER1
// Constants used for SETUP_TIMER_1() are:
//      (or (via |) together constants from each group)
#define T1_DISABLED         0
#define T1_INTERNAL         0x85
#define T1_EXTERNAL         0x87
#define T1_EXTERNAL_SYNC    0x83

#define T1_CLK_OUT          8

#define T1_DIV_BY_1         0
#define T1_DIV_BY_2         0x10
#define T1_DIV_BY_4         0x20
#define T1_DIV_BY_8         0x30

////////////////////////////////////////////////////////////////// Timer 2
// Timer 2 Functions: SETUP_TIMER_2, GET_TIMER2, SET_TIMER2
// Constants used for SETUP_TIMER_2() are:
#define T2_DISABLED         0
#define T2_DIV_BY_1         4
#define T2_DIV_BY_4         5
#define T2_DIV_BY_16        6

////////////////////////////////////////////////////////////////// CCP
// CCP Functions: SETUP_CCPx, SET_PWMx_DUTY
// CCP Variables: CCP_x, CCP_x_LOW, CCP_x_HIGH
// Constants used for SETUP_CCPx() are:
#define CCP_OFF                         0
#define CCP_CAPTURE_FE                  4
#define CCP_CAPTURE_RE                  5
#define CCP_CAPTURE_DIV_4               6
#define CCP_CAPTURE_DIV_16              7
#define CCP_COMPARE_SET_ON_MATCH        8
#define CCP_COMPARE_CLR_ON_MATCH        9
#define CCP_COMPARE_INT                 0xA
#define CCP_COMPARE_RESET_TIMER         0xB
#define CCP_PWM                         0xC
#define CCP_PWM_PLUS_1                  0x1c  
#define CCP_PWM_PLUS_2                  0x2c
#define CCP_PWM_PLUS_3                  0x3c
#word   CCP_1       =                   getenv("SFR:CCPR1L")
#byte   CCP_1_LOW   =                   getenv("SFR:CCPR1L")
#byte   CCP_1_HIGH  =                   getenv("SFR:CCPR1H")
#word   CCP_2       =                   getenv("SFR:CCPR2L")
#byte   CCP_2_LOW   =                   getenv("SFR:CCPR2L")
#byte   CCP_2_HIGH  =                   getenv("SFR:CCPR2H")
////////////////////////////////////////////////////////////////// PSP
// PSP Functions: SETUP_PSP, PSP_INPUT_FULL(), PSP_OUTPUT_FULL(),
//                PSP_OVERFLOW(), INPUT_D(), OUTPUT_D()
// PSP Variables: PSP_DATA
// Constants used in SETUP_PSP() are:
#define PSP_ENABLED                     0x10
#define PSP_DISABLED                    0

#byte   PSP_DATA=                       8   

////////////////////////////////////////////////////////////////// SPI
// SPI Functions: SETUP_SPI, SPI_WRITE, SPI_READ, SPI_DATA_IN
// Constants used in SETUP_SPI() are:
#define SPI_DISABLED             0x00
#define SPI_MASTER               0x20
#define SPI_SLAVE                0x24
#define SPI_SCK_IDLE_HIGH        0x10
#define SPI_SCK_IDLE_LOW         0x00
#define SPI_CLK_DIV_4            0x00
#define SPI_CLK_DIV_16           0x01
#define SPI_CLK_DIV_64           0x02
#define SPI_CLK_T2               0x03
#define SPI_SS_DISABLED          0x01

#define SPI_XMIT_L_TO_H          0x4000
#define SPI_XMIT_H_TO_L          0x0000

#define SPI_SAMPLE_AT_MIDDLE     0x0000
#define SPI_SAMPLE_AT_END        0x8000

//The following are provided for compatibility
#define SPI_L_TO_H       SPI_SCK_IDLE_LOW
#define SPI_H_TO_L       SPI_SCK_IDLE_HIGH

////////////////////////////////////////////////////////////////// UART
// Constants used in setup_uart() are:
// FALSE - Turn UART off
// TRUE  - Turn UART on
#define UART_ADDRESS           2
#define UART_DATA              4
////////////////////////////////////////////////////////////////// COMP
// Comparator Variables: C1OUT, C2OUT
// Constants used in setup_comparator() are:
#define A0_A3_A1_A3  0xfff04
#define A0_A3_A1_A2_OUT_ON_A4_A5  0xfcf03
#define A0_A3_A1_A3_OUT_ON_A4_A5  0xbcf05
#define NC_NC_NC_NC  0x0ff07
#define A0_A3_A1_A2  0xfff02
#define A0_A3_NC_NC_OUT_ON_A4  0x9ef01
#define A0_VR_A1_VR 0x3ff06
#define A3_VR_A2_VR 0xcff0e
#define CP1_INVERT  0x0000010
#define CP2_INVERT  0x0000020

#bit C1OUT = 0x9c.6      
#bit C2OUT = 0x9c.7      

////////////////////////////////////////////////////////////////// VREF
// Constants used in setup_vref() are:
//
#define VREF_LOW  0xa0
#define VREF_HIGH 0x80
// Or (with |) the above with a number 0-15
#define VREF_A2   0x40



////////////////////////////////////////////////////////////////// ADC
// ADC Functions: SETUP_ADC(), SETUP_ADC_PORTS() (aka SETUP_PORT_A),
//                SET_ADC_CHANNEL(), READ_ADC()
// Constants used for SETUP_ADC() are:
#define ADC_OFF                 0              // ADC Off
#define ADC_CLOCK_DIV_2   0x10000
#define ADC_CLOCK_DIV_4    0x4000
#define ADC_CLOCK_DIV_8    0x0040
#define ADC_CLOCK_DIV_16   0x4040
#define ADC_CLOCK_DIV_32   0x0080
#define ADC_CLOCK_DIV_64   0x4080
#define ADC_CLOCK_INTERNAL 0x00c0              // Internal 2-6us

// Constants used in SETUP_ADC_PORTS() are:
#define NO_ANALOGS                           7    // None
#define ALL_ANALOG                           0    // A0 A1 A2 A3 A5 E0 E1 E2 
#define AN0_AN1_AN2_AN4_AN5_AN6_AN7_VSS_VREF 1    // A0 A1 A2 A5 E0 E1 E2 VRefh=A3     
#define AN0_AN1_AN2_AN3_AN4                  2    // A0 A1 A2 A3 A5          
#define AN0_AN1_AN2_AN4_VSS_VREF             3    // A0 A1 A2 A4 VRefh=A3              
#define AN0_AN1_AN3                          4    // A0 A1 A3
#define AN0_AN1_VSS_VREF                     5    // A0 A1 VRefh=A3
#define AN0_AN1_AN4_AN5_AN6_AN7_VREF_VREF 0x08    // A0 A1 A5 E0 E1 E2 VRefh=A3 VRefl=A2     
#define AN0_AN1_AN2_AN3_AN4_AN5           0x09    // A0 A1 A2 A3 A5 E0        
#define AN0_AN1_AN2_AN4_AN5_VSS_VREF      0x0A    // A0 A1 A2 A5 E0 VRefh=A3           
#define AN0_AN1_AN4_AN5_VREF_VREF         0x0B    // A0 A1 A5 E0 VRefh=A3 VRefl=A2           
#define AN0_AN1_AN4_VREF_VREF             0x0C    // A0 A1 A4 VRefh=A3 VRefl=A2              
#define AN0_AN1_VREF_VREF                 0x0D    // A0 A1 VRefh=A3 VRefl=A2
#define AN0                               0x0E    // A0
#define AN0_VREF_VREF                     0x0F    // A0 VRefh=A3 VRefl=A2
#define ANALOG_RA3_REF                    0x1     //!old only provided for compatibility
#define A_ANALOG                          0x2     //!old only provided for compatibility  
#define A_ANALOG_RA3_REF                  0x3     //!old only provided for compatibility  
#define RA0_RA1_RA3_ANALOG                0x4     //!old only provided for compatibility
#define RA0_RA1_ANALOG_RA3_REF            0x5     //!old only provided for compatibility
#define ANALOG_RA3_RA2_REF                0x8     //!old only provided for compatibility
#define ANALOG_NOT_RE1_RE2                0x9     //!old only provided for compatibility  
#define ANALOG_NOT_RE1_RE2_REF_RA3        0xA     //!old only provided for compatibility  
#define ANALOG_NOT_RE1_RE2_REF_RA3_RA2    0xB     //!old only provided for compatibility  
#define A_ANALOG_RA3_RA2_REF              0xC     //!old only provided for compatibility  
#define RA0_RA1_ANALOG_RA3_RA2_REF        0xD     //!old only provided for compatibility
#define RA0_ANALOG                        0xE     //!old only provided for compatibility
#define RA0_ANALOG_RA3_RA2_REF            0xF     //!old only provided for compatibility

// Constants used in READ_ADC() are:
#define ADC_START_AND_READ     7   // This is the default if nothing is specified
#define ADC_START_ONLY         1
#define ADC_READ_ONLY          6

////////////////////////////////////////////////////////////////// INT
// Interrupt Functions: ENABLE_INTERRUPTS(), DISABLE_INTERRUPTS(),
//                      CLEAR_INTERRUPT(), INTERRUPT_ACTIVE(),
//                      EXT_INT_EDGE()
//
// Constants used in EXT_INT_EDGE() are:
#define L_TO_H              0x40
#define H_TO_L                 0
// Constants used in ENABLE/DISABLE_INTERRUPTS() are:
#define GLOBAL                    0x0BC0
#define PERIPH                    0x0B40
#define INT_RTCC                  0x000B20
#define INT_RB                    0x00FF0B08
#define INT_EXT_L2H               0x50000B10
#define INT_EXT_H2L               0x60000B10
#define INT_EXT                   0x000B10
#define INT_AD                    0x008C40
#define INT_TBE                   0x008C10
#define INT_RDA                   0x008C20
#define INT_TIMER1                0x008C01
#define INT_TIMER2                0x008C02
#define INT_CCP1                  0x008C04
#define INT_CCP2                  0x008D01
#define INT_SSP                   0x008C08
#define INT_PSP                   0x008C80
#define INT_BUSCOL                0x008D08
#define INT_EEPROM                0x008D10
#define INT_TIMER0                0x000B20
#define INT_COMP                  0x008D40

#list

 

[betwixt]

CCS is strange, the .h file for any particular processor should contain a list of all the internal registers so it can be 'included' in any project using that processor type. I can't see why you should need to tell it some of the register addresses while it seems to know where others are by itself.

Can you explain why you want the ADC to control the baud rate, it seems like a bad idea because it would make serial communication very unreliable.

Brian.