基于k210的视觉分拣机械臂

已于 2024-05-28 09:11:24 修改
阅读量1.1k 收藏 24
点赞数 31
文章标签： stm32 单片机 mcu 物联网 嵌入式硬件 计算机视觉 机器人
于 2024-05-24 12:09:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64161215/article/details/139090409
版权

视频效果

https://pan.baidu.com/s/1sMP-tNi0KWiCTKWUEM3WQg?pwd=fehs 提取码：fehs

一、 机械臂本体结构

 DH参数表 

二、机械臂运动学模型

三、机械臂运动学正反解源码 （Matlab）

正逆解模型

%% 运动学反解模型
%Z=L2*cos(j2)+L3*cos(j2+j3)+L4*cos(j2+j3+j4)+L1;
%len=L2*sin(j2)+L3*sin(j2+j3)+L4*sin(j2+j3+j4);
clc;
close all;
clear all;
syms j1 j2 j3 j4 X Y Z;
n = 0;m = 0;

X=input('输入X的坐标：');
Y=input('输入Y的坐标：');
Z=input('输入Z的坐标：');
% X=57.86;
% Y=189.24;
% Z=30.55;
    
a1 = 75.7;a2 = 132;a3 = 98.03; a4 = 146;
if (X == 0)
    j1 = 90;
else
    j1 = abs(atan((Y) / X)*(57.3));
end
for i=0:180
    j_all = 3.1415927*i / 180;
    len = sqrt((Y)*(Y) + X * X);
    high = Z;
    L = len - a4 * sin(j_all);
    H = high - a4 * cos(j_all) - a1;
    Cosj3 = ((L*L) + (H*H) - ((a2)*(a2)) - ((a3)*(a3))) / (2 * (a2)*(a3));
    Sinj3 = (sqrt(1 - (Cosj3)*(Cosj3)));
    j3 = atan((Sinj3) / (Cosj3))*(57.3);
    K2 = a3 * sin(j3 / 57.3);
    K1 = a2 + a3 * cos(j3 / 57.3);
    Cosj2 = (K2*L + K1 * H) / (K1*K1 + K2 * K2);
    Sinj2 = (sqrt(1 - (Cosj2)*(Cosj2)));
    j2 = atan((Sinj2) / (Cosj2))*57.3;
    j4 = j_all * 57.3 - j2 - j3;

    if (j2 >= 0 && j3 >= 0 && j4 >= -90 && j2 <= 180 && j3 <= 180 && j4 <= 90)
        n = n + 1;
    end
end


for i=0:180
    j_all = 3.1415927*i / 180;
    
    len = sqrt((Y)*(Y) + X * X);
    high = Z;
    
    L = len - a4 * sin(j_all);
    H = high - a4 * cos(j_all) - a1;
    
    Cosj3 = ((L*L) + (H*H) - ((a2)*(a2)) - ((a3)*(a3))) / (2 * (a2)*(a3));
    Sinj3 = (sqrt(1 - (Cosj3)*(Cosj3)));
    
    j3 = atan((Sinj3) / (Cosj3))*(57.3);
    
    K2 = a3 * sin(j3 / 57.3);
    K1 = a2 + a3 * cos(j3 / 57.3);
    
    Cosj2 = (K2*L + K1 * H) / (K1*K1 + K2 * K2);
    Sinj2 = (sqrt(1 - (Cosj2)*(Cosj2)));
    
    j2 = atan((Sinj2) / (Cosj2))*57.3;
    j4 = j_all * 57.3 - j2 - j3;

    if (j2 >= 0 && j3 >= 0 && j4 >= -90 && j2 <= 180 && j3 <= 180 && j4 <= 90)
        m = m + 1;
        if (m == n / 2 || m == (n + 1) / 2)
            break;
        end
    end
end
fprintf("\n各关节角度：\n");
fprintf("j1:%f,j2:%f\nj3:%f,j4:%f\n\n", j1, j2, j3, j4);
%% 运动学正解模型
L1 = 75.7;L2 = 132;L3 = 98.03; L4 = 146;
j1_=j1/180*pi;j2_=j2/180*pi;j3_=j3/180*pi;j4_=j4/180*pi;
X0=[1;0;0];
R1=[cos(j2_) -sin(j2_) 0;
    sin(j2_) cos(j2_) 0;
    0 0 1];
R2=[cos(j3_) -sin(j3_) 0;
    sin(j3_) cos(j3_) 0;
    0 0 1];
R3=[cos(j4_) -sin(j4_) 0;
    sin(j4_) cos(j4_) 0;
    0 0 1];
T=L1*X0+L2*R1*X0+L3*R1*R2*X0+L4*R1*R2*R3*X0;
Z=L2*cos(j2_)+L3*cos(j2_+j3_)+L4*cos(j2_+j3_+j4_)+L1;
len=T(2,1);
X_=len/sqrt(1+(tan(j1_))^2);
Y_=sqrt(len^2-len^2/(1+(tan(j1_))^2));
Z_=T(1,1);
fprintf("正解验证：\n");
fprintf("X:%f,Y:%f,Z:%f\n", X_, Y_, Z_);

逆解函数封装

function [j1,j2,j3,j4]=Inverse_kine(X,Y,Z)
    n = 0;m = 0;
    a1 = 75.7;a2 = 132;a3 = 98.03; a4 = 146;
    if (X == 0)
        j1 = 90;
    else
        j1 = abs(atan((Y) / X)*(57.3));
    end
    for i=0:180
        j_all = 3.1415927*i / 180;
        len = sqrt((Y)*(Y) + X * X);
        high = Z;
        L = len - a4 * sin(j_all);
        H = high - a4 * cos(j_all) - a1;
        Cosj3 = ((L*L) + (H*H) - ((a2)*(a2)) - ((a3)*(a3))) / (2 * (a2)*(a3));
        Sinj3 = (sqrt(1 - (Cosj3)*(Cosj3)));
        j3 = atan((Sinj3) / (Cosj3))*(57.3);
        K2 = a3 * sin(j3 / 57.3);
        K1 = a2 + a3 * cos(j3 / 57.3);
        Cosj2 = (K2*L + K1 * H) / (K1*K1 + K2 * K2);
        Sinj2 = (sqrt(1 - (Cosj2)*(Cosj2)));
        j2 = atan((Sinj2) / (Cosj2))*57.3;
        j4 = j_all * 57.3 - j2 - j3;

        if (j2 >= 0 && j3 >= 0 && j4 >= -90 && j2 <= 180 && j3 <= 180 && j4 <= 90)
            n = n + 1;
        end
    end


    for i=0:180
        j_all = 3.1415927*i / 180;

        len = sqrt((Y)*(Y) + X * X);
        high = Z;

        L = len - a4 * sin(j_all);
        H = high - a4 * cos(j_all) - a1;

        Cosj3 = ((L*L) + (H*H) - ((a2)*(a2)) - ((a3)*(a3))) / (2 * (a2)*(a3));
        Sinj3 = (sqrt(1 - (Cosj3)*(Cosj3)));

        j3 = atan((Sinj3) / (Cosj3))*(57.3);

        K2 = a3 * sin(j3 / 57.3);
        K1 = a2 + a3 * cos(j3 / 57.3);

        Cosj2 = (K2*L + K1 * H) / (K1*K1 + K2 * K2);
        Sinj2 = (sqrt(1 - (Cosj2)*(Cosj2)));

        j2 = atan((Sinj2) / (Cosj2))*57.3;
        j4 = j_all * 57.3 - j2 - j3;

        if (j2 >= 0 && j3 >= 0 && j4 >= -90 && j2 <= 180 && j3 <= 180 && j4 <= 90)
            m = m + 1;
            if (m == n / 2 || m == (n + 1) / 2)
                break;
            end
        end
    end
end

C++实现

#include <math.h>
#include <stdio.h>
int main()
{
	
	float a1,a2,a3,a4;                  //a1为底部圆台高度 剩下三个为三个机械臂长度 
	float j1,j4,j2,j3;                      //四个姿态角
	float L,H,P;	             //L =a2*sin(j2) + a3*sin(j2 + j3);H = a2*cos(j2) + a3*cos(j2 + j3); P为底部圆盘半径R
	float j_all;	                             //j2,j3,j4之和
	float len,high;                       //总长度,总高度
	float Cosj3,Sinj3;                   //用来存储cosj3,sinj3数值
	float Cosj2,Sinj2;
	float K1,K2;
	float X,Y,Z;  	             //输入 （X,Y,Z）坐标
	int i;
	float n,m,q;
	n = 0;
	m = 0;
	q = 0;
	//目标点坐标（X，Y，Z）
	X = 0;
	Y = 18;
	Z = 0;

	P = 14;     //底部圆盘半径
	a1 = 12; 	//底部圆盘高度	            
	a2 = 12;    //机械臂长度
	a3 = 12;
	a4 = 12;
	
	if (X == 0) 
	    j1=90;
	else 
	    j1 = atan((Y+P)/X)*(57.3);

	for(i=0;i<=180;i++)
	{	
		j_all = 3.1415927*i/180;

		len = sqrt((Y+P)*(Y+P)+X*X);
		high = Z;
			
		L = len	- a4*sin(j_all);
		H = high - a4*cos(j_all) - a1;
		
		Cosj3 = ((L*L)+(H*H)-((a2)*(a2))-((a3)*(a3)))/(2*(a2)*(a3));
		Sinj3 = (sqrt(1-(Cosj3)*(Cosj3)));
		
		j3 = atan((Sinj3)/(Cosj3))*(57.3);
		
		K2 = a3*sin(j3/57.3);
		K1 = a2+a3*cos(j3/57.3);
		
		Cosj2 = (K2*L+K1*H)/(K1*K1+K2*K2);
		Sinj2 = (sqrt(1-(Cosj2)*(Cosj2)));
		
		j2 = atan((Sinj2)/(Cosj2))*57.3;
		j4 = j_all*57.3- j2 - j3;
		
		if(j2>=0&&j3>=0&&j4>=-90&&j2<=180&&j3<=180&&j4<=90)
		{
			n=n+1;
		}
    } 
   
   
   	for(i=0;i<=180;i++)
	{
		j_all = 3.1415927*i/180;
		
		len = sqrt((Y+P)*(Y+P)+X*X);
		high = Z;

		L = len	- a4*sin(j_all);
		H = high - a4*cos(j_all) - a1;
		
		Cosj3 = ((L*L)+(H*H)-((a2)*(a2))-((a3)*(a3)))/(2*(a2)*(a3));
		Sinj3 = (sqrt(1-(Cosj3)*(Cosj3)));
		
		j3 = atan((Sinj3)/(Cosj3))*(57.3);
		
		K2 = a3*sin(j3/57.3);
		K1 = a2+a3*cos(j3/57.3);
		
		Cosj2 = (K2*L+K1*H)/(K1*K1+K2*K2);
		Sinj2 = (sqrt(1-(Cosj2)*(Cosj2)));
		
		j2 = atan((Sinj2)/(Cosj2))*57.3;
		j4 = j_all*57.3- j2 - j3;
		
	    if(j2>=0&&j3>=0&&j4>=-90&&j2<=180&&j3<=180&&j4<=90)
		{
			m=m+1;
			if(m==n/2||m==(n+1)/2)
			{	
				break;
			}
		}
    }
   
   	printf("j1:%f,j2:%f\nj3:%f,j4:%f\n",j1,j2,j3,j4);
}

四、机械臂运动控制

K210视觉端代码 

import ustruct
import sensor,lcd,time
from machine import UART,Timer
from fpioa_manager import fm

fm.register(6, fm.fpioa.UART1_RX, force=True)#映射串口引脚
fm.register(7, fm.fpioa.UART1_TX, force=True)


uart = UART(UART.UART1, 115200, read_buf_len=4096)#初始化串口

sensor.reset()#摄像头初始化
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.set_vflip(1) #后置模式，所见即所得

lcd.init()#lcd初始化

clock=time.clock()

blue_threshold  = (13, 78, -21, 28, -94, -19)#蓝色阈值
red_threshold  =(20, 55, 75, 21, 69, 9)#红色阈值
green_threshold =(21, 66, -14, -104, 79, -39)#绿色阈值

var_x_stride=10
var_y_stride=10
var_pixels_threshold=80
var_merge=True
var_margin=True
var_uart_feedback=False
def sending_data(color, cx, cy):
    global uart
    data = ustruct.pack("<bbhhhb",0x2c,0x12,int(color),int(cx),int(cy),0x5b)
    uart.write(data)

while True:
#    text=uart.read() #读取数据
#    if text: #如果读取到了数据
#        print("[INFO][USART] ",text.decode('utf-8')) #REPL打印
    clock.tick()

    img = sensor.snapshot().lens_corr(strength = 1.8, zoom = 1.0)#从感光芯片获得一张图像并且进行畸变校正
    blue_blobs = img.find_blobs([blue_threshold],x_stride=var_x_stride, y_stride=var_y_stride, pixels_threshold=var_pixels_threshold,merge=var_merge,margin=var_margin )
    red_blobs = img.find_blobs([red_threshold], x_stride=var_x_stride, y_stride=var_y_stride, pixels_threshold=var_pixels_threshold,merge=var_merge,margin=var_margin )
    green_blobs = img.find_blobs([green_threshold], x_stride=var_x_stride, y_stride=var_y_stride, pixels_threshold=var_pixels_threshold,merge=var_merge,margin=var_margin )

    if blue_blobs:
        color_status = ord('B')
        for r in blue_blobs:
            img.draw_rectangle((r[0],r[1],r[2],r[3]),color=(0,0,255))
            img.draw_cross(r[5], r[6],size=2,color=(0,255,0))
            img.draw_string(r[0], (r[1]-10), "blue", color=(0,0,255))
        sending_data(color_status,r[5],r[6])
    if green_blobs:
       color_status = ord('G')
       for r in green_blobs:
            img.draw_rectangle((r[0],r[1],r[2],r[3]),color=(0,255,0))
            img.draw_cross(r[5], r[6],size=2,color=(0,255,0))
            img.draw_string(r[0], (r[1]-10), "green", color=(0,255,0))
       sending_data(color_status,r[5],r[6])
    if red_blobs:
        color_status = ord('R')
        for r in red_blobs:
            img.draw_rectangle((r[0],r[1],r[2],r[3]),color=(255,0,0))
            img.draw_cross(r[5], r[6],size=2,color=(255,0,0))
            img.draw_string(r[0], (r[1]-10), "red", color=(255,0,0))
        sending_data(color_status,r[5],r[6])
    lcd.display(img)     #LCD显示图片

Stm32F407端主要代码（Keil5）

由于代码较多篇幅有限，这里只放核心代码，需要全部工程文件的见文末链接。

#include <ROBOT.h>

unsigned char robot_state = 0;
unsigned int item_amount_blue = 0;
unsigned int item_amount_green = 0;
unsigned int item_amount_red = 0;

//设置工作状态函数，并用LED指示当前工作状态
void setRobotState(int state)
{
    if(state)
    {
        LED1=0;
        LED0=1;
        robot_state=1;
        //NOTE：K210串口关闭直接中断
        //  USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//开启中断，继续接收坐标
    } else {
        LED1=1;
        LED0=0;
        robot_state=0;
     //   USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);//关闭中断，防止干扰
    }
}

void robot_init()  
{
    robot_state=0;
    change_mode(1,1);           //设置锁死模式
    change_mode(2,1);
    change_mode(3,1);
    change_mode(4,1);
    change_mode(5,1);
    change_mode(6,1);
    set_speed(1,40);            //设置转速
    set_speed(2,40);
    set_speed(3,40);
    set_speed(4,40);
    set_speed(5,40);
    set_speed(6,40);
    int idlist[20]={1,2,3,4,5,6};   //使用set_angles()时需要初始化的ID数组
    //float anglelist[20]={160,185,107,2,0,40};
    float anglelist[20]={130,125,107,2,0,100};  
    set_angles(idlist,anglelist,100,1);
    delay_ms(1000);
    delay_ms(1000);
    delay_ms(1000);
    //setRobotState(1);
}

//反馈机器人状态
//当为0时为工作状态-执行搬运任务，1时为空闲状态-等待搬运坐标
int getRobotState()
{
    return robot_state;
}

//使末端执行器张开/放置
void openEffector(int delay)
{
    set_angle(5,0,100);
    if(delay) delay_ms(delay);
}

//使末端执行器闭合/抓起
void closeEffector(int delay)
{
    set_angle(5,55,100);
    if(delay) delay_ms(delay);
}

/*
* 逆解核心程序
*/
void robot_move(int X,int Y,int Z,int change)
{
    if(getRobotState()||(!change))
    {
        if(change) setRobotState(0);
        //计算逆解
        double a1, a2, a3, a4;                  //a1为底部圆台高度 剩下三个为三个机械臂长度 
        double j1, j4, j2, j3;                      //四个姿态角
        double L, H, P;	             //L =a2*sin(j2) + a3*sin(j2 + j3);H = a2*cos(j2) + a3*cos(j2 + j3); P为底部圆盘半径R
        double j_all;	                             //j2,j3,j4之和
        double len, high;                       //总长度,总高度
        double Cosj3, Sinj3;                   //用来存储cosj3,sinj3数值
        double Cosj2, Sinj2;
        double K1, K2;
        int i;
        double n, m;
        n = 0;
        m = 0;

        P = 0;
        a1 = 75.7; 	//底部圆盘高度	            
        a2 = 132;    //机械臂长度
        a3 = 98.03; //17.83
        a4 = 146;

        if (X == 0)
            j1 = 90;
        else
        {
            j1 = atan((Y + P) / X)*(57.3);
            if(j1<0)j1=-j1;
        }
        for (i = 0; i <= 180; i++)
        {
            j_all = 3.1415927*i / 180;

            len = sqrt((Y + P)*(Y + P) + X * X);
            high = Z;

            L = len - a4 * sin(j_all);
            H = high - a4 * cos(j_all) - a1;

            Cosj3 = ((L*L) + (H*H) - ((a2)*(a2)) - ((a3)*(a3))) / (2 * (a2)*(a3));
            Sinj3 = (sqrt(1 - (Cosj3)*(Cosj3)));

            j3 = atan((Sinj3) / (Cosj3))*(57.3);

            K2 = a3 * sin(j3 / 57.3);
            K1 = a2 + a3 * cos(j3 / 57.3);

            Cosj2 = (K2*L + K1 * H) / (K1*K1 + K2 * K2);
            Sinj2 = (sqrt(1 - (Cosj2)*(Cosj2)));

            j2 = atan((Sinj2) / (Cosj2))*57.3;
            j4 = j_all * 57.3 - j2 - j3;

            if (j2 >= 0 && j3 >= 0 && j4 >= -90 && j2 <= 180 && j3 <= 180 && j4 <= 90)
            {
                n = n + 1;
            }
        }

        for (i = 0; i <= 180; i++)
        {
            j_all = 3.1415927*i / 180;

            len = sqrt((Y + P)*(Y + P) + X * X);
            high = Z;

            L = len - a4 * sin(j_all);
            H = high - a4 * cos(j_all) - a1;

            Cosj3 = ((L*L) + (H*H) - ((a2)*(a2)) - ((a3)*(a3))) / (2 * (a2)*(a3));
            Sinj3 = (sqrt(1 - (Cosj3)*(Cosj3)));

            j3 = atan((Sinj3) / (Cosj3))*(57.3);

            K2 = a3 * sin(j3 / 57.3);
            K1 = a2 + a3 * cos(j3 / 57.3);

            Cosj2 = (K2*L + K1 * H) / (K1*K1 + K2 * K2);
            Sinj2 = (sqrt(1 - (Cosj2)*(Cosj2)));

            j2 = atan((Sinj2) / (Cosj2))*57.3;
            j4 = j_all * 57.3 - j2 - j3;

            if (j2 >= 0 && j3 >= 0 && j4 >= -90 && j2 <= 180 && j3 <= 180 && j4 <= 90)
            {
                m = m + 1;
                if (m == n / 2 || m == (n + 1) / 2)
                {
                    break;
                }
            }
        }
        if(X>=0 && Y>=0)
        {
            j1=107-90+j1;
        } 
        else if(X<0 && Y>=0)
        {
            j1=107+90-j1;
        }
        else if(X<0 && Y<0)
        {
            j1=107+90+j1;
        }
        j2=j2+160;
        j3=185-j3;
        j4=40+j4;
        
        int idlist[20]={3,1,2,6};
        float anglelist[20]={j1,j2,j3,j4};
        set_angles(idlist,anglelist,100,1);
        delay_ms(2000);
        if(change) setRobotState(1);
    }
}


/*
* 根据比例系数与参数转换为机器人坐标系坐标并执行相关码垛核心部分
* 已知K210 视觉空间为320x240  
* X,Y,color 为串口传入相关数据
*/
void robot_transform(int X,int Y,int color)
{
    if(getRobotState())                                 //防止任务重复
    {
        setRobotState(0);                               //设置为工作状态
        printf("INPUT X: %d Y: %d Color: %d \n",X,Y,color);    //数据反馈
        //坐标变换
        double scale_x =1.003125;                         
        double scale_y =0.983333;
        double distance_x=106,distance_y=93;
        int rx = (int)(-distance_x+Y*scale_y);          //视觉区域外距离+坐标数值*比例系数
        int ry = (int)(distance_y+X*scale_x);
        printf("TRANS X: %d Y: %d \n",rx,ry);             //数据反馈
        if((ry<=140)||(ry>=365))
        {
            printf("RETURN \n");
            setRobotState(1);
            return;
        }
        //误差补偿
        if(ry<=200)
        {
            ry=ry+2;
            robot_move(rx,ry,20,0);
        } else if(ry<=300)
        {
            ry=ry+15;
            if(rx>=0) rx=rx+15;
            else rx=rx-15;
            robot_move(rx,ry,15,0);
        } else {
            ry=ry+15;
            if(rx>=0) rx=rx+20;
            else rx=rx-15;
            robot_move(rx,ry,60,0);
        }
        
        
        printf("MOVE X: %d Y: %d \n",rx,ry);              //数据反馈-实际
        
        closeEffector(1000);                            //抓取物块
        int idlist[20]={1,2,3,4,6};
        float anglelist[20]={130,125,107,2,100};  
        set_angles(idlist,anglelist,100,1);             //恢复姿态
        delay_ms(2000);
        
        int z = 120;
        
    //    int zscale = 35;
        if(color==71)                                   //绿色
        {
           // z=z+item_amount_green*zscale;
            robot_move(-180,0,z,0);
            item_amount_green++;
        } else if(color==82)                            //红色
        {
           // z=z+item_amount_red*zscale;
            robot_move(-180,100,z,0);
            item_amount_red++;
        } else if(color==66){                           //蓝色
          //  z=z+item_amount_blue*zscale;
            robot_move(-180,-100,z,0);
            item_amount_blue++;
        }
        //printf("PUT z:%d",z);             //数据反馈
        openEffector(1000);                             //放下物块
        
        set_angle(1,130,100);
        delay_ms(1000);
        set_angles(idlist,anglelist,100,1);             //恢复姿态
        delay_ms(1500);
        setRobotState(1);                               //解除工作状态
    }
}

 五、项目地址

https://pan.baidu.com/s/1RGkw8X3DCYciO0LEpT5UIg?pwd=tpl2 提取码：tpl2

Hwbxan
关注
  • 31
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
基于k210的水果分拣
qq_33862616的博客
04-17 8283
基于k210的水果分拣 yolov2tiny模型训练（采用darknet）前言darknetdarknet安装训练数据处理cfg文件配置weights文件获取训练前准备开始训练 前言 由于疫情原因，只完成识别部分，主控采用具有kpu加速的k210进行识别，网络传输打算采用esp32。水果分拣是本学期的一次综合实践课程，识别效果一般，勉强可以使用。 哔哩哔哩识别效果 采用堪智官方sdk，帧率大概29...
基于视觉伺服的机械臂分拣
04-09
非常不错的论文，对于机械臂的视觉伺服有需求的朋友们可以看一看
K210视觉机械臂发送坐标值（与下位机通信)
qq_62262788的博客
01-13 5632
k210与C51的通信实现，k210发送坐标值，下机位51单片机接收数据并提取核心数据的方法。
k210-arduino深度学习视觉机械臂抓取
热门推荐
UncleMie的博客
02-22 1万+
k210-arduino深度学习视觉机械臂抓取
咸鱼ZTMR实例—机械臂
咸鱼菌
04-22 377
咸鱼ZTMR实例—机械臂 1个舵机不过瘾，来4个搞搞机械臂。 SG90舵机X4 范围180°（-90°~90°） 引脚 说明 暗灰（棕色） GND 红色 5V 橙色 X1 PS2手柄 PS2手柄数字 代表舵机 机械臂状态 5&7 2号&3号舵机 支架上下运动 6&8 1号舵机 机身左右转 16(方块)&14（...
机械臂视觉抓取学习笔记
minzufuxing1949的博客
10-02 2882
像素坐标系不利于坐标变换，因此需要建立图像坐标系，其坐标轴的单位通常为毫米（mm），原点是相机光轴与相面的交点（称为主点），即图像的中心点，轴、轴分别与轴、轴平行。像素坐标系中坐标轴的单位是像素（整数）。摄像头这种精密仪器对光学器件的要求较高，由于摄像头内部与外部的一些原因，生成的物体图像往往会发生畸变，为了避免数据源造成的误差，需要针对摄像头的参数进行标定。2）、对图像中的特征点如标定板角点进行检测，得到标定板角点的像素坐标值，根据已知的棋盘格大小和世界坐标系原点，计算得到标定板角点的物理坐标值；
优傲机械臂视觉分拣
starry-sky的博客
03-31 1643
视觉分拣机器人分拣任务介绍视觉处理标定任务通信任务 分拣任务介绍  对于利用机械臂进行视觉分拣任务，其中占比最大的工作应该是视觉任务，但是对于初学者类似于我而言视觉是相对比较轻松的，因为像GitHub上有着大量的开源视觉处理模型，解除一些简单的分拣工作是绰绰有余的。可以很方便 视觉处理 标定任务 通信任务 ...
python实现基于K210的人脸识别项目源码（期末大作业）.zip
12-23
python实现基于K210的人脸识别项目源码（期末大作业）.zip 这是95分以上高分必过大作业项目，下载即用无需修改，确保可以运行。也可作为课程设计。 python实现基于K210的人脸识别项目源码（期末大作业）.zip 这是...
基于亚博K210的人脸识别项目python源码.zip
09-21
基于亚博K210的人脸识别项目python源码.zip基于亚博K210的人脸识别项目python源码.zip基于亚博K210的人脸识别项目python源码.zip基于亚博K210的人脸识别项目python源码.zip基于亚博K210的人脸识别项目python源码.zip...
《MicroPython从0到1》基于K210平台
02-07
"MicroPython从0到1"基于K210平台 本资源摘要信息旨在介绍MicroPython的基础知识和应用，基于K210平台的开发环境。MicroPython是一个轻量级的Python实现，旨在嵌入式系统中运行，提供了方便的开发方式和强大的功能...
基于机器视觉的多机械臂煤矸石分拣机器人系统研究
04-17
现有煤矸石分拣方法主要是根据煤和岩石的纹理特征值，利用图像处理和模式识别技术对煤矸石进行识别分选，分选的煤矸石粒度为25～150mm,而对于150mm以上的煤矸石仍依靠人工进行分选。为了对大粒度煤矸石进行分拣，设计了一种基于机器视觉的多机械臂煤矸石分拣机器人系统。该系统采用机器视觉采集煤矸石信息，应用深度学习方法实现煤矸石识别和抓取特征提取；在获取煤矸石序列信息后，根据煤矸石位置进行排序工作，并通过多目标任务分配策略将抓取任务下达给相应机械臂控制器；机械臂获取任务后，根据获得的任务对目标进行动态监测，当目标进入机械臂工作空间后由视觉伺服系统驱动机械臂完成煤矸石分拣。试验结果表明，该系统可对粒度为50～260mm的煤矸石进行高效、快速分拣，所采用的煤矸石识别方法和分拣策略在不同带速下具有良好的稳定性和准确性，煤矸识别与定位的综合准确率可达93%，验证了该系统的可行性。
基于机器视觉的自动分拣系统
10-12
对目标区域进行检测 在多种目标中识别特定颜色和形状的目标物 并给出相应的结果包括目标位置
基于K210开发实现的路面损坏识别系统python源代码+文档说明
最新发布
01-14
基于 K210 的路面损坏识别系统 前言 由于各种各样的原因，随着时间的推移，公路路面上会出现各种各样的损坏情况，例如出现裂缝、出现坑洼和交通标线模糊等。这些损坏情况往往会降低车辆行驶的舒适性，还可能成为交通...
基于MATLAB视觉的机械臂水果分拣系统仿真（记录自用）
qq_40969179的博客
07-05 2767
一、效果展示 ① 水果分拣系统仿真环境初始状态 ②GUI的界面 此界面是在之前做的六轴机械臂操作界面加上的，图个方便，所以这里显得比较突兀！ ③分拣结果 二、系统流程图 ①前处理 ②成熟度检测（通过颜色简单检测） ③果径检测 一可以利用采集到的边缘像素点信息，以某固定点与其他点分别进行比较获得其两者间位置最大的点，两者的距离最大者为判断该水果尺寸的信息。如图3-4所示，最长像素间距判断 。二是利用regionprops函数中的“Area”属性直接计算各个目标的面积值，后通过设定的范围，进行判断
【STM32实战】机械臂快递分拣系统（二）——机械臂控制程序（上位机）编写
adas323的博客
09-14 8530
之前的博文已经完成了机械臂控制程序（下位机）的编写，并通过蓝牙以及串口调试工具能实现对机械臂的控制，本篇主要是完成上位机程序的编写，使机械臂可以接收来自上位机的指令并做出相应的动作，方法还是采用串口通信，使用蓝牙模块连接，然后就是可以让这个上位机能连接阿里云平台，这样就可以在阿里云平台上实时看到各舵机的信息，以及发出控制指令，做出控制。
从零制作视觉抓取机械臂实物系列：一、让机械臂实物动起来（2）
Kkoutianwu的博客
08-18 3840
硬件准备以及开发环境搭建硬件准备开发环境搭建课后习题 硬件准备   开篇点题，我们需要一台电脑，不需要很高的配置，只要不是年份很久远的电脑足矣，一个淘宝机械臂，有钱可以3种机械臂都买来玩玩，一个下位机，一个USB转TTL模块或者一个蓝牙模块，一个USB相机，有钱也可以买个RGB-D相机。 开发环境搭建 编译器，编辑器，软件包， pycharm安装 anaconda安装 课后习题 ...
分拣机械臂
qq_35715421的博客
03-30 4635
第一部分  设计概述 随着科技的发展，人类探索未知世界的脚步也逐渐的加快。总会有一些地方和环境是人无法亲临去探索的。此时就需要借助一些辅助性的工具。因为有了这样的思考，开始有了设计一个可移动的机械臂的想法。模拟在复杂的环境中进行作业。 可移动的机械臂，底部移动用蓝牙来控制。机械臂分两部分来实施控制：一是web进行控制，就是在一个局域网内部通过web来让机械臂进行相应的抓取动作。二是Basys3
uarm视觉分拣代码解析、openmv颜色识别
weixin_42656213的博客
04-09 1729
以下代码为了做笔记方便，希望有错误的地方大家能给予修改意见，感谢！ 代码均来自https://github.com/uArm-Developer/Vision-Pick-and-Place Arduino参考链接：https://www.arduino.cc/reference/en/ 使用 ArduinoMega 1. Arduino 函数简要介绍 Serial相关函数 Arduino串行端口（也称为UART或USART），ArduinoMega有多个： //指示指定的串行端口是否已就绪。如果指定的
k210视觉识别模块
07-27
您指的是K210视觉识别模块，它是一种基于Kendryte K210芯片的人工智能图像处理模块。K210是一款嵌入式人工智能（AI）解决方案，具有高性能、低功耗和低成本的特点。这个模块可以用于各种视觉识别任务，如人脸识别、物体检测、图像分类等。它通常与摄像头模块一起使用，通过采集图像数据进行处理和分析。K210视觉识别模块在物联网、智能家居、机器人等领域有广泛的应用前景。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值