Python - Numeros Primos

candidato = 2


while(candidato <= 10000):
  divisor = 2
  primo = 1
  while(divisor * divisor <= candidato):
     if (candidato % divisor == 0):
        primo = 0
        break
     divisor = divisor + 1

  if(primo):
    print candidato

  candidato = candidato + 1

SDCC i2c LM75

#include <pic16f873a.h>
#include <i2c.h>
typedef unsigned int word;
word at 0x2007 CONFIG = _HS_OSC & _WDT_OFF & _PWRTE_ON & _BODEN_ON & _LVP_OFF & _CPD_OFF & _WRT_OFF & _DEBUG_OFF & _CP_OFF;

//-- Pines de conexionado para el LCD
#define RW  RA2
#define RS  RA1
#define E   RA0


//-- Valor inicial del timer0 para hacer una pausa de 10ms
//-- Divisor del prescar a 256
#define T_10ms 61

/*********************************************/
/* Habilitar el dato escrito en el puerto B  */
/*********************************************/
void enable()
{
  //-- Hay que garantizar un tiempo minimo de 500ns
  //-- A 20Mhz, las instrucciones tardan 200ns.
  //-- Por eso nos curamos en salud y repetimos la instruccion
  //-- tres veces. 
  E=1; E=1; E=1;
  E=0; E=0; E=0;
}

/**********************************/
/* Enviar un comando al LCD       */
/**********************************/
void lcd_cmd(unsigned char cmd)
{  
  RS=0;
  PORTB=cmd;
  enable();  
  cmd<<=4;
  PORTB=cmd;
  enable();
  delay(1);
}

/*********************************/
/* Escribir un dato en el lcd    */
/*********************************/
void lcd_write(unsigned char car)
{
  RS=1;
  PORTB=car;
  enable();   
  car<<=4;
  PORTB=car;
  enable(); 
  delay(1);
}

unsigned char ConfigLM75()
{
  // Envia Bit de Start
  i2c_SendStart();
  i2c_WaitMSSP();  

  // 2º Envio la direccion del modulo
  i2c_SendByte(0b10010000);
  i2c_WaitMSSP();  
  if (i2c_CheckACK()!=0) {
    i2c_fail();
    return 0;   // Ha habido un error, salgo de la rutina
  }

  
  i2c_SendByte(0b00000000); 
  i2c_WaitMSSP();
  if (i2c_CheckACK()!=0) {
    i2c_fail();
    return 0;    // Ha habido un error, salgo de la rutina
  }

  // termino el envio
  i2c_SendStop();
  i2c_WaitMSSP();

  return 1; 
}

unsigned char LeerLM75(unsigned char address, unsigned char *datoh, unsigned char *datol)
{
  i2c_SendStart();
  i2c_WaitMSSP(); 

  i2c_SendByte(address);

  i2c_WaitMSSP();  
  if (i2c_CheckACK()!=0) {
    i2c_fail();
    return 0;   // Ha habido un error, salgo de la rutina
  }
 
  *datoh=i2c_ReadByte(); 
  
  i2c_SendAck();
  i2c_WaitMSSP(); 

  *datol=i2c_ReadByte();   

  //  Mando NACK
  i2c_SendNack();
  i2c_WaitMSSP();  

  // Mando el Stop
  i2c_SendStop();
  i2c_WaitMSSP();  

  return 1;
}

void DEC_ASCII(unsigned char dato, unsigned char *D1, unsigned char *D2,unsigned char *D3)
{
  *D1 = dato / 100;
  *D2 = (dato % 100) / 10;
  *D3 = (dato % 100) % 10;

  *D1 = 0b00110000 | *D1;
  *D2 = 0b00110000 | *D2;
  *D3 = 0b00110000 | *D3;
}
/*-----------------------------------------------*/
void main(void)
{   
  unsigned char ret;
  unsigned char datoh, datol, D1, D2, D3;

  TRISB=0b00001111;  
  TRISA=0b00000000;  
  ADCON1=0x06;

  //-- Configurar temporizador para hacer pausas
  T0CS=0; PSA=0;
  //-- Configurar el prescaler (division entre 64)
  PS2=1; PS1=1; PS0=1;
  
  i2c_configure();
  //-- Pausa inicial
  delay(10);

  //Inicializando el LCD
  RW=0; E=0;
  lcd_cmd(0b00101000);
  lcd_cmd(0b00000110);
  lcd_cmd(0b00001110);
  lcd_cmd(0b00000010);
  lcd_cmd(0b00000001);

  ConfigLM75();

  delay(10);

  while(1){
  lcd_cmd(0b00000010);
  delay(10);
  ret=LeerLM75(0b10010001, &datoh, &datol);
    if (ret==1) { 
      DEC_ASCII(datoh, &D1, &D2, &D3);
      lcd_write(D1);
      lcd_write(D2);
      lcd_write(D3); 
    }else{
      LED = 1;
    }  
  }  
}

Las resistencias pullup son de 4K7 (Lauraa n.n)

SDCC Leer una eeprom i2c y escribir en un LCD

Utilizando los codigos anteriores podemos leer la eeprom e imprimirla en el LCD
el caracter que grabe es la J.


  //24C08A 256X4
  //0xA6 = 10100110  identificador de eeprom y bit's de paginas 
  i2c_write_byte(0xA6, 0x0, 0x4A);
  delay(10);

  ret=i2c_read_byte(0xA6, 0x0, &dato);
    if (ret==1) { 
     lcd_write(dato);
    }else{
      LED = 1;
    }


  
  while(1);

SDCC LCD a 4 bit's

Del sitio iearobotics.com hay un ejemplo para manejar LCD a 8bits, en este caso lo adapte para 4 bits.

#include <pic16f873a.h>
typedef unsigned int word;
word at 0x2007 CONFIG = _HS_OSC & _WDT_OFF & _PWRTE_ON & _BODEN_ON & _LVP_OFF & _CPD_OFF & _WRT_OFF & _DEBUG_OFF & _CP_OFF;

//-- Pines de conexionado para el LCD
#define RW  RA2
#define RS  RA1
#define E   RA0


//-- Valor inicial del timer0 para hacer una pausa de 10ms
//-- Divisor del prescar a 256
#define T_10ms 61

void timer0_delay(unsigned char t0ini)
{
  //-- Dar valor inicial del timer
  TMR0=t0ini;

  //-- Flag de interrupcion a cero
  T0IF=0;

  //-- Esperar a que transcurra el tiempo indicado
  while(T0IF==0);
}

/*******************************************************/
/* Pausa                                               */
/* ENTRADA: duracion de la pausa en centesimas (10ms)  */
/*******************************************************/
void delay(unsigned int duracion)
{
  unsigned int i;

  for (i=0; i<duracion; i++)
    timer0_delay(T_10ms);
}

/*********************************************/
/* Habilitar el dato escrito en el puerto B  */
/*********************************************/
void enable()
{
  //-- Hay que garantizar un tiempo minimo de 500ns
  //-- A 20Mhz, las instrucciones tardan 200ns.
  //-- Por eso nos curamos en salud y repetimos la instruccion
  //-- tres veces. 
  E=1; E=1; E=1;
  E=0; E=0; E=0;
}

/**********************************/
/* Enviar un comando al LCD       */
/**********************************/
void lcd_cmd(unsigned char cmd)
{  
  RS=0;
  PORTB=cmd;
  enable();  
  cmd<<=4;
  PORTB=cmd;
  enable();
  delay(1);
}

/*********************************/
/* Escribir un dato en el lcd    */
/*********************************/
void lcd_write(unsigned char car)
{
  RS=1;
  PORTB=car;
  enable();   
  car<<=4;
  PORTB=car;
  enable(); 
  delay(1);
}

void main(void)
{  
  TRISB=0b00000000;  
  TRISA=0b00000000;  
  ADCON1=0x06;

  //-- Configurar temporizador para hacer pausas
  T0CS=0; PSA=0;
  //-- Configurar el prescaler (division entre 64)
  PS2=1; PS1=1; PS0=1;

  //-- Pausa inicial
  delay(1);

  //-- Inicializar lcd (para trabajar a 4 bits)
  RW=0; E=0;
  lcd_cmd(0b00101000);

  //--  Modo de funcionamiento
  lcd_cmd(0b00000110);

  //-- Encender el LCD
  lcd_cmd(0b00001110);

  //-- Cursor a HOME
  lcd_cmd(0b00000010);

  //-- CLS
  lcd_cmd(0b00000001);

  //-- Enviar una cadena
  lcd_write('H');
  lcd_write('O');
  lcd_write('L');
  lcd_write('A');
  lcd_write('!');
  
  while(1);
}

SDCC i2c con PIC16F87x

EL codigo lo saque de iearobotics funciona exelente, lei una eeprom sin problemas.

#include <pic16f873a.h>
typedef unsigned int word;
word at 0x2007 CONFIG = _HS_OSC & _WDT_OFF & _PWRTE_ON & _BODEN_ON & _LVP_OFF & _CPD_OFF & _WRT_OFF & _DEBUG_OFF & _CP_OFF;

#define T_10ms 61
#define LED RA0
void timer0_delay(unsigned char t0ini)
{
  //-- Dar valor inicial del timer
  TMR0=t0ini;
 
  //-- Flag de interrupcion a cero
  T0IF=0;

  //-- Esperar a que transcurra el tiempo indicado
  while(T0IF==0);
}


/*******************************************************/
/* Pausa                                               */
/* ENTRADA: duracion de la pausa en centesimas (10ms)  */
/*******************************************************/
void delay(unsigned int duracion)
{
  unsigned int i;

  for (i=0; i<duracion; i++)
    timer0_delay(T_10ms);
}

/*
****************************************
*    FUNCIONES DE BAJO NIVEL DEL I2C   * 
****************************************
*/

// Envia Ack
// SDA = 0 
void i2c_SendAck()
{
  ACKDT = 0;  // Establece un ACK
  ACKEN = 1;  // Lo envia
}


// Envia Nack para finalizar la recepecion
// SDA = 1
void i2c_SendNack()
{
  ACKDT = 1;  // Establece un NACK
  ACKEN = 1;  // Lo envia
}


// verifica ACK
// Mira si en el 9 pulso de reloj (SCL en estado a 1) la señal SDA está a 0
unsigned char i2c_CheckACK()
{
  if ( ACKSTAT == 0 ) {
    return 0;   // correcto (lo he recibido )
  } else { 
    return 1; // incorrecto (no lo he recibido)
  }
}


// Envia la condicion de STOP
// Libera el BUS I2C, SDA y SCL a nivel alto
// SDA=1 cuando SCL=1. 
void i2c_SendStop() {
  PEN = 1;    // send stop bit
}


// Envia la condicion de START
// Inicializa el Bus I2C, SCL y SDA a nivel bajo
// Estando SCL=1 pone SDA=0, luego pone SCL=0
void i2c_SendStart()
{
  SEN = 1;     // send start bit
}

// Espera a que el I2C reciba algun evento
void i2c_WaitMSSP() 
{
  while (SSPIF == 0);  // Espera evento
  SSPIF=0;             // Limpia FLAG
}


// Espera a que el I2C reciba algun evento
unsigned char i2c_MSSP_Status()
{
  return SSPIF; 
}




// Repeated start from master
// Queremos transmitir más datos pero sin dejar el BUS, es decir
// sin mandar previamente un STOP. O por ejemplo si queremos mandar un STOP y seguidamente un
// START para que ningún otro dispositivo ocupe la línea usaremos esto.
void i2c_SendRStart() {
  RSEN=1;
}


// Leer Byte por el I2C
// Devuelve byte leido
unsigned char i2c_ReadByte() {
  RCEN=1;        // Activar el RCEN

  i2c_WaitMSSP();
  return SSPBUF;
}




// Envia un Dato por el Bus I2C
// Entrada el dato a enviar
void i2c_SendByte(unsigned char dato) {
  SSPBUF=dato;
}



// Fallo en el I2C
void i2c_fail() {
  i2c_SendStop();
  i2c_WaitMSSP();
}



/*
**************************************
*   FUNCIONES DE ALTO NIVEL del I2C  *
**************************************
*/


/* Configurar I2C
  Configuramos el I2C como Master
  y a una velocidad de 1Mhz
*/

void i2c_configure()
{
  // configuramos SCL y SDA como pines de entrada
  TRISC=TRISC | 0x18;  // 1 entrada / 0 salida  
  
  SSPSTAT=0x0;  
  SSPSTAT=SSPSTAT | 0x80;  // SMP=1 Slew rate disable for 100Kh  @@@
                           // CKE=0 (modo maestro I2C) y UA=0 (7 bits)

  SSPCON=0x08;       // I2C master mode (uso la formula del reloj con SSPAD)  
  SSPCON=SSPCON | 0x20;  // enable I2C  SSPEN=1

  SSPCON2=0x00;   // no se usa por ahora
  // velocidad = FOSC / ( 4 * (sspad + 1) )
  // Fosc=20Mhz

  SSPADD=49;  // 49->100Khz  @@@
  //SSPADD=24; // 24 -> 400khz   @@@

  // Limpia Flags de eventos
  SSPIF=0;  //Limpia flag de eventos SSP 
}



// manda un byte al dispositivo i2c
unsigned char i2c_write_byte(unsigned char address, unsigned char reg,
                             unsigned char dato)
{
  // 1º Envia Bit de Start
  i2c_SendStart();
  i2c_WaitMSSP();  

  // 2º Envio la direccion del modulo
  i2c_SendByte(address);
  i2c_WaitMSSP();
  if (i2c_CheckACK()!=0) {
    i2c_fail();
    return 0;  // Ha habido un error, salgo de la rutina
  }

  // 3º mando el registro sobre el que voy a actuar
  i2c_SendByte(reg);
  i2c_WaitMSSP(); 
  if (i2c_CheckACK()!=0) {
    i2c_fail();
    return 0;   // Ha habido un error, salgo de la rutina
  }

  // 4º mando el dato 
  i2c_SendByte(dato); 
  i2c_WaitMSSP();
  if (i2c_CheckACK()!=0) {
    i2c_fail();
    return 0;    // Ha habido un error, salgo de la rutina
  }

  // 6º termino el envio
  i2c_SendStop();
  i2c_WaitMSSP();

  return 1;  // Byte mandado correctamente
}


// Lee 1 byte1  del dispositivo i2c
// El dato leido lo devuelve por el parametro dato
unsigned char i2c_read_byte(unsigned char address, unsigned char reg, 
                            unsigned char *dato)
{

  // 1º Envia Bit de Start
  i2c_SendStart();
  i2c_WaitMSSP();  

  // 2º Envio la direccion del modulo
  i2c_SendByte(address);
  i2c_WaitMSSP();  
  if (i2c_CheckACK()!=0) {
    i2c_fail();
    return 0;   // Ha habido un error, salgo de la rutina
  }

  // 3º mando el registro sobre el que voy a actuar
  i2c_SendByte(reg); 
  i2c_WaitMSSP();  
  if (i2c_CheckACK()!=0) {
    i2c_fail();
    return 0;   // Ha habido un error, salgo de la rutina
  }

  // 4º Repeated start
  i2c_SendRStart();
  i2c_WaitMSSP();  

  // 4º mando direccion indicando lectura
  i2c_SendByte(address | 1);
  i2c_WaitMSSP();  
  if (i2c_CheckACK()!=0) {
    i2c_fail();
    return 0;   // Ha habido un error, salgo de la rutina
  }

  // 5º leo el byte 
  *dato=i2c_ReadByte(); 

  // 6º Mando NACK
  i2c_SendNack();
  i2c_WaitMSSP();  

  // Mando el Stop
  i2c_SendStop();
  i2c_WaitMSSP();  

  return 1;   // Lectura correcta

}

//----------------------------
//- Comienzo del programa  
//----------------------------

void main(void)
{
  unsigned char ret;
  unsigned char dato;

  TRISB=0x00;  
  TRISA=0x00;
  //-- Configurar el puerto A como digital
  ADCON1=0x06;

  //-- Configurar temporizador para hacer pausas
  T0CS=0; PSA=0;
  //-- Configurar el prescaler (division entre 64)
  PS2=1; PS1=1; PS0=1;

  //-- Pausa inicial
  delay(100);
  
  //-- Configurar el I2C como master
  i2c_configure();

  //-- Hago una pausa antes de empezar
  delay(10);
  
  //24C08A 256X4
  //0xA6 = 10100110  identificador de eeprom y bit's de paginas 
  i2c_write_byte(0xA6, 0x0, 0xAA);
  delay(10);
  
    ret=i2c_read_byte(0xA6, 0x0, &dato);
    if (ret==1) { 
      PORTB = dato;
    }else{
      LED = 1;
    }


  while(1);

}

Recuerden que la memoria 24C08A no utiliza los pines A0 A1 ya que los usa para acceder a los
bancos que son 4 segun la hoja de datos de atmel.
Osea para formar la palabra de control:

1010 -> identificador de la memoria, luego A2,A1,A0, R/W
en el ejemplo se accedio al 4 banco de 256 bits

10100000 para escribir el primer banco
10100001 para leer el primer banco

el pin A2 sera entonces para direccionar otras unidades conectadas al bus i2c.

Usando Gafix CASIO CFX

Gafix un programa para comunicarnos con nuestra calculadora casio cfx, como por ejemplo casio cfx 9850g plus, esta escrito en gtk y utiliza las librerias libcafix, todo esta disponible en sourceforge.
En el siguiente sitio encontraran mas informacion bastante interesante http://spiderpixel.co.uk/caspro/index.html programas y documentacion de varias calculadoras.

PWM con pic 16F87x - SDCC

void pwm(unsigned int ciclo, unsigned char aux){
 //250 Hz - 4Mhz valor del periodo
 PR2 = 0b11111001;  // 249
 //Ciclo de trabajo
 CCPR1L = ciclo; //249-100%   124-50%  
 //Prescaler 16, Timer 2 off 
 T2CON = 0b00000011 ; 
 //Modo PWM
 CCP1CON = 0b00001100 ; // 8bit 
 
 if (aux=='1'){
   TMR2ON=1;
 }else if(aux=='0'){   
   TMR2ON=0;
 }
} 

Hasta ahora funciona bien n_n asi que bueno  modificare con el tiempo...
para el motor que estoy usando de una lectora de CD los 250Hz le vino como anillo al dedo xD
pwm(124,1) seria el valor de los ciclos de trabajo y el uno para avilitar el PWM desde el
registro T2CON. Mas info para los calculos vean  la hoja de datos de microchip donde en una tabla
nos indica los minimos y maximos en que puede trabajar el pwm segun el cristal empleado.

freemat - Funciones para calcular tiempos TMR0

El siguiente codigo lo extraje de http://www.iearobotics.com/ un excelente sitio de microcontroladores pic con manuales cursos ejemplos.

El codigo calcula el valor del registro TMR0 y de su prescaler para configurarlo y poder generar notas musicales, ingresamos el valor del cristal y la frecuencia que queremos generar. Los scripts estan para matlab asi que hize unos cambios para que funcionen en freemat.

function TMR0=timer0_TMR0_frec(FOSC,frecuencia)
    DIV=[2,4,8,16,32,64,128,256];
    PS=[000,001,010,011,100,101,110,111];    
    Duracion = 1/(2*frecuencia)*1000000;
    TMR0=256-timer0_ticks(FOSC,Duracion);
    frec = 1000000./(2*timer0_Duracion(FOSC,Duracion));
    Error = frecuencia-frec;
    for i=1:length(TMR0)
     if TMR0(i)<256 && TMR0(i)>=0
      printf ('TMR0= %d, PS2:0= %03d, Div= %3d, Frec= %.1f Hz, Error= %.2f Hz\n', TMR0(i), PS(i), DIV(i), frec(i), Error(i));
      end           
    end

function Dur=timer0_Duracion(FOSC,Duracion)
  DIV=[2,4,8,16,32,64,128,256];
  N=timer0_ticks(20,Duracion);
  Dur = N.*(4*DIV/FOSC);

function N=timer0_ticks(FOSC,Duracion)
  DIV = [2 4 8 16 32 64 128 256];
  N = round(FOSC*Duracion./(4*DIV));
  for i=1:length(N)
    if N(i)>255
      N(i)=NaN;
    end
  end

function TMR0=timer0_TMR0(FOSC,t)
  DIV=[2,4,8,16,32,64,128,256];
  PS=[000,001,010,011,100,101,110,111];
  TMR0=256-timer0_ticks(FOSC,t);
  tc=timer0_Duracion(FOSC,t);
  Error = t - tc;

  for i=1:length(TMR0)
   if TMR0(i)<256 && TMR0(i)>=0
    printf ('T0INI= %3d, PS2:0= %03d, Div= %3d, tc= %.1f us, Error= %.2f us\n',
             TMR0(i),PS(i), DIV(i), tc(i),Error(i));
   end
  end

Ejemplo 6 - Sensores infrarrojos

/* Autor: Jose Maria Quiroga
   chispilinux@gmail.com
   GNU-Electronica

RB7 A  CD4052
RB6 B
RB5 
RB4 
RB3 
RB2 
RB1 
RB0 INT

RC7 RX
RC6 TX 
RC5 IN - LM562
RC4 SDA 
RC3 SCL
RC2 CE  PWM   L293D
RC1 B
RC0 A

RA0 AN0  
RA1 AN1  
RA2 AN2  
RA3 VRef + 
RA4 LED
RA5 AN4  */

#include <pic16f873a.h>
#include <usart.h>
#include <adc.h>
typedef unsigned int word;
word at 0x2007 CONFIG = _XT_OSC & _WDT_OFF & _PWRTE_ON & _BODEN_ON & _LVP_OFF & _CPD_OFF & _WRT_OFF & _DEBUG_OFF & _CP_OFF;

#define CA RB7
#define CB RB6
#define LED RA4
#define IN RC5
#define MA RC0
#define MB RC1
#define CE RC2

void retardo50ms(int m);

void main() {
 Configuracion(); 
 ConfigUART();
 ConfigADC();
 PORTA=0;PORTB=0;PORTC=0;
 
 while(1){
  CA=0;CB=0;
  if (IN==0){
   retardo50ms(1);
   if (IN==0)LED=0;
  }else{
   LED=1;
  }
 }
}


void Configuracion(){
  TRISA=0b00101111;
  TRISB=0b00000000;
  TRISC=0b10100000;

  INTCON=0b00000000;
  T0CS = 0;
  TMR0 = 0;
  PSA = 0;
}


void retardo50ms(int m){
unsigned int i;
for (i=1;i<=m;i++) {
 PS2=1; PS1=1; PS0=1; 
 T0IF = 0;
 TMR0=255;
 while(T0IF==0);
}
}

Sensores de obstaculos

SDCC Ejemplo 5 USART

Bueno aqui otro ejemplo que acabo de terminar sencillo n_n.


Para mandarle unos comando al pic desde python:

import serial

RS232 = serial.Serial('/dev/ttyUSB0', 1200, timeout=1)

print RS232.portstr
RS232.write(raw_input(':'))

try:
dato=ord(RS232.read())
print dato
dato=ord(RS232.read())
print dato
except:
print "No se recibio ningun dato"

RS232.close()


Programa en C para el pic, utiliza interrupciones para recibir los datos n_n.

#include <pic16f873a.h>

typedef unsigned int word;
word at 0x2007 CONFIG = _HS_OSC & _WDT_OFF & _LVP_OFF &_DEBUG_OFF & _CPD_OFF &_PWRTE_ON  &_BODEN_ON;


unsigned char Serial_RX(void);
void Serial_TX(unsigned char);

void isr() interrupt 0 {
unsigned char aux;
 if (RCIF==1){
   switch(RCREG){
     case 'A':RB0=1;break;
     case 'B':RB0=0;break;
   }
 } 
 Serial_TX('K');
 RCIF=0;
}

void main() {
 TRISB=0x0;
 TRISC=0b10000000;

 TXSTA=0b00100000;
 SPBRG=255;
 PIE1=0b00100000;
 RCSTA=0b10010000;
 INTCON=0b11000000;

 PORTB=0x0;
 while(1);
}

unsigned char Serial_RX(){
  while(RCIF==0);
  return RCREG;
}

void Serial_TX(unsigned char a){
 TXREG=a;
 while (TRMT==0);
}

SDCC Ejemplo 4 ADC

typedef unsigned int word;
word at 0x2007 CONFIG = _HS_OSC & _WDT_OFF & _PWRTE_ON & _BODEN_ON & _LVP_OFF & _CPD_OFF & _WRT_OFF & _DEBUG_OFF & _CP_OFF;


int LeerADC(int);

void main() {
unsigned int aux;
ADCON1=0b00000001; // Vref+ AN3
TRISA=0b11111111;
TRISB=0b00000000;
while(1){
aux = LeerADC(1);
PORTB = aux;
}
}


int LeerADC (int c){
switch(c) {
case 1:
ADCON0=0b01000001; //RA0 AN0
break;
case 2:
ADCON0=0b01001001; //RA1 AN1
break;
case 3:
ADCON0=0b01010001; //RA2 AN2
break;
case 4:
ADCON0=0b01100001; //RA5 AN4
break;
}
GO=1;
while(GO==0);
return ADRESH;
}

SDCC Ejemplo 3 Tmr0

/*Recuerden esto se genero con Piklab pongan el include segun su PIC, 20Mhz*/


typedef unsigned int word;
word at 0x2007 CONFIG = _HS_OSC & _WDT_OFF & _LVP_OFF &_DEBUG_OFF & _CPD_OFF &_PWRTE_ON &_BODEN_ON;

void delay_1ms(void);
void delay_100ms(void);

void main() {
int a;
TRISB= 0b00000000;
INTCON=0b00000000;

T0CS = 0;
TMR0 = 0;
PSA = 0;

while(1){
PORTB=0b11110000;
delay_100ms();
PORTB=0b11100000;
delay_100ms();
PORTB=0b11000000;
delay_100ms();
PORTB=0b10000000;
delay_100ms();
}
}
void delay_100ms(){
int a;
for (a=0;a<=100;a++){
delay_1ms();
}
}

void delay_1ms()
{
PS2=1; PS1=0; PS0=0;
T0IF = 0;
TMR0=100;
while(T0IF==0);
}