Mini curso "Programación en XC8"

[elgarbe]

y si metes los datos del gps al 2550 y alli armas la trama completa?
si no tiene 2 uart, la que recive los datos del gps la puedes hacer por software....

otra podría ser poner unas llaves electrónicas (no se si el 4066 sirve para eso) y que el micro elija si pasan los datos del gps o los mismos del micro. hay unos integrados digitales que no recuerdo como se llaman, transeiver, codificadores, no recuerdo, pero posee 2 entradas por cada línea de salida y con un pin de control se elije que dato pasa a la salida...

Me interesa el código del bmp, estoy por utilizar uno igual, está disponible?

Salludos!

[Rseliman]

y si metes los datos del gps al 2550 y alli armas la trama completa?
si no tiene 2 uart, la que recive los datos del gps la puedes hacer por software....

otra podría ser poner unas llaves electrónicas (no se si el 4066 sirve para eso) y que el micro elija si pasan los datos del gps o los mismos del micro. hay unos integrados digitales que no recuerdo como se llaman, transeiver, codificadores, no recuerdo, pero posee 2 entradas por cada línea de salida y con un pin de control se elije que dato pasa a la salida...

Me interesa el código del bmp, estoy por utilizar uno igual, está disponible?

Salludos!

Porsupuesto que si esta disponible ...se aprende mucho al compartir ...creo que ahi esta el secreto ahora te paso el codigo ....

Yo tambien pense en poner un integrado que separe ...pero me gusta mas la idea de entrar por una uart por soft ...ya vere que hago

te paso el codigo del Bmp

Código: [Seleccionar]

/*
 * File:   bmp085.c
 * Author: Ramiro
 *
 * Created on 21 de septiembre de 2013, 13:09
 */

#define _XTAL_FREQ 8000000

#include "xc.h"
#include <math.h>
#include "bmp085.h"



// * Defines ************************************************************
#define BMP085_R 0xEF
#define BMP085_W 0xEE
#define OSS 3 // Oversampling Setting

// * Globals Variables **************************************************

const unsigned char OSS_conversion_time[] = {5, 8, 14, 26};

signed char BMP_err;

long ac1;
long ac2;
long ac3;
long b1;
long b2;
long mb;
long mc;
long md;
unsigned long ac4;
unsigned long ac5;
unsigned long ac6;

/************************************************************************
*
*
************************************************************************/
void delay_ms(unsigned short ms)
{
for(; ms > 0; ms--)
{
Delay100TCYx(20);
}
}

/************************************************************************
*
*
************************************************************************/
void BMP085_Calibration(void)
{
ac1 = (signed short) bmp085ReadShort(0xAA);
ac2 = (signed short) bmp085ReadShort(0xAC);
ac3 = (signed short) bmp085ReadShort(0xAE);
ac4 = bmp085ReadShort(0xB0);
ac5 = bmp085ReadShort(0xB2);
ac6 = bmp085ReadShort(0xB4);
b1 = (signed short) bmp085ReadShort(0xB6);
b2 = (signed short) bmp085ReadShort(0xB8);
mb = (signed short) bmp085ReadShort(0xBA);
mc = (signed short) bmp085ReadShort(0xBC);
md = (signed short) bmp085ReadShort(0xBE);
}

/************************************************************************
*
*
************************************************************************/
void BMP085_Known_Calibration(void)
{
ac1 = 408;
ac2 = -72;
ac3 = -14383;
ac4 = 32741;
ac5 = 32757;
ac6 = 23153;
b1 = 6190;
b2 = 4;
mb = -32768;
mc = -8711;
md = 2868;
}


/************************************************************************
*
************************************************************************/
void BMP_process_error()
{
#ifdef ERROR_HANDLING
if(BMP_err != 0)
{
flag |= BMP_ERROR;
printf((const far rom char*) "BMP_err: %d\r\n", BMP_err);
BMP_err = 0;
}
#endif
}

/************************************************************************
*
*
************************************************************************/
unsigned short bmp085ReadShort(unsigned char address)
{
unsigned short msb, lsb;
unsigned short data;
StartI2C();

BMP_err |= WriteI2C(BMP085_W); // Write 0xEE
BMP_err |= WriteI2C(address); // Write register address

RestartI2C();

BMP_err |= WriteI2C(BMP085_R); // Write 0xEF

msb = ReadI2C(); // Get MSB result
BMP_err |= AckI2C();
lsb = ReadI2C(); // Get LSB result


NotAckI2C();
StopI2C();

delay_ms(10);

data = msb << 8;
data |= lsb;

BMP_process_error();

return data;
}

/************************************************************************
*
*
************************************************************************/
unsigned long bmp085ReadThreeBytes(unsigned char address)
{
unsigned short msb, lsb, xlsb;
unsigned long data;

StartI2C();

BMP_err |= WriteI2C(BMP085_W); // Write 0xEE
BMP_err |= WriteI2C(address); // Write register address

RestartI2C();

BMP_err |= WriteI2C(BMP085_R); // Write 0xEF

msb = ReadI2C(); // Get MSB result
AckI2C();
lsb = ReadI2C(); // Get LSB result

NotAckI2C();
StopI2C();

delay_ms(10);

data = msb;
data <<= 8;
data |= lsb;
data <<= 8;
data |= xlsb;

BMP_process_error();

return data;
}

/************************************************************************
*
*
************************************************************************/
long bmp085ReadTemp(void)
{
StartI2C();

WriteI2C(BMP085_W); // Write 0xEE
WriteI2C(0xF4); // Write register address
WriteI2C(0x2E); // Write register data for temp

StopI2C();

delay_ms(10); // Max time is 4.5ms

return (signed short) bmp085ReadShort(0xF6);
}

/************************************************************************
*
*
************************************************************************/
long bmp085ReadPressure(void)
{
StartI2C();

WriteI2C(BMP085_W); // Write 0xEE
WriteI2C(0xF4); // Write register address
WriteI2C(0x34 | (OSS << 6)); // Write register data for temp

StopI2C();

delay_ms(OSS_conversion_time[OSS]); // Max time is 4.5ms
if(OSS) {
return bmp085ReadThreeBytes(0xF6);
} else {
return ((long) bmp085ReadShort(0xF6)) << 8;
}
}

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

#define SHIFT(shift) (((long) 1) << (shift))

void bmp085Convert(long *temperature, long *pressure, unsigned char readings)
{
long ut;
long up;
long x1, x2, b5, b6, x3, b3, p;
unsigned long b4, b7;
unsigned char i;

ut = 0;
up = 0;

for(i = 0; i < readings; i++)
{
ut += bmp085ReadTemp();
up += bmp085ReadPressure();
}
ut = ut / readings;
up = up / readings;

up = up >> (8-OSS);

x1 = (ut - ac6) * ac5 / SHIFT(15);
x2 = (mc * SHIFT(11)) / (x1 + md);
b5 = x1 + x2;
*temperature = (b5 + 8) / SHIFT(4);

b6 = b5 - 4000;
x1 = (b2 * (b6 * b6 / SHIFT(12))) / SHIFT(11);
x2 = ac2 * b6 / SHIFT(11);
x3 = x1 + x2;

b3 = ((((ac1 * 4) + x3) << OSS) + 2) / SHIFT(2);
x1 = ac3 * b6 / SHIFT(13);
x2 = (b1 * (b6 * b6 / SHIFT(12))) / SHIFT(16);
x3 = ((x1 + x2) + 2) / SHIFT(2);
b4 = (ac4 * (unsigned long) (x3 + 32768)) / SHIFT(15);
b7 = ((unsigned long) up - b3) * (50000 >> OSS);
p = b7 < 0x80000000 ? (b7 * 2) / b4 : (b7 / b4) * 2;

x1 = p / SHIFT(8);
x1 *= x1;
x1 = (x1 * 3038) / SHIFT(16);
x2 = (-7357 * p) / SHIFT(16);
x2 = x2 / SHIFT(16);

*pressure = p + (x1 + x2 + 3791) / SHIFT(4);

}

en el main usas primero

BMP085_Calibration()   

lo cual obtiene los valores fijos de calibracion , y desp de esto lees directamente los datos

 bmp085Convert(&temperature, &pressure, 5);


Cualquier cosa me preguntas !!! un abrazo

[Suky]

Comparto la idea con elgarbe, hay que leer los datos del GPS con el 18f2550, cada vez que llegue una trama agregarle lo de los demás parámetros, y de ahí enviarlo a la PC... Este ultimo podes hacerlo con una uart por SW. (porque según recuerdo el GPS envía datos cada x tiempo, y ahí te conviene usar interrupciones)

Colocar llaves electrónicas puede ser mas complicado, porque hay que determinar cuando esta enviando datos, sino tenes posibilidad de cortar la trama enviada.

Saludos!

[elgarbe]

por cierto, en:
C:\Archivos de programa\Microchip\xc8\v1.21\include\plib
tenes un archivo llamado sw_uart, ahí esta la implementacion para pic18 de una uart por software.

Saludos!

[elgarbe]

Ramiro, las funciones writei2c y las demas referentes al i2c donde estan las definiciones? son de alguna plib de microchip?

me llego la imu para empezar a jugar y probablemente comience con este sensor hasta que le agarre la mano al i2c, que nunca he usado...

saludos!

[Rseliman]

Ramiro, las funciones writei2c y las demas referentes al i2c donde estan las definiciones? son de alguna plib de microchip?

me llego la imu para empezar a jugar y probablemente comience con este sensor hasta que le agarre la mano al i2c, que nunca he usado...

saludos!

Como andas ?? busca en el doc plibs de xc8 en procesador 2550 ...yo la saque de ahi ...en la carpeta de xc8 en docs ...ahi tenes el pdf de las libs ...

Un Abrazo

[Rseliman]

Ramiro, las funciones writei2c y las demas referentes al i2c donde estan las definiciones? son de alguna plib de microchip?

me llego la imu para empezar a jugar y probablemente comience con este sensor hasta que le agarre la mano al i2c, que nunca he usado...

saludos!

Perdoname te entendi mal ....lo que pasa es que yo llame la lib desde otro lado ...esta en la carpeta plib de xc8 ...i2c.h ...y como usarla esta en el doc de las libs de xc8 ...bahhh c18 pero es lo mismo ...el doc esta en la carpeta docs en la carpeta del compiler xc8
Abrazo

[elgarbe]

Perfecto, me imaginaba que andaría por ahí.
Ya estudie el código que posteaste junto con el datasheet y ya entiendo como funcionan las funciones.

Ahora biene lo más lindo, tengo que portar esas funciones a ARM ya que estoy usando la LPCXpresso para conectar el sensor... ya iremos viendo que pasa.

Saludos!

[elgarbe]

Ramiro, tendras el bmp085.h a mano?

Saludos!

[AngelGris]

  Yo utilizaría UART por hard para la comunicación con el GPS. I2C por Hard para la comunicación con el BMP y UART por soft para la comunicación con la PC.

[Rseliman]

Ramiro, tendras el bmp085.h a mano?

Saludos!

Te lo paso cuando llegue a casa disculpame !!!

Abrazo

[Rseliman]

Ramiro, tendras el bmp085.h a mano?

Saludos!

Te lo paso cuando llegue a casa disculpame !!!

Abrazo

Aca va el .h

Código: [Seleccionar]

/*
 * File:   bmp085.h
 * Author: Ramiro
 *
 * Created on 21 de septiembre de 2013, 13:12
 */

#ifndef BMP085_H
#define BMP085_H

#ifdef __cplusplus
extern "C" {
#endif




#ifdef __cplusplus
}
#endif

#endif /* BMP085_H */

void delay_ms(unsigned short ms);
void BMP085_Calibration(void);
long bmp085ReadTemp(void);
long bmp085ReadPressure(void);
unsigned short bmp085ReadShort(unsigned char address);
void bmp085Convert(long *temperature, long *pressure, unsigned char readings);
void BMP_process_error();

[Rojasfx]

Buenas Compañeros de electronica..

Quiero hacer un proyecto sencillo de un contador que incremente al presionar un pulsador, y que muestre el valor en un display de 7 seg, sin embargo tengo problemas con el contador tengo una leve idea, si alguien pudiera darme una mano se lo agradeceria..    Lo que pretendo es que en la variable llamada contador se almacene el valor...  no inclui la parte de display de 7 seg porque quisiera ir por partes..

// PIC16F877A Configuration Bit Settings
#define XTAL_FREQ  12000000
#include <xc.h>

// #pragma config statements should precede project file includes.
// Use project enums instead of #define for ON and OFF.

// CONFIG
#pragma config FOSC = HS        // Oscillator Selection bits (HS oscillator)
#pragma config WDTE = OFF        // Watchdog Timer Enable bit (WDT enabled)
#pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
#pragma config BOREN = ON       // Brown-out Reset Enable bit (BOR enabled)
#pragma config LVP = ON         // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3/PGM pin has PGM function; low-voltage programming enabled)
#pragma config CPD = OFF        // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off)
#pragma config WRT = OFF        // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control)
#pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)

int contador;

int main(int argc, char** argv) {
    TRISD = 0x00;
    TRISC = 0x01;
    contador = 0;
    PORTC = 0x00;
    PORTD = 0x00;

    if(RC0 ==0){
            contador = contador++;}
      end if

[AngelGris]

  El problema que hay en como haces la lectura del pin es que si el pin queda presionado mucho tiempo el contador seguirá contando y ademas sería bueno colocar algún delay como antirrebote... si no es eso lo que necesitas debería modificar la forma de la lectura... tal vez algo así pueda funcionar...

Código: C

1. unsigned int contado = 0; // contador
2. unsigned char estado = 0; // guardo el estado del pulsador (1 indica presionado y 0 sin presionar)
3.  
4. if ((estado == 1) && (PORTCbits.RC0 == 1)) // si estaba presionado y ahora esta suelto
5.   estado = 0; // boton suelto
6. if ((estado == 0) && (PORTCbits.RC0 == 0)) // si estaba suelto y ahora esta presionado...
7. {
8.   __delay_ms(15); // 15 mS de antirrebote
9.   if (PORTCbits.RC0 == 0) // si sigue presionado
10.   {
11.     contador++; // incremento el contador
12.     estado = 1; // boton presionado
13.   }
14. }

[Rojasfx]

Gracias compañero por el aporte.. 
   Veo que estas mas familiarizado que yo en esto.

   Preguntas:
        1.  declare bien los puertos?
        2.  como hago para "invocar" el valor almacenado en la variable contador?