tsl2561
//****************************************** *****************
//** Controlador IIC**
//** Microcontrolador: STC12C5410AD Frecuencia principal: 24MHz **
//** Saltando lt; 2008.04.20gt; **
//****************** * ***************************************
//# incluir lt; REGX051.Hgt; // archivo de encabezado AT89C4051
#include "../inc/STC12C5410AD.H" // archivo de encabezado AT89C4051
#include lt;INTRINS.Hgt ; // Archivo de encabezado de comando del sistema
#include "def.h" // Archivo de definición de tipo
#include "config.h" // Archivo de encabezado de configuración
#include "IIC.h" // Archivo de encabezado de configuración
#include "uart.h" // Archivo de encabezado de configuración
#define SomeNOP(); _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();}
//****Declaración de variable****
INT CH0, CH1;
// *** Declaración de función***
void I2C_Start (void);
void I2C_Stop ( void);
BOOL Send_Byte_I2C(BYTE tmData);
BYTE Read_Byte_I2C_ACK();
BYTE Read_Byte_I2C_NoACK(); ( uchar addr);
void InitTsl256x(void);
INT GetLux(void);
//BOOL Read_Data_I2C(BYTE iNum, unsigned int wAddr, BYTE tmDat
a[64]);
//BOOL Write_Data_I2C(BYTE iNum, unsigned int wAddr, BYTE tmData[64]); ************************************************** **************************
int sin signo CalculateLux(int sin signo iGain, int sin signo tInt, int sin signo ch0 , unsigned int ch1, int iType
//#pragma OPTIMIZE(5)
/****************** ************************************************** * ***********
* Nombre: I2C_Start()
* Función: Iniciar operación I2C
* Parámetros de entrada: Ninguno
* Parámetros de exportación: Ninguno
********************************* ***** ********************************************** **/
void I2C_Start (void)
{
SDA=0
SCL=0; p> SomeNOP() ; // La línea de datos permanece alta, la línea de reloj salta de mayor a menor una vez y comienza la comunicación I2C
SDA=1
SCL=1;
SomeNOP(); // La línea de datos permanece alta, la línea de reloj salta de mayor a menor una vez y comienza la comunicación I2C
SDA=0; > SCL=0;
SomeNOP(); // La línea de datos permanece alta, la línea de reloj salta de alta a baja una vez y comienza la comunicación I2C
SDA=1; /p>
SCL=1;
SomeNOP(); //La línea de datos permanece alta, la línea de reloj salta de mayor a menor una vez y comienza la comunicación I2C
SomeNOP(); // La línea de datos permanece alta, la línea de reloj Un salto de mayor a menor, se inicia la comunicación I2C
SDA=0
SCL=0; >
SomeNOP(); //La línea de datos permanece alta, la línea de reloj salta de mayor a menor una vez y se inicia la comunicación I2C
SDA=1
SCL= 1;
SomeNOP(); //datos La línea permanece alta, la línea del reloj pasa de alta a baja una vez y comienza la comunicación I2C
SDA=0;
SCL=0;
SomeNOP(); // La línea de datos permanece alta, la línea de reloj salta de mayor a menor una vez y comienza la comunicación I2C
SDA=1 ;
SCL=1;
SomeNOP(); //La línea de datos permanece alta, la línea de reloj salta de mayor a menor una vez y comienza la comunicación I2C
SomeNOP (); // La línea de datos permanece alta, la línea de reloj salta de alta a baja una vez y comienza la comunicación I2C
SDA=1
SCL=0; /p>
SomeNOP(); //La línea de datos permanece alta, la línea de reloj salta de alta a baja una vez y comienza la comunicación I2C
SDA=1
SCL=1;
p>
SomeNOP(); // La línea de datos permanece alta, la línea de reloj salta de mayor a menor una vez y comienza la comunicación I2C
SDA =0;
SomeNOP() ; //La línea de datos permanece alta, la línea de reloj salta una vez de mayor a menor y comienza la comunicación I2C
SomeNOP(); la línea de datos permanece alta, la línea del reloj salta una vez de mayor a menor y se inicia la comunicación I2C
}
/*************** ******************* ********************************** ****************
* Nombre: I2C_Stop()
* Función: Finalizar operación I2C
* Parámetro de entrada: Ninguno
* Parámetro de salida: Ninguno
*************************** ******************* ******************************* **/
void I2C_Stop (void)
{
SDA=0;
SomeNOP() //La línea de datos permanece bajo, la línea del reloj salta de bajo a alto una vez y la comunicación I2C se detiene
SCL=1
SomeNOP()
SDA=1;
AlgunosNOP();
}
p>/********************* **************************** ************************* **************
* Nombre: I2C_Start()
* Función: Iniciar operación I2C
* Parámetro de entrada : Ninguno
* Parámetro de salida: Ninguno
********* ********************** ******************************* ********************** */
void SendAck(void)
{
SDA =1
SCL=0; > SomeNOP(); //La línea de datos permanece baja y la línea de reloj pasa de alta a baja para enviar una señal de respuesta
SCL=1
SomeNOP();
// SCL=0;
}
/********************* *** ************************************************* **** ********
* Nombre: I2C_Start()
* Función: Iniciar operación I2C
* Parámetros de entrada: Ninguno
* Parámetros de exportación: Ninguno
********************************* ********* ******************************************* *******/
void SendNotAck(void)
{
SDA=1
SCL=0;
SomeNOP(); // La línea de datos permanece alta y la línea de reloj pasa de alta a baja sin respuesta
SCL=1
SomeNOP(
// SCL=0
}
/******************* ******************* ********************************** ************
* Nombre: I2C_Start()
* Función: Iniciar operación I2C
* Parámetro de entrada: Ninguno
* Parámetro de salida: Ninguno
****************************** ********************** **************************** ********/
BOOL Send_Byte_I2C(BYTE ch)
{
unsigned char i=8
mientras (i--)
{
SCL=0;
_nop_();
SDA=(bit)(campeón); ;0x80);
chlt;lt;=1;
SomeNOP (); //Los datos se pueden enviar mientras el reloj permanece bajo
SCL=1 ;
AlgunosNOP();
}
SCL= 0
EnviarNotAck(); 0;
}
/********************************* *********************************** *************** ***
* Nombre: I2C_Start()
* Función: Iniciar operación I2C
* Parámetros de entrada: Ninguno
* Salir parámetros: Ninguno
********************************************* *** *************************************/
BYTE Read_Byte_I2C_ACK( vacío)
{
BYTE i,tdata;
i=8;tdata=0;
SDA=1; p>
_nop_(); _nop_(); _nop_();
mientras (i--)
{
tdatalt;lt;= 1;
SCL=0;
AlgunosNOP();
SCL=1
AlgunosNOP(); lo hace una vez desde baja Una transición alta puede recibir datos
tdata|=SDA
}
SCL=0
SendAck; ();
devolver datos
}
/********************* *** ************************************************* **** *****
* Nombre: I2C_Start()
* Función: Iniciar operación I2C
* Parámetro de entrada: Ninguno
* Parámetros de exportación: Ninguno
************************************ ******** *******************************************/
BYTE Read_Byte_I2C_NoACK()
{
BYTE i
BYTE tmData = 0
SDA= 1;
for(i=0; ilt; 8; i)
{
tmData *= 2
SCL = 1;
if(SDA)
tmData |=
SCL = 0
_nop_ (); >
_nop_ ();
_nop_ ();
_nop_ ();
_nop_ (
}
/* SCL = 0 */
return tmData
}
/********** ******** **
************************************************** * *********
* Nombre: TSL2561_write_byte()
* Función: Iniciar operación I2C
* Parámetros de entrada: Ninguno
* Parámetros de exportación: Ninguno
********************************* * ********************************************/
uchar TSL2561_write_byte( dirección de caracteres sin firmar, dat de caracteres sin firmar)
{
uchar status=0
I2C_Start() //Iniciar<; / p>
status=Send_Byte_I2C(TSL2561_ADDR|TSL2561_WR); //Escribir dirección TSL2561
status=Send_Byte_I2C(0x80|addr); //Escribir comando
status=Send_Byte_I2C ( dat); //Escribir datos
I2C_Stop( ); //Detener
delay_1ms(2); //Retraso 2 ms
return 0; /p>
}
/************************************ ******* ******************************************* **
* Nombre: TSL2561_read_byte()
* Función: Iniciar operación I2C
* Parámetro de entrada: Ninguno
* Parámetro de salida : Ninguno
****************************************** ************ ****************************/
uchar TSL2561_read_byte(uchar addr)
{
uchar status=0;
I2C_Start(); //Iniciar
status=Send_Byte_I2C( TSL2561_ADDR|TSL2561_WR); //Escribir dirección TSL2561
status=Send_Byte_I2C(0x80|addr); //Escribir comando
I2C_Start(); //Reiniciar
status=Send_Byte_I2C(TSL2561_ADDR|TSL2561_RD); //Escribir dirección TSL2561
status=Read_Byte_I2C_ACK(); //Leer datos
I2C_Stop( ); //Detener
delay_1ms(10);
estado de retorno
}
/** * ************************************************** ***************************
* Nombre: InitTsl256x()
* Función: Iniciar operación I2C
* Parámetro de entrada: Ninguno
* Parámetro de salida: Ninguno
****************** ** ************************************************* *** *************/
void InitTsl256x(void)
{
uchar status
status=TSL2561_write_byte(0x00, PWUP); //Registro 00H
//status=TSL2561_write_byte(0x01, 0x12); //Registro 00H
status=TSL2561_write_byte( 0x01, 0x02 ); //Registro 00H //jumping080522 cambia la ganancia a 1x
status=TSL2561_write_byte(0x02, 0x00); //Registro 00H
status=TSL2561_write_byte(0x03, 0x00); //Registrar 00H
status=TSL2561_write_byte(0x04, 0x00); //Registrar 00H
status=TSL2561_write_byte(0x05, 0x00); >
status=TSL2561_write_byte(0x06, 0x00); //Registrar 00H
/*
I2C_Start() //Iniciar
status=Send_Byte_I2C (TSL2561_ADDR| TSL2561_WR); //Escribe la dirección TSL2561;
//prueba de salto
mientras(!status)//prueba el reconocimiento del Tsl2561
LED=0
LED=1;
status=Send_Byte_I2C(0x90|REG_CTR); //Escribir comando
// I2C_Start(); //Iniciar
// status=Send_Byte_I2C(TSL2561_ADDR |TSL2561_RD); //Escribe la dirección TSL2561
status=Send_Byte_I2C(0x07); //Escribe n ge
status=Send_Byte_I2C(PWUP);
status=Send_Byte_I2C(0x12); //Registro 01H -la ganancia=1 16x -el temporizador=10 401ms
status=Send_Byte_I2C(0x00); //Registro 02H
status=Send_Byte_I2C(0x00); //Registrar 03H
status=Send_Byte_I2C(0x00); //Registrar 04H
status=Send_Byte_I2C(0x00); p>
status=Send_Byte_I2C(0x00); //Registrar 06H sin interrupción
I2C_Stop( ); //Detener*/
delay_1ms(10); ms
}
//********************************* ** **********************************************
//
// Copyright -Handson Jumping, Inc.
//
// Aproximación de ecuaciones de lux sin cálculos de punto flotante
/////////////////////////////////////////////// ///// ///////////////////////////////
// Rutina: unsigned int Calcula
teLux(unsigned int ch0, unsigned int ch0, int iType)
//
// Descripción: Calcula la iluminancia aproximada (lux) dada la bruto
// valores de canal del TSL2560. La ecuación si se implementa
// como una aproximación lineal por partes
//
// Argumentos. : ganancia int iGain sin signo, donde 0: 1X, 1: 16X
// tiempo de integración int sin signo, donde 0: 13,7 mS, 1: 100 mS, 2: 402 mS,
<. p> // 3: Manual// unsigned int ch0 . valor de canal sin procesar del canal 0 de TSL2560
// unsigned int ch1 valor de canal sin procesar del canal 1 de TSL2560 <. /p >
// unsigned int iType . tipo de paquete (T o CS)
//
// Devolución: unsigned int la iluminancia aproximada (lux)
//
///////////////////////////////////// //// //////////////////////////////////////////////p>
unsigned int CalculateLux (unsigned int iGain, unsigned int tInt, unsigned int ch0, unsigned int ch1, int iType)
{
unsigned long ratio1
relación larga sin firmar;
temp larga sin firmar;
lux largo sin firmar;
chScale largo sin firmar; canal1; //TSL2561
unsigned long canal0; //TSL2561
unsigned int b, m
//....... .................................................... .................. ........
// primero, escale los valores del canal dependiendo de la ganancia y el tiempo de integración
// 16X, 402mS es nominal
// escale si el tiempo de integración NO es. 402 ms
switch (tInt)
{
caso 0: // 13,7 ms
chScale = CHSCALE_TINT0
;descanso;
caso 1: // 101 ms
chScale = CHSCALE_TINT1;
descanso
predeterminado: // asumir que no hay escala
chScale = (1 lt; lt; CH_SCALE);
break
}
// escalar si se gana; NO es 16X
if (!iGain) chScale = chScale lt 4; // escala de 1X a 16X
// escala los valores del canal
canal0 = (ch0 * chEscala) gt; CH_SCALE;
canal1 = (ch1 * chEscala) gt; .... ................................................. ................... ............
// encuentra la proporción de los valores del canal ( Canal1/Canal0)
// protección contra división por cero
ratio1 = 0
if (canal0 != 0) ratio1 = (canal1 lt; lt ; (RATIO_SCALE 1)) / canal0;
// redondea el valor de la relación
relación = (ratio1 1) gt; es la relación lt; = eachBreak
switch (iType)
{
caso 0: // paquete T <
/p>
if ((ratio gt; = 0) amp; amp; (ratio lt; = K1T))
{b=B1T; m=M1T;}
else if (ratio lt; = K2T)
{b=B2T; m=M2T;}
else if (ratio lt;= K3T)
{b=B3T; m=M3T;}
si (relación lt; = K4T)
{b=B4T; m=M4T;}
else if (ratio lt;= K5T)
{b=B5T; m=M5T;}
else if (ratio lt;= K6T)
{ b=B6T; m=M6T;}
más si (relación lt;= K7T)
{b=B7T; m=M7T;}
más if (ratio gt; K8T)
{b=B8T; m=M8T;}
break
caso 1: // paquete CS
/*
if ((relación gt; = 0) amp; amp; (relación lt; = K1C))
{b=B1C; m=M1C; }
si (relación lt;= K2C)
{b=B2C; m=M2C;}
si (relación lt;= K3C)
{b=B3C; m=M3C;}
si no (relación lt; = K4C)
{b=B4C;m=M4C;}
else if (relación lt;= K5C)
{b=B5C; m=M5C;}
else if (relación lt;= K6C)
{b=B6C; m=M6C;}
else if (relación lt; = K7C)
{b=B7C; m=M7C;}
else if (relación gt; K8C)
{b=B8C; m=M8C;}
*/
descanso
}
temp = ((canal0 * b)- (canal1 * m));
// no permitir valor de lux negativo
si (temp lt; 0) temp = 0;
// redondo lsb (2^(LUX_SCALE.1))
temp = (1 lt; lt; (LUX_SCALE-1)
// quitar la porción fraccionaria
lux = temp gt; LUX_SCALE
return(lux); }
/****************************************** * *****************************************
* Nombre: GetLux( )
* Función: Iniciar operación I2C
* Parámetro de entrada: Ninguno
* Parámetro de salida: Ninguno
***** ********************************************** ****** *************************/
INT GetLux(void)
{
INT i;
i=0;
CH0=TSL2561_read_byte(REG_CH0_L);
CH0=CH0 TSL2561_read_byte(REG_CH0_H) *256;
CH1=TSL2561_read_byte(REG_CH1_L);
CH1=CH1 TSL2561_read_byte(REG_CH1_H)*256;
i=CalculateLux(GAIN_1X, ITIME_400MS, CH0 , CH1, FootType_T);
retorno (i);