无线视频监控小车

最新推荐文章于 2022-07-05 09:33:15 发布
最新推荐文章于 2022-07-05 09:33:15 发布
阅读量2.5k 收藏 3
点赞数 2
分类专栏： 应用-robot-vision-motion cpu-arm9-mini2440 文章标签： struct table output security socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/opencpu/article/details/7484378
版权
各个模块
micro2440，1个
usb无线网卡TL-WN721N，1个
usb摄像头zp0301，1个
L298N直流电机驱动模块，2个
小车主体，1个

视频稍后

 
//在micro2440上操作
[root@FriendlyARM plg]# ls
bin-song
bin-song.tgz
dc_motor_driver.ko
server
usb-wifi-kits-for-mini2440-linux-2.6.32.2-20100728.tar.gz
[root@FriendlyARM plg]# 
[root@FriendlyARM plg]# scan-wifi //扫描无线路由器
         57% ChinaNet-TEXj(Security)
         57% iTV-TEXj(Security)
         56% ZXDSL531BII-539490
         91% MERCURY_C93C2E(Security)//找到了
(Security)
         39% ChinaNet-rwXE(Security)
         37% iTV-rwXE(Security)
7 Access Point Found
[root@FriendlyARM plg]# start-wifi wpa2 MERCURY_C93C2E qwertyuiop//连接至无线路由器，密码是qwertyuiop
udhcpc (v1.13.3) started
Sending discover...
Sending discover...
Sending discover...
Sending discover...
cfg80211: Calling CRDA for country: US
Sending discover...
Sending select for 192.168.1.101...
Lease of 192.168.1.101 obtained, lease time 7200
deleting routers
route: SIOCDELRT: No such process
adding dns 192.168.1.109
[root@FriendlyARM bin-song]# ifconfig eth0 down //暂时禁用本地网卡

[root@FriendlyARM plg]# insmod dc_motor_driver.ko //加载驱动
smart_car       initialized
[root@FriendlyARM plg]# ./server &//启动服务器，监听3333端口，udp模式
[root@FriendlyARM plg]#  DBG(/opt/FriendlyARM/mini2440/smart_car/dc_motor/dc_motor_driver.c, misc_open(), 146): open 
 DBG(server.c, main(), 63): sock sucessful
 DBG(server.c, main(), 78): bind sucess

[root@FriendlyARM plg]# cd bin-song/
[root@FriendlyARM bin-song]# ./mjpg_streamer -i input_uvc.so -o "output_http.so -w ./www"  //开启mjpg的web服务器，8080端口

//在虚拟机上操作
[root@localhost dc_motor]# ./client //此时按下上下左右键开始控制吧

源码： 
/*******************************dc_motor_driver.c**************/  
//操作io口,使用8个点，
//分配给每个L298N模块4个点
//如下
      
#include <linux/miscdevice.h>    
#include <linux/delay.h>    
#include <asm/irq.h>    
#include <mach/regs-gpio.h>    
#include <mach/hardware.h>    
#include <linux/kernel.h>    
#include <linux/module.h>    
#include <linux/init.h>    
#include <linux/mm.h>    
#include <linux/fs.h>    
#include <linux/types.h>    
#include <linux/time.h>      
#include <linux/timer.h>     
#include <linux/moduleparam.h>    
#include <linux/slab.h>    
#include <linux/errno.h>    
#include <linux/ioctl.h>    
#include <linux/cdev.h>    
#include <linux/string.h>    
#include <linux/list.h>    
#include <linux/pci.h>    
#include <linux/gpio.h>    
#include <asm/uaccess.h>    
#include <asm/atomic.h>    
#include <asm/unistd.h>    
    
#define DEBUG      
#ifdef DEBUG        
#define DBG(...) printk(" DBG(%s, %s(), %d): ", __FILE__, __FUNCTION__, __LINE__); printk(__VA_ARGS__)        
#else        
#define DBG(...)        
#endif        
    
    
#define DEVICE_NAME "smart_car"      
#define delay_time_ms 1000  
  
int ret;  
unsigned long motor_table [] = {    
    S3C2410_GPF(0),//EA    
    S3C2410_GPF(2),//EB 
    S3C2410_GPF(4),//EC  
    S3C2410_GPF(6),//ED
 
    S3C2410_GPF(1),//IA,the back-right  wheel ,1 on,0 back
    S3C2410_GPF(3),//IB,the front-right wheel ,1 on,0 back
    S3C2410_GPF(5),//IC,the back-left   wheel ,1 on,0 back
    S3C2410_GPG(0),//ID,the back-right  wheel ,1 on,0 back
  
};     
unsigned int motor_cfg_table [] = {    
    S3C2410_GPIO_OUTPUT,  
    S3C2410_GPIO_OUTPUT,   
    S3C2410_GPIO_OUTPUT,     
    S3C2410_GPIO_OUTPUT,

    S3C2410_GPIO_OUTPUT,
    S3C2410_GPIO_OUTPUT,     
    S3C2410_GPIO_OUTPUT,
    S3C2410_GPIO_OUTPUT,      
};    
#define SET_EA_HIGH (s3c2410_gpio_setpin(motor_table[0],1))  
#define SET_EA_LOW (s3c2410_gpio_setpin(motor_table[0],0))  
  
#define SET_EB_HIGH (s3c2410_gpio_setpin(motor_table[1],1))  
#define SET_EB_LOW (s3c2410_gpio_setpin(motor_table[1],0))  
  
#define SET_EC_HIGH (s3c2410_gpio_setpin(motor_table[2],1))  
#define SET_EC_LOW (s3c2410_gpio_setpin(motor_table[2],0))  

#define SET_ED_HIGH (s3c2410_gpio_setpin(motor_table[3],1))  
#define SET_ED_LOW (s3c2410_gpio_setpin(motor_table[3],0))  
  
#define SET_IA_HIGH (s3c2410_gpio_setpin(motor_table[4],1))  
#define SET_IA_LOW (s3c2410_gpio_setpin(motor_table[4],0))  
  
#define SET_IB_HIGH (s3c2410_gpio_setpin(motor_table[5],1))  
#define SET_IB_LOW (s3c2410_gpio_setpin(motor_table[5],0))  

#define SET_IC_HIGH (s3c2410_gpio_setpin(motor_table[6],1))  
#define SET_IC_LOW (s3c2410_gpio_setpin(motor_table[6],0))  
  
#define SET_ID_HIGH (s3c2410_gpio_setpin(motor_table[7],1))  
#define SET_ID_LOW (s3c2410_gpio_setpin(motor_table[7],0))  

#define UP 1
#define DOWN 6
#define RIGHT 3
#define LEFT 4
#define STOP 5

ssize_t misc_write(struct file *filp, const char __user *buf, size_t count,  loff_t *f_pos)      
{           
DBG("write \n");       
    int ret;    
    char *commad=0;    
    if (count == 0) {    
        return count;    
    }    
    commad=kmalloc(count+1,GFP_KERNEL);//need print it using %s, so plus 1 byte for '\0'    
    ret = copy_from_user(commad, buf, count);//if success,ret=0    
    if (ret) {    
        return ret;    
    }    
    commad[count]='\0';    
    DBG("commad=%s\n",commad);    
    DBG("ret=%d\n",ret);    
        
//to test the command "set to 1" or "clear to 0" if correct 代码做管脚测试用到    
    if(strncmp(commad,"SET_EA_HIGH",count)==0) {SET_EA_HIGH;DBG("excuting SET_EN_HIGH succes !\n");}     
    if(strncmp(commad,"SET_EA_LOW",count)==0) {SET_EA_LOW;DBG("excuting SET_EN_LOW succes !\n");}     
    if(strncmp(commad,"SET_EB_HIGH",count)==0) {SET_EB_HIGH;DBG("excuting SET_EB_HIGH succes !\n");}     
    if(strncmp(commad,"SET_EB_LOW",count)==0) {SET_EB_LOW;DBG("excuting SET_EB_LOW succes !\n");}     
    if(strncmp(commad,"SET_EC_HIGH",count)==0) {SET_EC_HIGH;DBG("excuting SET_EC_HIGH succes !\n");}     
    if(strncmp(commad,"SET_EC_LOW",count)==0) {SET_EC_LOW;DBG("excuting SET_EC_LOW succes !\n");}     
    if(strncmp(commad,"SET_ED_HIGH",count)==0) {SET_ED_HIGH;DBG("excuting SET_ED_HIGH succes !\n");}     
    if(strncmp(commad,"SET_ED_LOW",count)==0) {SET_ED_LOW;DBG("excuting SET_ED_LOW succes !\n");}   

    if(strncmp(commad,"SET_IA_HIGH",count)==0) {SET_IA_HIGH;DBG("excuting SET_IA_HIGH succes !\n");}     
    if(strncmp(commad,"SET_IA_LOW",count)==0) {SET_IA_LOW;DBG("excuting SET_IA_LOW succes !\n");}    
    if(strncmp(commad,"SET_IB_HIGH",count)==0) {SET_IB_HIGH;DBG("excuting SET_IB_HIGH succes !\n");}     
    if(strncmp(commad,"SET_IB_LOW",count)==0) {SET_IB_LOW;DBG("excuting SET_IB_LOW succes !\n");}   
    if(strncmp(commad,"SET_IC_HIGH",count)==0) {SET_IC_HIGH;DBG("excuting SET_IC_HIGH succes !\n");}     
    if(strncmp(commad,"SET_IC_LOW",count)==0) {SET_IC_LOW;DBG("excuting SET_IC_LOW succes !\n");} 
    if(strncmp(commad,"SET_ID_HIGH",count)==0) {SET_ID_HIGH;DBG("excuting SET_ID_HIGH succes !\n");}     
    if(strncmp(commad,"SET_ID_LOW",count)==0) {SET_ID_LOW;DBG("excuting SET_ID_LOW succes !\n");}  

    return ret ? ret : count;      
}      
ssize_t misc_read(struct file *filp, char __user *buf, size_t count,  loff_t *f_pos)      
{      
DBG("read \n");     
return 0;   
}      
    
    
static int misc_release(struct inode *inode, struct file *filp)      
{    
DBG("release \n");       
return 0;      
}      
    
static int misc_open(struct inode *inode, struct file *filp)      
{         
DBG("open \n");      
return 0;      
}      
    
static inline void go_on()
{
	SET_EA_HIGH;
	SET_IA_HIGH;

	SET_EB_HIGH;
	SET_IB_HIGH;

	SET_EC_HIGH;
	SET_IC_HIGH;

	SET_ED_HIGH;
	SET_ID_HIGH;

}
static inline void go_back()
{
	SET_EA_HIGH;
	SET_IA_LOW;

	SET_EB_HIGH;
	SET_IB_LOW;

	SET_EC_HIGH;
	SET_IC_LOW;

	SET_ED_HIGH;
	SET_ID_LOW;

}
static inline void go_right()
{
	SET_EA_LOW;

	SET_EB_HIGH;
	SET_IB_HIGH;

	SET_EC_LOW;

	SET_ED_HIGH;
	SET_ID_HIGH;
}

static inline void go_left()
{

	SET_EA_HIGH;
	SET_IA_HIGH;

	SET_EB_LOW;

	SET_EC_HIGH;	
	SET_IC_HIGH;

	SET_ED_LOW;
}
static inline void stop()
{

	SET_EA_LOW;

	SET_EB_LOW;

	SET_EC_LOW;

	SET_ED_LOW;
}





static int misc_ioctl(struct inode *inode,struct file *file,unsigned int cmd,unsigned long arg)  
{  
int i=0;  
DBG("cmd=%x\n",cmd);  
DBG("arg=%x\n",arg);  
if (cmd==UP)		// go on 
{      	
	go_on();
}else if(cmd==DOWN){  //go back
	go_back();  
}else if(cmd==RIGHT){  //go right

	go_right();
}else if(cmd==LEFT){  //go left

	go_left(); 
}else if(cmd==STOP){  //stop
	stop(); 
}  
   return 0;
   
}  
  
  
    
static struct file_operations dev_fops = {      
.owner  =   THIS_MODULE,      
.open   =   misc_open,      
.read   =   misc_read,      
.write  =   misc_write,      
.release=   misc_release,      
.ioctl= misc_ioctl,  
};      
    
static struct miscdevice misc = {      
.minor = MISC_DYNAMIC_MINOR,      
.name = DEVICE_NAME,      
.fops = &dev_fops,      
};      
    
static int __init dev_init(void)      
{      
  
int ret;    
int i;    
for (i = 0; i < 8; i++) {//配置管脚的out in 模式    
s3c2410_gpio_cfgpin(motor_table[i], motor_cfg_table[i]);    
s3c2410_gpio_setpin(motor_table[i], 0);    
}    
  
ret = misc_register(&misc);    
//InitRc522() ;//初始化    
printk (DEVICE_NAME"\tinitialized\n");    
//open_flag=0;    
return ret;    
  
  
  
}      
    
static void __exit dev_exit(void)      
{      
DBG (DEVICE_NAME"\texit\n");      
misc_deregister(&misc);      
}      
    
module_init(dev_init);      
module_exit(dev_exit);      
MODULE_LICENSE("GPL");      
MODULE_AUTHOR("Song.");     

//server.c
//运行在micro2440,监听本地udp 3333端口
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include<stdlib.h>
#include <sys/stat.h>    
#include <sys/ioctl.h>    
#include <fcntl.h>    
#include <linux/fs.h>    
  

#define DEBUG    
#ifdef DEBUG      
#define DBG(...) fprintf(stderr, " DBG(%s, %s(), %d): ", __FILE__, __FUNCTION__, __LINE__); fprintf(stderr, __VA_ARGS__)      
#else      
#define DBG(...)      
#endif   

#define SERV_PORT   3333

#define   UP_KEY   		0x41 
#define   DOWN_KEY   		0x42
#define   RIGHT_KEY   		0x43
#define   LEFT_KEY   		0x44
#define	  STOP_KEY 		0x20

#define UP 1
#define DOWN 6
#define RIGHT 3
#define LEFT 4
#define STOP 5

  int main(int argc,char* argv[])
  {
//open the device
	int fd = open("/dev/smart_car", O_RDWR|O_CREAT,00100);    
	if (fd < 0) 
	{    
		perror("open file ");    
		return 1;    
	}    


	int sock_fd;   //套接子描述符号
	if(argc==1)
	{
	//for the socket
		  int recv_num;
		  int send_num;
		  int client_len;
		  char recv_buf[1];
		  struct sockaddr_in  addr_serv;
		  struct sockaddr_in  addr_client;//服务器和客户端地址
		  sock_fd = socket(AF_INET,SOCK_DGRAM,0);
		  if(sock_fd < 0){
		          DBG("socket");
		          exit(1);
		  } else{
	  
		          DBG("sock sucessful\n");
		  }
		  //初始化服务器断地址
		  memset(&addr_serv,0,sizeof(struct sockaddr_in));
		  addr_serv.sin_family = AF_INET;//协议族
		  addr_serv.sin_port = htons(SERV_PORT);
		  addr_serv.sin_addr.s_addr = htonl(INADDR_ANY);
	  
		  client_len = sizeof(struct sockaddr_in);
		  /*绑定套接子*/
		  if(bind(sock_fd,(struct sockaddr *)&addr_serv,sizeof(struct sockaddr_in))<0 ){
		          DBG("bind");
		          exit(1);
		  } else{
	  
		          DBG("bind sucess\n");
		  }
	//monitor the socket
		  while(1){
			  recv_num = recvfrom(sock_fd,recv_buf,sizeof(recv_buf),0,(struct sockaddr *)&addr_client,&client_len);
			  if(recv_num <  0){
			          DBG("bad\n");
			          DBG("again recvfrom");
			          exit(1);
			  } else{
		          	DBG("recv sucess:%x\n",recv_buf[0]);
				switch(recv_buf[0])
				{
				case UP_KEY:
					{
					ioctl(fd,UP);
					DBG("UP\n");break;
					}
				case DOWN_KEY:
					{
					ioctl(fd,DOWN);
					DBG("DOWN\n");break;
					}
				case RIGHT_KEY:
					{
					ioctl(fd,RIGHT);
					DBG("RIGHT\n");break;
					}
				case LEFT_KEY:
					{
					ioctl(fd,LEFT);
					DBG("LEFT\n");break;
					}
				case STOP_KEY:
					{
					ioctl(fd,STOP);
					DBG("STOP\n");break;
					}
				}

			
			  }
		  	}
	}
	else if(argc==2)//to test
	{
		int len=write(fd,argv[1],strlen(argv[1]));
		if (len > 0) {  
		DBG("len= %d\n",len);    
		DBG("%s,%d\n",argv[1],strlen(argv[1]));    
		} else {    
		DBG("error:");    
		return 1;    
		}     
	}
//close socket
          close(sock_fd);
//clode device
	  close(fd);  
          return 0;
  }


//client.c
//运行在主机，向micro2440的udp 3333端口发送控制数据 
#include<stdio.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
#include<unistd.h>

#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>

#define DEBUG    
#ifdef DEBUG      
#define DBG(...) fprintf(stderr, " DBG(%s, %s(), %d): ", __FILE__, __FUNCTION__, __LINE__); fprintf(stderr, __VA_ARGS__)      
#else      
#define DBG(...)      
#endif   

#define DEST_PORT 3333
#define DSET_IP_ADDRESS  "192.168.1.101"

#include <termios.h>


static struct termios stored_settings;

void set_keypress(void)
{
    struct termios new_settings;

    tcgetattr(0,&stored_settings);

    new_settings = stored_settings;

    /* Disable canonical mode, and set buffer size to 1 byte */
    new_settings.c_lflag &= (~ICANON);
    new_settings.c_cc[VTIME] = 0;
    new_settings.c_cc[VMIN] = 1;

    tcsetattr(0,TCSANOW,&new_settings);
    return;
}

void reset_keypress(void)
{
    tcsetattr(0,TCSANOW,&stored_settings);
    return;
}




int main()
{
	int sock_fd;/*套接字文件描述符*/
	int send_num;
	int recv_num;
	int dest_len;
	char send_buf[1];
	struct sockaddr_in addr_serv;/*服务端地址，客户端地址*/
	set_keypress();
	sock_fd = socket(AF_INET,SOCK_DGRAM,0);//创建套接子
	//初始化服务器端地址
	memset(&addr_serv,0,sizeof(addr_serv));
	addr_serv.sin_family = AF_INET;
	addr_serv.sin_addr.s_addr = inet_addr(DSET_IP_ADDRESS);
	addr_serv.sin_port = htons(DEST_PORT);

	dest_len = sizeof(struct sockaddr_in);
	
//response for key
	char ch;
	while(1)//may use ctrl+c to kill
	{
		ch=getchar();
		DBG("ch=%x\n",ch);
		send_num = sendto(sock_fd,&ch,sizeof(ch),0,(struct sockaddr *)&addr_serv,dest_len);
		if(send_num < 0){
		 DBG("sendto");
		 exit(1);
		} else{
		  DBG("send sucessful\n");
		}
		

	}

	close(sock_fd);
	reset_keypress();
	return 0;



}


google_lover
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
WIFI视频小车
04-18
NULL 博文链接：https://924789950.iteye.com/blog/1840790
本人将陆续发布自己所做的无线视频监控小车视频及资料
JCracker 在路上
05-04 4755
本人将陆续发布自己所做的无线视频监控小车视频及资料，其中包括源码，对源码的视频讲解，以及在做的过程中所使用到的参考资料。给和我类似的同学提供一个参考。 硬件环境：                            real6410开发板，ov9650摄像头，直流电机驱动电路，无线路由器，real6410配套无线网卡，pc机 总体思路：     视频传
【原创】Android无线视频监控小车--前篇
lynnlase的专栏
12-10 1759
因为自己刚好有一个mini2440的板子一直放着，最近一段时间又没有弄linux，都生疏了，驱动啊内核配置都忘了，汗。所以还是弄个东西算是自己巩固下 自己的知识。           平台：                    mini2440开发板                    天敏的USB摄像头（具体型号没有注意，反正测试能正常驱动就用了）
毕业设计之wifi视频监控小车（一）
devilbuqi的博客
03-29 5303
首先作为一名即将毕业和还在苦苦做毕业的技术菜鸟，像大佬们致敬，说心里话，技术这一行真的还是很难，但是既然选择了就不会退缩，自己慢慢学习慢慢成长。 为了提高自己，我毕业设计选择的是做一个搭载摄像头的小车，这设计相信很多前辈们已经做过了，网上资料也多，我也很感谢大佬们分享的经验，帮我解决了很多问题。首先在硬件开发板选择上面我选择的是mini2440，也就是一款ARM9的S3C244...
Android平台无线视频监控小车的设计
03-17
单片机为硬件平台，通过无线路由器进行视频流的访问和对小车进行驱动，实现安卓手机无线访问小车摄像头进行视 频监控和操控小车行走。经过测试，无线遥控小车在 １５０ｍ 的范围内可流畅地查看小车摄像头采集的视频...
Android平台无线视频监控小车的设计.pptx
最新发布
10-15
Android平台无线视频监控小车的设计.pptx
无线视频监控小车视频采集部分源码
05-05
无线视频监控小车视频采集部分源码，详细分析了如何使用v4l2接口，以及如何使用x.264对采集到的视频进行压缩，并且通过UDP将H264流发送出去。更多详细内容及视频请访问http://blog.csdn.net/jcracker
Wifi视频监控小车
08-15
随着生活智能化的不断发展，智能家居将是未来发展的必然趋势...而现在嵌入wifi功能的设备随处可见，所以利用现有的网络资源搭建一台wifi视频监控小车的想法就诞生了，即利用带有wifi的设备进行控制小车，实现无线监控。
无线视频监控小车之系统后台视频显示部分
05-05
无线视频监控小车之系统后台视频显示部分，如何使用ffmpeg解码接收到的h264流，同时如何利用SDL在屏幕上将解码后的视频播放出来。更多详细信息及视频请访问http://blog.csdn.net/jcracker
基于wifi手机控制的无线视频小车
02-24
基于wifi手机控制的无线视频小车 ARM下制作详细教程
基于opencv的远程视频监控智能小车
12-25
在智能小车上（Arduino、主控板）搭载wifi模块和摄像头，发送数据到电脑，vs2013处理数据后发回小车，达到实时视频监测和远程遥控控的目的，所有代码都是用txt文档保存的，直接在vs中复制即可。（需提前配置好opencv3.0）
pcDuino: 无线视频监控小车视频及资料
进击的青少年
01-21 384
http://blog.csdn.net/jcracker/article/details/7536479
无线视频监控系统 PHP,无线视频监控小车整体方案
weixin_39693437的博客
03-27 343
无线视频监控小车整体方案，包括源码，视频讲解。从采集到h264压缩，到视频显示，到小车控制，全套哦.本人将陆续发布自己所做的无线视频监控小车视频及资料，其中包括源码，对源码的视频讲解，以及在做的过程中所使用到的参考资料。给和我类似的同学提供一个参考。硬件环境：real6410开发板，ov9650摄像头，直流电机驱动电路，无线路由器，real6410配套无线网卡，pc机总体思路：视频传输模块：利用r...
带监控的移动小车机器人
L1643319918的博客
07-05 559
项目实操：带监控的移动小车机器人
WIFI实时监控追踪小车演示视频——安卓端、小车
学习者专栏
10-23 5866
本项目是将安卓技术、嵌入式技术、无线通信技术等相关技术应用到视频监控系统中，可实现视频监控系统的设备移动化，由可移动监控平台、控制软件两部分组成。使用安卓手机作为控制端，通过无线网络对监控平台进行移动方向、速度的控制，摄像头云台转动控制，可以实现重力感应控制，平台上的摄像头实时采集视频图像信号并通过无线WiFi网络将视频信号实时传输到手机端观看，然后可实时拍照录像并可实时存储，且可以凭借PC使用OpenCV进行运动物体追踪。由于监控端可移动，可以在无人进入的情况下获取危险环境的视频图像。具有控制方便，监控灵
远程视频小车
weixin_43073852的博客
03-11 3131
受疫情影响不得不呆在家里，网上看到山东硬核小姐姐用遥控视频小车买馒头，逛大明湖，这真是躺在家里逛世界的赶脚。刚好手头有个机器人小车，就想着改造一下。 一、项目准备 1、树莓派3B+一块 2、arduino小车一个 3、USB摄像头一个 其中arduino小车网上有很多教程可自行搜索。因为小车只是载体，没有太多复杂的功能，只需要一块arduion控制板，一个电机驱动模块，两个电机即可。至于小车外形可...
halcon基本，vb，vc连接halcon读取图像，视频
热门推荐
openCpu
03-29 1万+
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、 halcon学习方法：安装完halcon之后，在开始里出现一些文档 看完solution_guide_i.pdf就算是入门了，里面讲了大部分应用的需要的步骤及所用算法 quick_guide.pdf 快速入门halcon
颜色空间，图像格式，彩色转灰度函数
openCpu
03-25 8506
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、 rgb颜色空间 灰度图像是一个特殊的彩色图像，r=g=b，如图 所以，要将彩色图像转化为灰度图像，只需令每个像素的r=g=b=x即可.而x等于多少，视不同情况而定。 补充： 黑色 r=0 g=0 b=0 白色 r=255 g
arduino视频小车
09-08
该小车的硬件部分包括Arduino UNO单片机、电机驱动模块、红外接收模块、无线路由模块、视频监控模块、循迹模块和避障模块。通过使用这些模块，可以实现小车的自动寻迹、避障功能，以及控制行驶速度等。这个小车的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值