¿Cómo controla el microcontrolador 51 el sensor ultrasónico? ¿Busca un programa en lenguaje C (debe ser utilizable) 100 adicionales?

//Módulo ultrasónico ME007 programa de visualización

//Oscilador de cristal=8M

//MCU=STC10F04XE

//P0. 0 -P0.6*** Pin de tubo digital Yang

//Trig = P1^0

//Echo = P3^2

#include < reg52.h> //Incluye un archivo de encabezado para el kernel estándar 52

#define uchar unsigned char //Defínelo para facilitar su uso

#define uint unsigned int

#define ulong unsigned long

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

sfr CLK_DIV = 0x97 //Definición del microcontrolador STC, división de frecuencia del reloj del sistema

<; p> //Es el puerto IO del microcontrolador STC Establece la definición de dirección

sfr P0M1 = 0X93;

sfr P0M0 = 0X94;

sfr P1M1 = 0X91 ;

sfr P1M0 = 0X92 ;

sfr P2M1 = 0X95;

sfr P2M0 = 0X96;

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

sbit Trig = P1^0; //Generar pin de disparo de pulso

sbit Echo = P3^2; //Pin de eco

sbit test = P1^1; /p>

uchar code SEG7[10]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};//Tubo digital 0-9

uint distancia[4]; //Mida la distancia desde el búfer de recepción

uchar ge,shi,bai,temp,flag,outcomeH,outcomeL,i //Registro personalizado

bit Success_flag; //Indicador de éxito de la medición

//********Declaración de función

void conversion(uint temp_data);

void delay_20us();

//void pai_xu();

void main(void) // Programa principal

{ uint Distance_data,a,b;

uchar CONT_1;

p>

CLK_DIV=0X03; //El reloj del sistema es un oscilador de cristal de 1/8 (pdf-45 páginas)

P0M1 = 0; /Configurar el puerto io como salida push-pull

P1M1 = 0;

P2M1 = 0;

P0M0 = 0XFF;

P1M0 = 0XFF;

P2M0 = 0XFF;

i=0;

bandera=0;

prueba =0;

Trig=0; //Primero baja los pines de entrada de pulso

TMO

D=0x11; //Temporizador 0, temporizador 1, modo de trabajo de 16 bits

TR0=1; //Iniciar temporizador 0

IT0=0; cambia a nivel bajo, activando una interrupción externa

ET0=1; //Activa la interrupción del temporizador 0

//ET1=1 //Activa la interrupción del temporizador 1<; /p> p>

EX0=0; //Desactivar interrupciones externas

EA=1; //Activar interrupción total 0

while(1) //Programa bucle

{

EA=0;

Trig=1;

delay_20us();

Trig =0; // Genera un pulso de 20us en el pin Trig

while(Echo==0); //Espera a que el pin Echo alcance nivel alto

Success_flag=0; // Borrar indicador de éxito de medición

EX0=1; //Activar interrupción externa

TH1=0; //Borrar temporizador 1

TL1=0; //Borrar temporizador 1

TF1=0; //

TR1=1; //Iniciar temporizador 1

EA=1;

while(TH1 < 30); //Esperando el resultado de la medición, el período es 65.535 milisegundos (se puede implementar mediante interrupción)

TR1=0 //Cerrar el temporizador 1

EX0=0; //Desactivar interrupciones externas

if(succeed_flag==1)

{

Distance_data=outcomeH; del resultado de la medición

distancia_data<<=8; //Coloque los 8 bits superiores de 16 bits

distancia_data=distance_data|outcomeL;//Fusionar con los 8 bits bajos para formar datos de resultado de 16 bits

p>

Distance_data*=12; //Porque el temporizador se divide por defecto entre 12

Distance_data/=58; microsegundos divididos por 58 son centímetros

} //Por qué divididos por 58 son centímetros, Y metros = (X segundos * 344) / 2

// X segundos = (2*Y metros) / 344 ==》X segundos = 0.0058*Y Metros==》Centímetros=microsegundos/58

if(succeed_flag==0)

{

distancia_data=0; //Borrar si no hay eco Cero

test = !test;

//Pruebe los cambios de luz

}

/// distancia[i]=distance_data; //Coloque los datos del resultado de la medición en el búfer

// / i++;

/// if(i==3)

/// {

/// distancia_datos=(distancia[0]+distancia [ 1]+distancia[2]+distancia[3])/4;

/// pai_xu();

/// distancia_data=distancia[1];

a=distancia_datos;

if(b==a) CONT_1=0;

if(b!=a) CONT_1++;

si (CONT_1>=3)

{ CONT_1=0;

b=a;

conversión(b);

}

/// i=0;

/// }

}

}

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

//Interrupción externa 0, utilizada para determinar el nivel de eco

INTO_() interrupción 0 //La interrupción externa es No 0

{

resultH =TH1; //Obtener el valor del temporizador

resultL =TL1 //Obtener el valor del temporizador

Success_flag=1; //Marcar para medición exitosa

EX0=0; //Cerrar interrupción externa

}

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

//La interrupción del temporizador 0 se utiliza para la visualización

timer0() interrupción 1 //La interrupción del temporizador 0 es la número 1

{

TH0=0xfd; //Escribe el valor inicial del temporizador 0

TL0=0x77

switch(flag)

{caso 0x00:P0=ge; P2=0xfd;flag++;romper;

caso 0x01:P0=shi;P2=0xfe;flag++;romper;

caso 0x02 :P0=bai;P2=0xfb;flag=0;romper;

}

}

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

/*

//Interrupción del temporizador 1, utilizada para temporización de alcance ultrasónico

interrupción 3 del temporizador1() // Interrupción del temporizador 0 es el número 1

{

TH1=0;

>

TL1=0;

}

*/

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

//Mostrar programa de conversión de datos

void conversion(uint temp_data)

{

uchar ge_data,shi_data,bai_data ;

p>

bai_data=temp_data/100;

temp_data=temp_data%100; //operación restante

shi_data=temp_data/10;

temp_data =temp_data%10; //Operación restante

ge_data=temp_data;

bai_data=SEG7[bai_data];

shi_data= SEG7[shi_data];

ge_data =SEG7[ge_data];

EA=0;

bai = bai_data;

shi = shi_data;

ge = ge_data

EA=1;

}

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

void delay_20us()

{ uchar bt ;

for(bt=0;bt<100;bt++) ;

}

/*

void pai_xu()

{ uint t;

if (distancia [0]>distancia[1] )

{t=distancia[0];distancia[0]=distancia[1];distancia[1]=t;} /*Valores de intercambio

if(distancia[0 ]>distancia[2])

{t=distancia[2];distancia[2]=distancia[0];distancia[0]=t;} /* Valores de intercambio

if(distancia[1]>distancia[2])

{t=distancia[1];distancia[1]=distancia[2];distancia[2] =t;} /*Valores de intercambio

}

*/

Uno de mis procedimientos de ultrasonido

Tengo preguntas, por favor pregunte ~~

/ /Programa de visualización del módulo ultrasónico

#include //Incluye un archivo de encabezado para el kernel estándar 52

#include< intrins.h> //Incluye _nop_() Archivo de encabezado para la definición de función

#define uchar unsigned char //Defínelo por conveniencia

#define uint unsigned int

#define ulong unsigned long

sbit Tx = P3^3 //Generar pin de pulso

s;

bit Rx = P3^2; // pin de eco

sbit RS=P2^0; //Registra el bit de selección, define el bit RS como el pin P2.0

sbit RW =P2^1; // Lee y escribe el bit de selección, define el bit RW como el pin P2.1

sbit E=P2^2 // Habilita el bit de señal, define el bit E como P2. 2 pines

sbit BF=P0^7; //Bit de indicador de ocupado, define el bit BF como pin P0.7

cadena de código de caracteres sin firmar[]= {"CHAO SHENG BO "};

//código de caracteres sin firmar string1[ ]={"QUICK STUDY MCU"};

dígito de código de caracteres sin firmar[ ]={"0123456789" }; //Definir matriz de caracteres para mostrar números

//uchar code SEG7[10]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};//Digital Pipe 0-9

uint Distance[4]; //Rango del buffer de recepción

uchar ge,shi,bai,temp,flag,outcomeH,outcomeL,i // Registro personalizado

bit Success_flag; //Indicador de medición exitosa

//********Declaración de función

Conversión nula (uint temp_data);

void delay_20us();

void pai_xu();

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

Función de función: retardo 1ms

(3j+2)*i=(3×33+2)×10=1010 (microsegundo), que puede considerarse como 1 milisegundo

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

nulo delay1ms()

{

unsigned char i,j

for(i=0;i<10;i++)

for(j=0;j<33;j++)

}

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

Función función: Retardo durante un número de milisegundos

Parámetro de entrada: n

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

retraso nulo (carácter n sin firmar)

{

carácter sin firmar i;

for(i=0;i

delay1ms();

}

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

Función: Determina el estado de ocupado del módulo LCD

Valor de retorno: resultado.

resultado=1, ocupado; resultado=0, no ocupado

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

carácter sin firmar BusyTest(void)

{

resultado del bit;

RS=0; //Según las regulaciones, cuando RS es de nivel bajo y RW es de nivel alto, se puede leer el estado

RW=1;

E=1; //E=1, se permite lectura y escritura

_nop_(); //Sin operación

_nop_ ();

_nop_( );

_nop_(); //Cuatro ciclos de máquina sin operación para dar el tiempo de reacción del hardware

result=BF ; //Asignar el nivel de indicador de ocupado al resultado

E=0; //Restaurar E al nivel bajo

devolver resultado;

}

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

Función: escribir el comando de configuración del modo o mostrar la dirección en el módulo LCD

Parámetro de entrada: dictar

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

void WriteInstruction (dictado de caracteres sin firmar)

{

while(BusyTest()==1); //Espera si está ocupado

RS =0; // De acuerdo con las regulaciones, RS y R cuando /W tiene un nivel bajo al mismo tiempo, puede escribir instrucciones

RW=0;

E=0; /E se establece en un nivel bajo (de acuerdo con la Tabla 8-6, escriba instrucciones Cuando, E es un pulso alto,

// Esto es para hacer que E haga una transición positiva de 0 a 1, entonces " Primero se debe configurar 0"

_nop_();

_nop_(); //Dos ciclos de máquina de operación en vacío para darle tiempo de reacción al hardware

P0 =dictar; //Enviar datos al puerto P0, es decir, escribir instrucciones o direcciones

_nop_();

_nop_();

_nop_( );

_nop_(); //Sin operación durante cuatro ciclos de la máquina, lo que da tiempo de respuesta al hardware

E=1 //E está configurado en nivel alto

<; p> _nop_();

_nop_();

_nop_();

_nop_(); //Cuatro ciclos de máquina sin operación para dar el tiempo de reacción del hardware

E=0; //Cuando E salta del nivel alto a Cuando el nivel es bajo, el módulo LCD comienza a ejecutar comandos

}

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

Función: Especificar la dirección real de visualización de caracteres

Parámetros de entrada: x

****** ************************************* *

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

void WriteAddress(unsigned char x)

{

WriteInstruction(x|0x80); /El método para determinar la posición de visualización es "80H+código de dirección x"

}

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

Función función: convertir datos (ASCII estándar código de caracteres) escrito en el módulo LCD

Parámetro de entrada: y (constante de carácter)

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

void WriteData(carácter sin firmar)

{

while(BusyTest()==1);

RS=1; //Cuando RS es de nivel alto y RW es de nivel bajo, los datos pueden escribir

RW=0;

E=0; //E se establece en un nivel bajo (según la Tabla 8-6, al escribir instrucciones, E es un pulso alto,

// Es para hacer que E haga una transición positiva de 0 a 1, por lo que primero se debe establecer "0"

P0=y //Enviar los datos al P0; puerto, es decir, escribir los datos en el módulo de cristal líquido

_nop_();

_nop_();

_nop_();

_nop_(); //Sin operación durante cuatro ciclos de la máquina, proporcione el tiempo de reacción del hardware

E=1; //Establezca E en nivel alto

_nop_();

_nop_();

_nop_();

_nop_(); //Cuatro ciclos de máquina sin operación para darle tiempo de reacción al hardware

E=0; //Cuando E salta del nivel alto Cuando pasa al nivel bajo, el módulo LCD comienza a ejecutar el comando

}

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

Función: Inicializar el modo de visualización LCD

p>

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

void LcdInitiate(void)

{

delay(15); //Retraso de 15 ms, debe usarse al escribir instrucciones por primera vez. Dale a la pantalla LCD un tiempo de respuesta más largo

WriteInstruction(0x38); //Configuración del modo de visualización: pantalla de 16 × 2, matriz de puntos de 5 × 7, interfaz de datos de 8 bits

delay( 5); //Retraso de 5 ms, dale al hardware algo de tiempo de reacción

WriteInstruction(0x38);

delay(5);

WriteInstruction(0x38); //Tres veces consecutivas para garantizar una inicialización exitosa

delay(5) );

WriteInstruction(0x0c); //Configuración del modo de visualización: visualización activada, sin cursor, cursor no parpadeante

retardo(5);

WriteInstruction( 0x06); //Configuración del modo de visualización: el cursor se mueve hacia la derecha, carácter

No mover

delay(5);

WriteInstruction(0x01); //Borrar instrucción de pantalla para borrar el contenido de la pantalla anterior

delay(5);

}

void main(void) // Programa principal

{ uint Distance_data,a,b;

uchar CONT_1; /p>

uchar k; //Defina la variable i para que apunte al elemento de la matriz de cadenas

LcdInitiate() //Llame a la función de inicialización de LCD

delay(10) ; // Retrasa 10 ms para darle al hardware algo de tiempo de reacción

WriteAddress(0x01); //Comienza a mostrar desde la fila 1 y la columna 3

k = 0; Tercera columna de la matriz de caracteres 1 elemento

while(string[k] != '\0')

{

WriteData(string[k]) ;

k++; //Apunta a un elemento de la matriz de caracteres inferior

}

i=0;

flag=0 ;

Tx=0; //Primero baja el pin de entrada de pulso

TMOD=0x10 //Temporizador 0, temporizador 1, modo de trabajo de 16 bits

<; p>// TR0=1 ; //Inicia el temporizador 0

IT0=0; //Cambia del nivel alto al nivel bajo, activa una interrupción externa

//ET0=1; //Abrir interrupción del temporizador 0

EX0=0; //Desactivar interrupciones externas

EA=1; //Activar interrupción total 0

while( 1) // Bucle del programa

{

WriteAddress(0x41); //Comienza a mostrar desde la fila 2 y la columna 6

WriteData('J'); //Cambia los diez mil dígitos Escribe constantes de caracteres numéricos en LCD

WriteData('U'); //Escribe constantes de caracteres de 10,000 dígitos en LCD

WriteData('L') ; //Escribe constantes de caracteres numéricos en LCD Escribe constantes de caracteres con decenas de miles de dígitos en LCD

WriteData('I'); //Escribe constantes de caracteres con decenas de miles de dígitos en LCD

WriteData(':'); //Escribe constantes de caracteres con decenas de miles de dígitos en LCD

WriteData(digit[bai]); //Escribe constantes de caracteres con decenas de miles de dígitos en LCD

p>

WriteData(digit[shi ]); //Escribe constantes de caracteres con miles de dígitos en LCD

WriteData('.'); //Escribe constantes de caracteres con decenas de miles de dígitos en LCD

WriteData( digit[ge]); //Escribe constantes de caracteres con centenas de dígitos en LCD

WriteData(' '); >

WriteData('C'); //Escribe constantes de caracteres con decenas de miles de dígitos en LCD

WriteData('M'); //Escribe constantes de caracteres con decenas de miles de dígitos en LCD

EA=0;

T

x=1;

delay_20us();

Tx=0; //Genera un pulso de 20us en el pin Tx

while(Rx== 0) ; //Esperar a que el pin de eco de Rx suba.

Success_flag=0; //Borrar el indicador de éxito de medición

EX0=1 //Activar la interrupción externa

p>

TH1=0; //Borrar el temporizador 1

TL1=0; //Borrar el temporizador 1

TF1=0; TR1=1; //Inicia el temporizador 1

EA=1;

while(TH1 < 30); //Esperando el resultado de la medición, el período es de 65,535 milisegundos (interrupciones disponibles). )

TR1=0; //Apagar el temporizador 1

EX0=0; //Apagar las interrupciones externas

if(succeed_flag==1 )

{

distancia_data=outcomeH; //8 bits altos del resultado de la medición

distancia_data<<=8; 16 bits bit

distancia_data=distance_data|outcomeL;//Combinado con los 8 bits inferiores para formar datos de resultado de 16 bits

distancia_data*=12;//Porque el temporizador está predeterminado en dividir por 12

distancia_data/=58; //La unidad de microsegundos dividido por 58 es igual a centímetros

} //Por qué dividido por 58 es igual a centímetros, Y metros = (X segundos * 344)/2

// X segundos = (2*Y metros)/344 ==》 0)

{

distancia_datos=0; Borrar si no hay eco

}

Distance[i]=distance_data ; //Coloca los datos del resultado de la medición en el buffer

i++;

if(i==3)

{

distancia_datos=(distancia[0]+distancia[1]+distancia[2]+distancia[3])/ 4;

pai_xu();

distancia_datos=distancia[1] ;

a=distancia_datos;

si(b==a) CONT_1=0;

si(b!=a) CONT_1++;

si(CONT_1>=3)

{ CONT_1 =0;

b=a;

conversión(b);

}

i=0;

}

}

}

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

// Interrupción externa 0, utilizada para juzgar el nivel de eco

INTO_() interrupción 0 // La interrupción externa es el número 0

{

resultH =TH1 ; / /Obtener el valor del temporizador

resultL =TL1; //Obtener el valor del temporizador

Success_flag=1 //Marcar para medición exitosa

EX0 =0; //Desactivar interrupciones externas

}

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

//Interrupción del temporizador 0, utilizada para visualización

interrupción 1 del timer0() // La interrupción del temporizador 0 es el número 1

{

// TH0 =0xfd; // Escribe el valor inicial del temporizador 0

// TL0=0x77

}

//Mostrar programa de conversión de datos

conversión nula (uint temp_data)

{

uchar ge_data,shi_data,bai_data ;

bai_data=temp_data/100 ;

temp_data=temp_data% 100; //Operación restante

shi_data=temp_data/10;

temp_data=temp_data%10; //Operación restante

ge_data= temp_data;

//bai_data=SEG7[bai_data];

//shi_data=SEG7[shi_data]&0x7f;

//ge_data =SEG7[ge_data] ;

EA=0;

bai = bai_data;

shi = shi_data;

ge = ge_data

<; p> EA =1;

}

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

void delay_20us()

{ uchar bt ;

for(bt=0;bt<60;bt++);

}

void pai_xu()

{ uint t;

si

(distancia[0]>distancia[1])

{t=distancia[0];distancia[0]=distancia[1];distancia[1]=t;}

if(distancia[0]>distancia[2])

{t=distancia[2];distancia[2]=distancia[0];distancia[0]=t;}

if(distancia[1]>distancia[2])

{t=distancia[1];distancia[1]=distancia[2];distancia[2]=t;}

}

El primero debe modificarse, ¡también puedes probar esto! Primero debes entender esto y modificar el pin... se mostrará como 1602