El nivel del autor de este artículo aún es limitado. Si hay algo mal, espero su corrección.
Me refiero a algunos artículos.Muchos bloggers usan stm32 como la computadora inferior para el control, pero aún no lo he tocado, así que uso una microcomputadora de un solo chip 51.
Surgió una idea, hacer un coche inteligente para recoger tenis, comenzar con el brazo robótico, y hay muchos detalles en el brazo robótico, y gradualmente superar los problemas uno por uno.
La visión del brazo robótico visual K210 :
La cámara K210 está fija y los elementos que se van a capturar también están fijos
El extremo C51 utiliza el sistema de microcomputadora de un solo chip más pequeño para controlar el mecanismo de dirección.Un brazo robótico se compone de múltiples mecanismos de dirección ("articulaciones de brazo").
Principio de funcionamiento: K210 reconoce el objeto a recoger y transmite las coordenadas horizontales y verticales (X, Y) del objeto a recoger a la microcomputadora de un solo chip 51. Los valores de X e Y se calculan matemáticamente para controlar la traducción hacia arriba, abajo, izquierda y derecha del mecanismo de dirección para alcanzar la posición de destino se da cuenta de la función de sujeción.
El diagrama conceptual es el siguiente:
Lo anterior es una imaginación general, paso a paso, este artículo solo habla de cómo realizar la comunicación entre C51 y K210, realizar la transmisión de coordenadas y recibirlas.
k210 enviar datos:
from machine import UART,Timer
from fpioa_manager import fm
import time
fm.register(6, fm.fpioa.UART1_RX, force=True)
fm.register(7, fm.fpioa.UART1_TX, force=True)
hengzuobiao = 256
zongzuobiao = 257
class K210_transmit():
head1 = 0xAA
x = hengzuobiao
y = zongzuobiao
head2 = 0xAA
mo = 0xab
K210 = K210_transmit()
def K210_data():
data=bytearray([K210.head1,
K210.x>>8,K210.x,
K210.y>>8,K210.y,
K210.head2,K210.mo])
return data
uart = UART(UART.UART1, 9600, read_buf_len=4096)
while True:
uart.write(K210_data()) #数据回传
time.sleep(1)Los valores de las coordenadas se dan primero directamente: hengzuobiao = 256 zongzuobiao = 257. Primero realizamos la comunicación, y luego hacemos el final del K210 para devolver las coordenadas del objeto reconocido.
Análisis de código: k210 puede mapear pines libremente, configuro el pin 6 como RXD y el pin 7 como TXD. Se define una clase para guardar la información a ser enviada por el puerto serie. Diseñe head1 = 0xAA y mo = 0xab para "recortar" los datos centrales, de modo que en el extremo 51 podamos juzgar si se ha recibido esta cadena de datos.
uart = UART(UART.UART1, 9600, read_buf_len=4096)La configuración inicial del puerto serial, k210 tiene dos puertos seriales, este es el puerto serial 1, la tasa de baudios está configurada en 9600, porque el módulo bluetooth HC-05 enviado por mí no ha sido modificado internamente, siempre ha sido 9600 , para mantener la consistencia. (HC-05 bluetooth se usa en pruebas posteriores), uart.write() se usa para enviar.
Experiencia experimental: paso a paso, cuando llegamos a este paso, nos preocupa un poco si los datos enviados ahora son el valor del código anterior. ¿Este envío salió mal? Primero confirme que el envío de este paso es correcto, para que cuando construyamos lentamente el siguiente paso de recepción, no tengamos que buscar el problema del envío antes; aquí uso el módulo Bluetooth HC-05 para probar el envío de datos. El uso del módulo Bluetooth HC-05 es muy fácil de comenzar. Si tiene alguna pregunta, puede consultar mi artículo: La microcomputadora de un solo chip C51 usa el módulo Bluetooth HC-05 para realizar la iluminación del teléfono móvil_Blog de Liangchen353
Inicie y ejecute el programa en el lado del K210, el diagrama de cableado y el diagrama de fenómenos son los siguientes:
¡Se puede ver por el fenómeno que los datos se envían con éxito! ¡Nuestros datos básicos están adentro! X = 01 * 256 + 00 = 256; Y = 01 * 256 + 01 = 257
Se puede ver que cada uno de nuestros paquetes de datos enviados son siete bits de datos.
Antes de eso, me metí en un hoyo, porque k210 solo puede enviar cadenas al enviar datos, es decir, uart.write(), y enviar directamente 256, 257 no se puede enviar. Luego, la idea es convertir 257, 257 en "256", "257", enviarlo y extraer el número entero, pero en el extremo 51, la función atoi() no se usa, esta es una función que puede convertir un carácter a un número entero, se puede usar en el compilador de C y le recordará que hay un archivo menos en Keil. También puede encontrarlo en línea, todos los cuales se descargan por una tarifa. Están empaquetados juntos y son todos enteros. En el lado 51, está bien hacer un cálculo de multiplicar por 256, ¡lo cual es muy bueno!
C51 recibe datos:
#include <REGX52.H>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#define MAX_SIZE 8
unsigned char Buffer[MAX_SIZE];
unsigned char dat;
unsigned int x,y;
unsigned int Receive_count = 0;
void UART_init()
{
TMOD = 0x20;
TH1 = 0xfd;
TL1 = 0xfd;
SM0 = 0;
SM1 = 1;
REN = 1;
TR1 = 1;
EA = 1;
ES =1 ;
}
void UART_SendByte(unsigned char Byte)
{
SBUF = Byte;
while(TI == 0);
TI = 0;
}
char putchar(char c)//閲嶅畾鍚?
{
UART_SendByte(c);
return c;
}
void main()
{
UART_init();
while(1)
{
}
}
void UART_INTERRUPT() interrupt 4
{
dat = SBUF;
RI = 0;//手动置0是下一次能够进入中断的关键
if(dat != 0xab)//判断是否接收完成我的那串数据了？
{
Buffer[Receive_count] = dat;
Receive_count ++;
if(Receive_count == MAX_SIZE)
{
x = Buffer[1]*256+Buffer[2];
y = Buffer[3]*256+Buffer[4];
if(Buffer[0] == 0xAA && Buffer[5] == 0xAA && x == 256 && y == 257)
{
printf("the test was successful");
}
else
{
printf("the test failed!");
}
}
}
}Aquí hay un resumen de la comunicación en serie de la microcomputadora de un solo chip 51 que he aprendido:
void UART_init()
{
TMOD = 0x20;
TH1 = 0xfd;
TL1 = 0xfd;
SM0 = 0;
SM1 = 1;
REN = 1;
TR1 = 1;
EA = 1;
ES =1 ;
}Usted mismo puede generar la inicialización del puerto serie en el stc-isp, y se verifica la tasa de baudios de 9600. Este punto debe tenerse en cuenta, la comunicación entre los dos microcontroladores, la tasa de baudios debe ser consistente. Modo 1, datos de ocho bits, etc., EA, ES son interrupciones totales.
如图你可以看到51单片机串口通信的工作流程，RX和TX分别是发送数据和接收数据，比如，本来RI和TI两个管理着一个"闸门"，内部配置好的RI和TI都是0，当接收到数据时，系统会将RI自动置1，只要我们将后面的"闸门"配置好都接通，这时就是打开中断了，就可以写中断函数(51的串口通信中断是interrupt 4)，同理发送数据的时候是TI=1 ，同样地打开中断。但是寄存器SBUF一次性只能存一个字节的数据，如果像前面我们发的七个数据都想过去，就需要进入中断函数后，再手动置0,等待下一个数据发送时，RX---->致RI = 1再进中断，再提取数据。
SBUF寄存器的介绍：SBUF是用来存取数据的，在51单片机的系统内部，但dat=SBUF 和SBUF=dat是不一样的，dat = SBUF是我们自己创的一个变量dat来存装接收到的数据，SBUF=dat则是将数据发送出去，是同一个SBUF，但是功能不同，参考文章中有讲，底层配置时其实是两个的，这里不多再深探索。
定义一个数组用来存装每次传来的数据是很关键的一步，我之前以为dat = SBUF就可以一次性把数据都接来了，然后我就自以为的定义了一个dat[7]，以为数据分别装进每个[0],[1],[2]里面了，后来怎么都提不出来，因为根本就没有dat[2],dat[3]这些数！记住，我们的中断函数一次性接收到一个字节的数据后就跳出中断了，所以我们想提取出我们的核心数据，就要写个数组Buffer[]，每次接收到一个数据后就赶紧把它存进去,这时候，我们K210发送的数据mo = 0xab就有作用了，作为我们发送的一串数据的末尾，就能用来判断数据的发送完成。
void UART_SendByte(unsigned char Byte)
{
SBUF = Byte;
while(TI == 0);
TI = 0;
}
char putchar(char c)
{
UART_SendByte(c);
return c;
}这两段函数是为了实现printf函数，比如说我们写printf("Hello,world");先将寄存器SBUF为"H"，TI = 0表示接收完成，while(TI ==0);是判断是否接收完成，如果没有完成，就是TI ==0,让程序在循环里在等等，然后退出循环后，将TI打成0，等'e',进入....最后实现打印在串口通信助手上的效果，可参考之前有写的一篇51的printf()51单片机也能用printf()函数进行调试_良辰353的博客
终于到这一刻了！x,y就是我们想要的坐标值。
接线图：
一键启动发送数据
HEX显示不勾选，因为我们发的是字符串数据
波特率9600同C51同K210
外界问题总结：
烧录HEX文件时，串口调试器要关闭，因为此时是PC连了51占用了串口。
烧录时，先拔开与K210的接线，因为K210在通电，会干扰到相接的51的引脚。
现象：
