Red de conocimiento informático - Problemas con los teléfonos móviles - tsl2561

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);