cjoint

Publicité


Publicité

Format du document : text/plain

Prévisualisation




/************************************************ **************** / /
/ / Série AM de lecture simples exemples d'utilisation de bus
/ / MCU: AT89S52 ou STC89C52RC
/ / Fonction: température de transmission série et d'humidité Vitesse de transmission 9600
/ / Crystal: 12M (horloge système de l'utilisateur si ce n'est 12M veuillez modifier le temps de retard définitions de macros liées et commentaires)
/ / L'environnement de compilation: Keil3
/ /: Okumatsu électronique
/ / ************************************************ ****************/
#include "REG52.H"
#include "INTRINS.H"


//L'utilisateur en fonction de leur propre cristal modifier la valeur correspondante
#define FOSC 12000000
#define BAUD 9600

//Lisez la définition peu capteur de port, peut être modifié
sbit Sensor_SDA = P0^0;
sbit Sensor_SCL = P0^1;

// Les variables définies
unsigned char Sensor_Data[5]={0x00,0x00,0x00,0x00,0x00};
unsigned char Sensor_Check; //checksum
unsigned char Sensor_AnswerFlag; //recevoir drapeau de départ
unsigned char Sensor_ErrorFlag; //lecture de l'indicateur d'erreur de capteur
unsigned int Sys_CNT;
unsigned int Tmp;
unsigned char * String;

//String définition
#define S_Temp "Temp:"
#define S_RH "RH:"
#define S_CRCT "Check: True"
#define S_CRCF "Check: Wrong"
#define S_Data "Data: "
#define S_NotS "Sensor Not Connected"

/******************************************** \
* Fonctions: cristal retard à 12M * |
* T = 1 pour 20us 10us ensuite doublé * |
\ ****************************/
void Delay_N10us(unsigned char t)
{
while(t--)
{
_nop_();
}
}

/********************************************\
|* Fonctions: cristal retard à 12M * |
| * Retard environ 1ms * *|
\********************************************/
void Delay_N1ms(unsigned int t)
{
unsigned int i;
unsigned int j;
for(j=t;j>0;j--)
for(i=124;i>0;i--); //retard environ 1ms
}

/********************************************\
|* Fonction: initialiser le port série *|
\********************************************/
void InitUART(void)
{
unsigned int iTmpBaud;
unsigned long lTmpBaud;
iTmpBaud = 0;
//First Timer sélectionner 2 en tant que générateur de bauds, 16-bit de temporisation, le chargement automatique
SCON = 0x50; //SM0 SM1 SM2 REN TB8 RB8 TI RI //0 1 0 1 0 0 0 0
PCON = 0x00; //adresse du PCON 87H,SMOD =0

T2CON = 0x30; //TF2 EXF2 RCLK TCLK EXEN2 TR2 C(/T2) CP(/RL2) //0 0 1 1 0 0 0 0
T2MOD = 0x00; // / / / / / / T2OE DCEN //0 0 0 0 0 0 0 0

lTmpBaud = FOSC/BAUD;
lTmpBaud /= 32; //12T-mode
iTmpBaud = lTmpBaud & 0xFFFF;
iTmpBaud = 65536 - iTmpBaud;
RCAP2H = (iTmpBaud>>8) & 0x0FF;
RCAP2L = iTmpBaud & 0x0FF;

RI = 0; //efface le drapeau d'interruption recevoir
REN = 1; //Autoriser réception série
ES = 1; //permettent d'interruption série
TR2 = 1; //start timer 1

EA=1;//interruption totale ouverte
}

/********************************************\
|* Fonction: serial fonction d'envoi *|
\********************************************/
void UARTSend(char UCHAR)
{
SBUF=UCHAR;
while(TI==0);
TI=0;
}

/********************************************\
|* Fonction: Fonction d'interruption série *|
\********************************************/
void UARTRead(void) interrupt 4
{
char temp;
if(RI)
{
RI=0;
temp = SBUF;
}
}

/********************************************\
|* Fonction: série sous-fonction d'envoi *|
\********************************************/
void UART_PutString(unsigned char *buf)
{
while(*buf)
UARTSend(*buf++);
}
void UART_PutStringAndNum(unsigned char *buf ,unsigned int num)
{
unsigned char a[3],i;
a[3] = '0'+num%10;
a[2] = '.';
a[1] = '0'+num/10%10;
a[0] = '0'+num/100%10;
while(*buf)
UARTSend(*buf++);
UARTSend(' ');
for(i=0;i<4;i++)
{
UARTSend(a[i]);
}
}
void UART_PutStringAnd_Data(unsigned char *buf ,unsigned char *bufdata)
{
unsigned char a[2],i,j;
while(*buf)
UARTSend(*buf++);
UARTSend(' ');
for(i=0;i<5;i++)
{
a[0] = bufdata[i]/16;
a[1] = bufdata[i]%16;
for(j=0;j<2;j++)
{
if(a[j]>9)
{
a[j] = (a[j]-10)+'A';
}
else
{
a[j] = a[j]+'0';
}
UARTSend(a[j]);
}
UARTSend(' ');
}
}

/********************************************\
|* Fonction: port série pour envoyer des données de capteurs fonctions *|
\********************************************/
void UARTSend_Nbyte(void)
{
if(Sensor_AnswerFlag == 1)
{
Sensor_Check = Sensor_Data[0]+Sensor_Data[1]+Sensor_Data[2]+Sensor_Data[3];
//Contrôler le succès
if(Sensor_Check ==Sensor_Data[4])
{
String = S_RH;//"RH:";
Tmp = Sensor_Data[0]*256+Sensor_Data[1];
UART_PutStringAndNum(String,Tmp);
UARTSend(' ');
UARTSend(' ');

String = S_Temp;// "Temp:";
Tmp = Sensor_Data[2]*256+Sensor_Data[3];
UART_PutStringAndNum(String,Tmp);
UARTSend(' ');
UARTSend(' ');

String = S_CRCT;//"Check: True";
UART_PutString(String);
}else //échec de la validation
{
String = S_Data;//"Data: ";
UART_PutStringAnd_Data(String,Sensor_Data);
UARTSend(' ');
UARTSend(' ');
String = S_CRCF;//"Check: Wrong";
UART_PutString(String);
}
}// Capteur n'est pas connecté
else
{
String = S_NotS; //"Sensor Not Connected";
UART_PutString(String);
}
UARTSend(0x0A);

}
void Clear_Data (void)
{
int i;
for(i=0;i<5;i++)
{
Sensor_Data[i] = 0x00;
}//Réception de données effacées
}


/********************************************\
|* Fonction: lisez le capteur envoie un seul octet *|
\********************************************/
unsigned char Read_SensorData(void)
{
unsigned char i,cnt;
unsigned char buffer,tmp;
buffer = 0;
for(i=0;i<8;i++)
{
cnt=0;
while(!Sensor_SDA) //détecter la fin de la dernière de bas
{
if(++cnt >= 300)
{
break;
}
}
//retard Min=26us Max50us Passer le niveau élevé de données"0"
Delay_N10us(2); //retard 30us

//Déterminer capteurs envoient des bits de données
tmp =0;
if(Sensor_SDA)
{
tmp = 1;
}
cnt =0;
while(Sensor_SDA) //fin de l'attente d'un niveau élevé
{
if(++cnt >= 200)
{
break;
}
}
buffer <<=1;
buffer |= tmp;
}
return buffer;
}

/********************************************\
|* Lecture du capteur *|
\********************************************/
unsigned char Read_Sensor(void)
{
unsigned char i;
//(Min=800US Max=20Ms)
Sensor_SDA = 0;
Delay_N1ms(2); //delais 2Ms

//libere le delais du bus (Min=30us Max=50us)
Sensor_SDA = 1;
Delay_N10us(1);//delais 30us
//Hôte est défini pour entrer un signal de réponse jugement capteur
Sensor_SDA = 1;

Sensor_AnswerFlag = 0; // etat de reponce

//Déterminer si l'esclave ne répond pas à un niveau bas en réponse à des signaux tels que vous sautez, délabré réponse
if(Sensor_SDA ==0)
{
Sensor_AnswerFlag = 1;//réception du signal de début
Sys_CNT = 0;
//Déterminer si le problème esclave 80US signal de faible niveau de réponse plus
while((!Sensor_SDA))
{
if(++Sys_CNT>300) //éviter entrer dans une boucle infinie
{
Sensor_ErrorFlag = 1;
return 0;
}
}
Sys_CNT = 0;
//Déterminer s'il convient de délivrer un esclave question 80US haut niveau tel est l'accès à la réception de données d'état
while((Sensor_SDA))
{
if(++Sys_CNT>300) //éviter entrer dans une boucle infinie
{
Sensor_ErrorFlag = 1;
return 0;
}
}
/*Les données du capteur de réception pour envoyer un total de 40 données
5 bytes élevés d'abord envoyé 5 octets sont une humidité élevée, une humidité élevée, faible calibrage de la température à basse température
Somme de contrôle: taux d'humidité élevé la faible humidité + + + température élevée à basse température*/

for(i=0;i<5;i++)
{
Sensor_Data[i] = Read_SensorData();
}
}
else
{
Sensor_AnswerFlag = 0; // n'a pas reçu la réponse du capteur
}
return 1;
}

void main(void)
{
Sensor_SCL = 0;
InitUART(); //la fonction initiale de série d'envoi
while(1)
{
Clear_Data(); // efface les données de réception
Read_Sensor(); // lire les données des capteurs
UARTSend_Nbyte(); // série pour envoyer les données de capteur de lecture
Delay_N1ms(2000); // retard (lu deux fois à des intervalles d'au moins 2S)
}
}


Publicité


Signaler le contenu de ce document

Publicité