PAJ7620U2+蓝牙主从机实现远程手势控制

最新推荐文章于 2024-03-22 14:01:34 发布
最新推荐文章于 2024-03-22 14:01:34 发布
阅读量825 收藏 8
点赞数
分类专栏： arduino
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qqliuzhitong/article/details/118893516
版权

目录

主机：

从机： 

电机测试： 

这是个4舵机驱动的水上仿生鱼。

两块arduino通过蓝牙通信，岸上的arduino连接paj7620u2进行手势控制。

水下的arduino连接驱动执行设备（舵机和电机）对机器鱼直接控制。

主机：

主机为一块arduino连接上paj7620u2手势传感器模块。

#include <Wire.h>
#include "paj7620.h"
#include<SoftwareSerial.h>

//新建一个Serial_p对象，rx:6,tx:5
//连接蓝牙的master
SoftwareSerial Serial_p(6,5);

#define GES_REACTION_TIME   500       // You can adjust the reaction time according to the actual circumstance.
#define GES_ENTRY_TIME      800       // When you want to recognize the Forward/Backward gestures, your gestures' reaction time must less than GES_ENTRY_TIME(0.8s). 
#define GES_QUIT_TIME     1000

//上:a 下:b 左:c 右:d 前:e
char command_char='e';

void setup()
{
  uint8_t error = 0;

  Serial.begin(9600);
  Serial_p.begin(9600);
  Serial.println("Serial baud:9600");
  Serial.println("Underwater fish master program!");

  error = paj7620Init();      // initialize Paj7620 registers
  if (error) 
  {
    Serial.print("INIT ERROR,CODE:");
    Serial.println(error);
  }
  else
  {
    Serial.println("INIT OK");
  }
  Serial.println("Please input your gestures:\n");
}

void loop()
{
  uint8_t data = 0, data1 = 0, error;
  
  error = paj7620ReadReg(0x43, 1, &data);       // Read Bank_0_Reg_0x43/0x44 for gesture result.
  if (!error) 
  {
    switch (data)                   // When different gestures be detected, the variable 'data' will be set to different values by paj7620ReadReg(0x43, 1, &data).
    {
      case GES_RIGHT_FLAG:
        delay(GES_ENTRY_TIME);
        paj7620ReadReg(0x43, 1, &data);
        if(data == GES_FORWARD_FLAG) 
        {
          Serial.println("Forward");
          Serial_p.print('e');
          delay(GES_QUIT_TIME);
        }
        else if(data == GES_BACKWARD_FLAG) 
        {
          Serial.println("Backward");
          delay(GES_QUIT_TIME);
        }
        else
        {
          Serial.println("Right");
          Serial_p.print('d');
        }          
        break;
      case GES_LEFT_FLAG: 
        delay(GES_ENTRY_TIME);
        paj7620ReadReg(0x43, 1, &data);
        if(data == GES_FORWARD_FLAG) 
        {
          Serial.println("Forward");
          Serial_p.print('e');
          delay(GES_QUIT_TIME);
        }
        else if(data == GES_BACKWARD_FLAG) 
        {
          Serial.println("Backward");
          delay(GES_QUIT_TIME);
        }
        else
        {
          Serial.println("Left");
          Serial_p.print('c');
        }          
        break;
      case GES_UP_FLAG:
        delay(GES_ENTRY_TIME);
        paj7620ReadReg(0x43, 1, &data);
        if(data == GES_FORWARD_FLAG) 
        {
          Serial.println("Forward");
          Serial_p.print('e');
          delay(GES_QUIT_TIME);
        }
        else if(data == GES_BACKWARD_FLAG) 
        {
          Serial.println("Backward");
          delay(GES_QUIT_TIME);
        }
        else
        {
          Serial.println("Up");
          Serial_p.print('a');
        }          
        break;
      case GES_DOWN_FLAG:
        delay(GES_ENTRY_TIME);
        paj7620ReadReg(0x43, 1, &data);
        if(data == GES_FORWARD_FLAG) 
        {
          Serial.println("Forward");
          Serial_p.print('e');
          delay(GES_QUIT_TIME);
        }
        else if(data == GES_BACKWARD_FLAG) 
        {
          Serial.println("Backward");
          delay(GES_QUIT_TIME);
        }
        else
        {
          Serial.println("Down");
          Serial_p.print('b');
        }          
        break;
      case GES_FORWARD_FLAG:
        Serial.println("Forward");
        Serial_p.print('e');
        delay(GES_QUIT_TIME);
        break;
      case GES_BACKWARD_FLAG:     
        Serial.println("Backward");
        delay(GES_QUIT_TIME);
        break;
      case GES_CLOCKWISE_FLAG:
        Serial.println("Clockwise");
        break;
      case GES_COUNT_CLOCKWISE_FLAG:
        Serial.println("anti-clockwise");
        break;  
      default:
        paj7620ReadReg(0x44, 1, &data1);
        if (data1 == GES_WAVE_FLAG) 
        {
          Serial.println("wave");
        }
        break;
    }
  }
  delay(100);
}

从机： 

从机为一块arduino连接若干舵机。

#include <Servo.h>
#include<SoftwareSerial.h>

//定义舵机速度
#define servo_speed 10

//定义限位开关引脚
#define swit1 10

#define water 11

#define servo1_pin 6
#define servo2_pin 7
#define servo3_pin 8
#define servo4_pin 9

//舵机1的摆动幅度
#define servo1_min -30
#define servo1_max +30

//舵机2的摆动幅度
#define servo2_min -30
#define servo2_max +30

//舵机3的摆动幅度
#define servo3_min -60
#define servo3_max +60

//舵机4的摆动幅度
#define servo4_min -30
#define servo4_max +30

#define TRIGGER A0
#define ECHO A1

#define dis_min 20        //超声波避障距离
#define dis_max 180       //超声波检测最大值

//丝杆总脉冲数量
#define step_sum 204800

//上浮下潜丝杆半个行程
#define step_sx 2048

//定义电机转速，数字越小转速越高
#define speed_motor 10

#define motor_step_pin 2
#define motor_dir_pin 3

int step_now=0;


//左舵机
Servo myservo1;
//右舵机
Servo myservo2;
//尾巴舵机第一节
Servo myservo3;
//尾巴舵机第二节
Servo myservo4;

//新建一个Serial_p对象，rx:12,tx:13
//连接蓝牙的master
SoftwareSerial Serial_p(12,13);

int dis_u=30;

//蓝牙指令   a-上  b-下  c-左  d-右  e-停
char command_char='e';

char command_char_last='e';

int servo_jiaozhun[4]={0,0,0,0};

bool bizhang=0;

unsigned long time_last=0;

int dis(){
  
//  float dist=0;
//  for(int i=0;i<3;i++)
//  {
    digitalWrite(TRIGGER, LOW);
    delayMicroseconds(2);
    //将trigPin电平拉高10微秒
    digitalWrite(TRIGGER, HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIGGER, LOW);
    // 读取echoPin电平,以毫秒为单位返回声波往返时间
    // 计算距离
    Serial.println(millis());
    float distance = pulseIn(ECHO,HIGH)/58.0; //算成厘米 
    Serial.println(millis());
    Serial.print("distance=");
    Serial.println(distance);
    distance=(int(distance * 100.0))/100.0;//保留两位小数 
//    dist+=distance;
//  }
//  return int(dist/3.0);
  return int(distance);
}

void myservo_init(){
  
  myservo1.attach(servo1_pin);
  myservo2.attach(servo2_pin);
  myservo3.attach(servo3_pin);
  myservo4.attach(servo4_pin);

  myservo1.write(90+servo_jiaozhun[1]);
  myservo1.write(90+servo_jiaozhun[2]);
  myservo1.write(90+servo_jiaozhun[3]);
  myservo1.write(90+servo_jiaozhun[4]);
  delay(500);

  Serial.println("Servo init successful!");
}

//步进电机限位开关检测
bool swit1_jc(){
  if(digitalRead(swit1)==HIGH)
  {
    delay(3);
    if(digitalRead(swit1)==HIGH)
    {
      Serial.println("swit 1 on");
      return true;
    }
    else 
    return false;
  }
  return false;
}

//dir为方向，如果方向反了，就改变这个参数
void motor_step(bool dir){
  digitalWrite(motor_dir_pin,dir);
  digitalWrite(motor_step_pin,HIGH);
  delay(speed_motor);
  digitalWrite(motor_step_pin,LOW);
  delay(speed_motor);
}

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  Serial_p.begin(9600);
  //初始化电机引脚
  pinMode(motor_step_pin,OUTPUT);
  digitalWrite(motor_step_pin,LOW);
  pinMode(motor_dir_pin,OUTPUT);
  digitalWrite(motor_dir_pin,LOW);
  
  Serial.println("Motor pin init successful!");
  
  //初始化舵机引脚
  pinMode(servo1_pin,OUTPUT);
  digitalWrite(servo1_pin,LOW);

  pinMode(servo2_pin,OUTPUT);
  digitalWrite(servo2_pin,LOW);

  pinMode(servo1_pin,OUTPUT);
  digitalWrite(servo2_pin,LOW);

  pinMode(servo1_pin,OUTPUT);
  digitalWrite(servo2_pin,LOW);

  Serial.println("Servo pin init successful!");
  
  //初始化限位开关和水滴传感器引脚
  pinMode(swit1,INPUT);
  pinMode(water,INPUT);
  Serial.println("Swit1 pin and water pin init successful!");
  //初始化超声波传感器引脚
  pinMode(TRIGGER,OUTPUT);
  pinMode(ECHO,INPUT);
  Serial.println("TRIGGER pin and ECHO pin init successful!");

 
  //丝杆步进电机复位
//  while(!(swit1_jc()))
//  {
//    motor_step(true);
//  }
//    for(int i=0;i<step_sum/2;i++)
//      motor_step(false);
//  Serial.println("Step motor init successful!");

  myservo_init();
  
  time_last=millis();
  
  Serial.println("Robot init successful!");
  
}

void loop() {
  // put your main code here, to run repeatedly:
  if(Serial.available()>0)
    command_char=Serial.read();

   Serial.print("Read distance qian:");
   Serial.println(millis());
  
    if(millis()-time_last>=10000)
    {
      //读取前方障碍物距离
      dis_u=dis();
      time_last=millis();
    }
    
  Serial.print("Read distance zhong:");
  Serial.println(millis());
  //如果距离小于阈值，则当前命令改为左转
  if((dis_u>0)&&(dis_u<dis_max))
  {
    if((dis_u<dis_min)&&(bizhang==0))
    {
      command_char_last=command_char;
      command_char='c';
      bizhang=1;
    }
    if((dis_u>dis_min)&&(bizhang==1))
    {
      command_char=command_char_last;
      bizhang=0;
    }
  }

  Serial.print("Read distance hou:");
  Serial.println(millis());
    
    for(int i=0;i<30;i++)
    {
      Serial.print(millis());
      if(digitalRead(water)==0)
     {
        if(command_char=='a')
      {
        if(step_now>=-step_sx)
        {
          motor_step(true);
          step_now--;
        }
      }
     else if(command_char=='b')
     {
      if(step_now<=step_sx)
        {
          motor_step(false);;
          step_now++;
        }
     }
     else if(command_char=='c')
     {
//      Serial.print("servo 1 :");
//      Serial.print(90+servo_jiaozhun[1]);
//      Serial.print("servo 2 :");
//      Serial.print(90+servo_jiaozhun[2]-map(i,0,30,0,servo2_max));
      
      myservo1.write(90+servo_jiaozhun[1]);
      myservo2.write(90+servo_jiaozhun[2]-map(i,0,30,0,servo2_max));
     }
     else if(command_char=='d')
     {
//      Serial.print("servo 1 :");
//      Serial.print(90+servo_jiaozhun[1]+map(i,0,30,0,servo1_max));
//      Serial.print("servo 2 :");
//      Serial.print(90+servo_jiaozhun[2]);
      
      myservo1.write(90+servo_jiaozhun[1]+map(i,0,30,0,servo1_max));
      myservo2.write(90+servo_jiaozhun[2]);
     }
     else if(command_char=='e')
     {
//      Serial.print("servo 1 :");
//      Serial.print(90+servo_jiaozhun[1]+map(i,0,30,0,servo1_max));
//      Serial.print("servo 2 :");
//      Serial.print(90+servo_jiaozhun[2]-map(i,0,30,0,servo2_max));
      
      myservo1.write(90+servo_jiaozhun[1]+map(i,0,30,0,servo1_max));
      myservo2.write(90+servo_jiaozhun[2]-map(i,0,30,0,servo2_max));
     }
  
     
//      Serial.print("servo 3 :");
//      Serial.print(90+servo_jiaozhun[3]+map(i,0,30,0,servo3_max));
//      Serial.print("servo 4 :");
//      Serial.println(90+servo_jiaozhun[4]+map(i,0,30,0,servo3_max));
      
      myservo3.write(90+servo_jiaozhun[3]+map(i,0,30,0,servo3_max));
      myservo4.write(90+servo_jiaozhun[4]+map(i,0,30,0,servo3_max));
     }
     delay(servo_speed);
    }

    for(int i=0;i<60;i++)
    {
      Serial.print(millis());
       if(digitalRead(water)==0)
     {
        if(command_char=='a')
      {
        if(step_now>=-step_sx)
        {
          motor_step(true);
          step_now--;
        }
      }
     else if(command_char=='b')
     {
      if(step_now<=step_sx)
        {
          motor_step(false);
          step_now++;
        }
     }
     else if(command_char=='c')
     {
//      Serial.print("servo 1 :");
//      Serial.print(90+servo_jiaozhun[1]);
//      Serial.print("servo 2 :");
//      Serial.print(90+servo_jiaozhun[2]+map(i,0,60,servo2_min,servo2_max));
      
      myservo1.write(90+servo_jiaozhun[1]);
      myservo2.write(90+servo_jiaozhun[2]+map(i,0,60,servo2_min,servo2_max));
     }
     else if(command_char=='d')
     {
//      Serial.print("servo 1 :");
//      Serial.print(90+servo_jiaozhun[1]-map(i,0,60,servo1_min,servo1_max));
//      Serial.print("servo 2 :");
//      Serial.print(90+servo_jiaozhun[2]);
      
      myservo1.write(90+servo_jiaozhun[1]-map(i,0,60,servo1_min,servo1_max));
      myservo2.write(90+servo_jiaozhun[2]);
     }
     else if(command_char=='e')
     {
//      Serial.print("servo 1 :");
//      Serial.print(90+servo_jiaozhun[1]-map(i,0,60,servo1_min,servo1_max));
//      Serial.print("servo 2 :");
//      Serial.print(90+servo_jiaozhun[2]+map(i,0,60,servo2_min,servo2_max));
      
      myservo1.write(90+servo_jiaozhun[1]-map(i,0,60,servo1_min,servo1_max));
      myservo2.write(90+servo_jiaozhun[2]+map(i,0,60,servo2_min,servo2_max));
     }
  
    
//      Serial.print("servo 3 :");
//      Serial.print(90+servo_jiaozhun[3]-map(i,0,60,servo3_min,servo3_max));
//      Serial.print("servo 4 :");
//      Serial.println(90+servo_jiaozhun[4]-map(i,0,60,servo3_min,servo3_max));
      
      myservo3.write(90+servo_jiaozhun[3]-map(i,0,60,servo3_min,servo3_max));
      myservo4.write(90+servo_jiaozhun[4]-map(i,0,60,servo3_min,servo3_max));
     }
     delay(servo_speed);
    }

    for(int i=0;i<30;i++)
    {
      Serial.print(millis());
       if(digitalRead(water)==0)
     {
        if(command_char=='a')
      {
        if(step_now>=-step_sx)
        {
          motor_step(true);
          step_now--;
        }
      }
     else if(command_char=='b')
     {
        if(step_now<=step_sx)
        {
          motor_step(false);
          step_now++;
        }
     }
     else if(command_char=='c')
     {
//      Serial.print("servo 1 :");
//      Serial.print(90+servo_jiaozhun[1]);
//      Serial.print("servo 2 :");
//      Serial.print(90+servo_jiaozhun[2]-map(i,0,30,servo2_min,0));
      
      myservo1.write(90+servo_jiaozhun[1]);
      myservo2.write(90+servo_jiaozhun[2]-map(i,0,30,servo2_min,0));
     }
     else if(command_char=='d')
     {
//      Serial.print("servo 1 :");
//      Serial.print(90+servo_jiaozhun[1]+map(i,0,30,servo1_min,0));
//      Serial.print("servo 2 :");
//      Serial.print(90+servo_jiaozhun[2]);
      
      myservo1.write(90+servo_jiaozhun[1]+map(i,0,30,servo1_min,0));
      myservo2.write(90+servo_jiaozhun[2]);
     }
     else if(command_char=='e')
     {
//      Serial.print("servo 1 :");
//      Serial.print(90+servo_jiaozhun[1]+map(i,0,30,servo1_min,0));
//      Serial.print("servo 2 :");
//      Serial.print(90+servo_jiaozhun[2]-map(i,0,30,servo2_min,0));
      
      myservo1.write(90+servo_jiaozhun[1]+map(i,0,30,servo1_min,0));
      myservo2.write(90+servo_jiaozhun[2]-map(i,0,30,servo2_min,0));
     }
  
    
//      Serial.print("servo 3 :");
//      Serial.print(90+servo_jiaozhun[3]+map(i,0,30,servo3_min,0));
//      Serial.print("servo 4 :");
//      Serial.println(90+servo_jiaozhun[4]+map(i,0,30,servo4_min,0));
      
      myservo3.write(90+servo_jiaozhun[3]+map(i,0,30,servo3_min,0));
      myservo4.write(90+servo_jiaozhun[4]+map(i,0,30,servo4_min,0));
     }
     delay(servo_speed);
    }
}

电机测试： 

这个程序主要测试步进电机转向和步数。

#define stp 2
#define dir 3

//定义限位开关引脚
#define swit1 10

//步进电机限位开关检测
bool swit1_jc(){
  if(digitalRead(swit1)==HIGH)
  {
    delay(3);
    if(digitalRead(swit1)==HIGH)
    {
      Serial.println("swit 1 on");
      return true;
    }
    else 
    return false;
  }
  return false;
}

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  pinMode(stp,OUTPUT);
  digitalWrite(stp,LOW);
  pinMode(dir,OUTPUT);
  digitalWrite(dir,LOW);
  pinMode(swit1,INPUT);
  while(!swit1_jc())
    {
      digitalWrite(dir,true);
      digitalWrite(stp,HIGH);
      delay(10);
      digitalWrite(stp,LOW);
      delay(10);
    }
    for(int i=0;i<=500;i++)
    {
      digitalWrite(dir,false);
      digitalWrite(stp,HIGH);
      delay(10);
      digitalWrite(stp,LOW);
      delay(10);
    }
}

void loop() {
  // put your main code here, to run repeatedly:
 
}

Allen953
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基于STM32的ATK-PAJ7620手势识别模块详解与实例解析
m0_57781768的博客
06-20 935
ATK-PAJ7620是一款基于红外技术的手势识别模块，能够识别包括上、下、左、右、前、后、顺时针和逆时针等手势。模块内置手势检测算法，输出为I2C接口信号，便于与各种微控制器进行通信。本文详细介绍了基于STM32和ATK-PAJ7620手势识别模块实现手势识别的完整流程。通过I2C通信、手势识别和主程序等步骤，读者可以全面掌握手势识别系统的设计与实现方法。文章还提供了常见问题的解决方案和优化建议，旨在帮助开发者在实际应用中提高系统的性能和可靠性。
【8-13】手势传感器PAJ7620U2测试 实现手势控制无人机
知行
08-13 2515
手势传感器PAJ7620U2 识别手势：上、下、左、右、前、后、顺时针、逆时针、摇摆 识别距离：5-15cm 微雪资料 1.软件下载 程序 示例程序 BCM2835程序 文档 用户手册 原理图 调试程序 Arduino IDE 串口调试助手 2.准备工作 2.1 硬件 打开I2C接口 连线 2.2 软件库 sudo apt-get install python-pip sudo pip install RPi.GPIO sudo pip install spidev sudo apt-get instal
29，ATK-PAJ7620手势识别模块资料,paj7620u2手势识别原理,C,C++
09-10
通过使用本代码，你可以在32上实现手势识别
大一萌新の作品：蓝牙主从模式摇杆控制小车和副产品手机遥控小车
ChiShangying的博客
01-28 1473
（纯萌新，学习单片机半年了，这是寒假回家的作品，师从江科大，写博客纪录我实现后的经验）（比较粗略）蓝牙主从模式遥杆控制小车，我将其分为了三部分：1.让小车动 2.蓝牙主从连接与信号的发送接收 3.获取摇杆的状态并控制小车转向。
Arduino Uno + PAJ7620U2 实现手势识别控制LED灯工作
Love丶伊卡洛斯
11-10 6843
paj7620官方例程：https://www.arduino.cc/reference/en/libraries/gesture-paj7620/ wire库官方文档：https://www.arduino.cc/en/Reference/Wire
STM32驱动PAJ7620手势识别传感器
优信电子的博客
03-08 1万+
STM32驱动PAJ7620手势识别传感器 原相科技公司的 PAJ-7620U2 芯片内集成了光学数组式传感器单元，可以快速准确的对输入信号进行感应和输出处理。内置光源和环境光抑制滤波器，能在黑暗或低光环境下工作。它支持上、下、左、右、前、后、顺时针旋转、逆时针旋转和挥动的手势动作识别，以及支持物体接近检测等功能。可大致检测物体体积大小和亮度。使用IIC通信接口可达400KHz通信速率。 传感器内部自带 LED 驱动器，传...
PAJ7620_paj7620_PAJ7620U2_手势识别_
10-02
PAJ7620是一款专用于...总之，PAJ7620U2传感器为开发者提供了一种简单、高效的方式来实现非接触式的手势控制，通过理解和利用提供的驱动程序，可以轻松地集成到各种创新项目中，为用户带来更加直观和便捷的交互体验。
29，ATK-PAJ7620手势识别模块资料,paj7620u2手势识别原理,C,C++源码.zip
10-11
ATK-PAJ7620手势识别模块是一款基于Paj7620U2芯片的手势识别解决方案，广泛应用于智能家居、智能设备以及人机交互领域。该模块能够通过检测和解析用户的手势动作，实现非接触式的控制功能，极大地提高了人与智能设备...
paj7620u2_PAJ7620基于STC15编写_PAJ7620U2_和接近距离感应功能_可识别9种手势操作_经过验证_
10-02
标题中的“paj7620u2”指的是PAJ7620U2，这是一款红外线接近感应传感器芯片，常用于实现无接触式的交互功能。它能够检测到附近物体的存在，甚至可以识别特定的手势，从而在各种智能设备中提供非触碰式控制。在本项目...
手势传感器PAJ7620U2.zip_ATK-PAJ7620_PAJ7620.zip_paj7620paj7620u2_paj7
07-14
PAJ7620U2 基于stm32的 手势传感器
ATK-PAJ7620手势识别模块资料
07-25
ATK-PAJ7620手势识别模块资料开发资料。
STM32 PAJ7620U2手势识别模块(IIC通信）程序源码详解
热门推荐
夜半少年的博客
10-05 1万+
最近在自学设计下基于STM32的项目，想用手势识别模块做一点好玩的，做个手势控制家居设备开关，另外正好借此巩固I²C 通信。因此，我想借这个机会在这里和大家分享一下自己学习时的所思所感吧 话不多说，先上硬货。 STM32F103 板 实验目的: 学习ATK-PAJ7620U2手势识别模块的使用,实现9个手势识别（GS）的检测功能，输出结果通过USART1显示在串口调试助手中。加入手势识别轮询检测的中断服务程序：
PAJ7620u2手势模块
HHH的博客
05-16 5982
一、简介：手势传感器，捕捉手势的芯片。 1、内置光源和环境光源抑制滤波器集成的led，镜头和手势感测器在一个小的立方体模组，能在黑暗或低光环境下工作。 2、内置9个手势类型：上，下，左，右，前，后，顺时针旋转，逆时针旋转，挥动。支持输出中断。 3、支持接近检测功能，检测物体体积大小和亮度。 4、分辨率：60x60 pixels ，每个像素的大小是：20x20 um2 ， 最大支持的速率：720fps。 5、模式：gesture / cursor / image modes 6、控制速度：...
atk-paj7620手势传感器驱动
锅锅的博客
10-11 2102
ATK-PAJ7620是一款高性能手势识别传感器模块。该模块采用原相科技（Pixart）公司的 PAJ7620U2 芯片，芯片内部集成了光学数组式传感器，以使复杂的手势和光标模式输出，自带九种手势 识别，支持上、下、左、右、前、后、顺时针旋转、逆时针旋转和挥动的手势动作识别，以 及支持物体接近检测等功能 代码示例 //手势传感器读取函数 //参数 手势结果 /* #define GES_UP BIT(0) //向上 #define GES_DOWM BIT(
PAJ7620U2手势识别——唤醒操作(1)
weixin_43828944的博客
03-27 5119
基于FPGA的PAJ7620手势识别——唤醒操作实现
BLE蓝牙模块主从一体功能应用场景详解
2301_81199294的博客
01-04 608
对于刚出生的新生儿，父母想要密切监视他们家的空气质量，于是购买了多个传感器散布在房间周围，中央显示屏显示空气质量，这是常规的的解决方案，如果窗户意外地打开，父母在楼上可能听不到中央单位的警报报警。主从一体功能有广泛的应用基础，为蓝牙模块的应用扩展提供了可能，后续在无线抄表、无线传感、智能家居、智能控制、工业遥控、遥测、智能楼宇、智能建筑、自动化数据采集、健康传感器、智能穿戴、智能机器人、无线传感 、电子标签等领域都有大量的应用。在众多工作模式中，主从一体工作模式是最常用的，也是目前较为流行的一种。
手势识别模块PAJ7620的简单应用
最新发布
xiaobuding的博客
03-22 2627
PAJ7620U2 芯片是原相科技（PixArt）公司推出的一款光学数组式传感器，芯片内置集成光源和环境光抑制滤波的 LED、镜头和手势识别传感器，能在黑暗或低光环境下工作，同时内置了支持九种手势的手势识别和物体接近检测功能。手势识别模块使用II2C接口，使用相应的库函数即可编程控制，手势识别模块返回的信号可用作为机器人接收的控制信号，从而实现对机器人的控制。内置的识别算法相当智能，能够把双手从生硬的按键中解放出来。
PAJ7620U2手势识别——配置0x00寄存器(3)
weixin_43828944的博客
03-28 2431
PAJ7620U2手势识别——配置0x00寄存器实现
单片机 PAJ7620U2 IIC协议 9种手势
jianqiang.xue
04-13 3427
由手势辨识传感器、LED和镜头组合而成的小尺寸模组可辨识单一物件之手势，并具有手势完成之自动判断功能具有两种模式：「手势模式」或「游标模式」手势模式：内建多达9种手势游标模式：可输出追踪物体的位置、尺寸和亮度的即时数据工作距离最多可达20公分。
PAJ7620U2手势识别STM32例程
07-15
你可以在CSDN上找到PAJ7620U2手势识别的STM32例程。以下是一个简单的例子： ```c #include "stm32f10x.h" #include "i2c.h" #include "paj7620u2.h" void PAJ7620U2_Init(void) { I2C_Init(); // 初始化PAJ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Allen953

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值