四足笔记

最新推荐文章于 2023-12-17 20:10:20 发布
最新推荐文章于 2023-12-17 20:10:20 发布
阅读量274 收藏 1
点赞数
分类专栏： STM32，MCU 文章标签： stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuiyihang0981/article/details/105980103
版权

robot.c

 

#include "robot.h"
#include "delay.h"
/*
   __________ __________ _________________
  |1_____)0                  4(______5|
  |__|       |left FRONT right|        |__|
             |                |
             |                |
             |                |
   _________ |                | __________
  |7_____)6     ___________   2(______3|
  |__|                                 |__|
*/
void action(int num,int turn,int raise,u16 measure_time,bool move)
{
	if(MOVE==move)
	PCA_MG9XX(num+1,0,raise,1,1);//抬起
	PCA_MG9XX(num,0,turn,1,1);//哪个,开始角度[默认0]，结束角度，模式，速度	
	if(MOVE==move)
	{
		if(num==0)			
			PCA_MG9XX(num+1,0,NOR_LU_2,1,1);//放下
		else if(num==6)
			PCA_MG9XX(num+1,0,NOR_LD_2,1,1);
		else if(num==2)
				PCA_MG9XX(num+1,0,NOR_RD_2,1,1);
		else
				PCA_MG9XX(num+1,0,NOR_RU_2,1,1);
	}
}

void home()
{
	action(0,NOR_LU_1,NOR_LU_2,10,STILL);
	action(2,NOR_RD_1,NOR_RD_2,10,STILL);
	action(4,NOR_RU_1,NOR_RU_2,10,STILL);
	action(6,NOR_LD_1,NOR_LD_2,10,STILL);
	//左上脚0-90向前，90-120高度下降--0
	//右下脚90-120向前，90-0高度下降--2//
	//右上脚90-120向前，90-0高度下降--4
	//左下脚0-90向前，90-120高度下降--6
}
void LowHome()//低姿态的原位置
{
	PCA_MG9XX(0,0,NOR_LU_1,2,1);
	PCA_MG9XX(2,0,NOR_RD_1,2,1);
	PCA_MG9XX(4,0,NOR_RU_1,2,1);
	PCA_MG9XX(6,0,NOR_LD_1,2,1);//锁定关节回归角度
	delay_ms(50);
	PCA_MG9XX(1,0,L_FUNUP,0,1);
	PCA_MG9XX(3,0,R_FUNUP,0,1);
	PCA_MG9XX(5,0,R_FUNUP,0,1);
	PCA_MG9XX(7,0,L_FUNUP,0,1);
	delay_ms(50);
}
void say_hello()//3,7可用
{
	int i;
	PCA_MG9XX(5,0,HELLO,0,0);
	for(i=0;i<8;i++)
	{
		PCA_MG9XX(4,0,90,1,5);
		delay_ms(20);
		PCA_MG9XX(4,0,120,1,5);
		delay_ms(20);
	}
	PCA_MG9XX(4,0,NOR_RU_1,0,0);
	PCA_MG9XX(5,0,NOR_RU_2,0,0);
}
//蜉蝣形式
void swim()
{
			action(0,WALK_F_L,L_UP,1,MOVE);
			action(4,WALK_F_R4,R_UP,1,MOVE);
			PCA_MG9XX(0,0,BACK_FL,1,10);//90
			PCA_MG9XX(4,0,BACK_FL,1,10);
			action(6,WALK_F_L4,UP_ADD,1,MOVE);
			action(2,WALK_F_R,UP_DE,1,MOVE);
			PCA_MG9XX(2,0,NOR_RD_1,1,10);//回归90度
			PCA_MG9XX(6,0,NOR_LD_1,1,10);//回归90度
}
void DogWalk()//3---7//1--5
{
	int i;
		//前后腿锁定180
	PCA_MG9XX(0,0,90,1,1);
	PCA_MG9XX(2,0,90,1,1);
	PCA_MG9XX(4,0,90,1,1);
	PCA_MG9XX(6,0,90,1,1);//锁定内关节回归角度
	
	PCA_MG9XX(1,0,90,1,1);
	PCA_MG9XX(3,0,85,1,1);//弥补机械上的误差
	PCA_MG9XX(5,0,90,1,1);
	PCA_MG9XX(7,0,100,1,1);//锁定外关节回归角度
	
	for(i=0;i<40;i++)
	{
		PCA_MG9XX(1,0,60,0,1);//1,5折叠
		PCA_MG9XX(5,0,60,0,1);
		delay_ms(50);
		PCA_MG9XX(1,0,90,0,1);
		PCA_MG9XX(5,0,90,0,1);
		delay_ms(50);
		PCA_MG9XX(3,0,55,0,1);//3，7
		PCA_MG9XX(7,0,70,0,1);
		delay_ms(50);
		PCA_MG9XX(3,0,85,0,1);
		PCA_MG9XX(7,0,100,0,1);
		delay_ms(50);
		
		//sportmini行走,有问题
//		PCA_MG9XX(1,0,60,0,1);//1,3折叠
//		PCA_MG9XX(3,0,55,0,1);
//		delay_ms(50);
//		PCA_MG9XX(1,0,90,0,1);
//		PCA_MG9XX(3,0,85,0,1);
//		delay_ms(50);
//		PCA_MG9XX(5,0,60,0,1);//5，7
//		PCA_MG9XX(7,0,70,0,1);
//		delay_ms(50);
//		PCA_MG9XX(5,0,90,0,1);
//		PCA_MG9XX(7,0,100,0,1);	
//		delay_ms(50);
	}
	home();
}
void jump()//跳跃
{
	//前后腿锁定180
	int i;
	PCA_MG9XX(0,0,90,1,1);
	PCA_MG9XX(2,0,90,1,1);
	PCA_MG9XX(4,0,90,1,1);
	PCA_MG9XX(6,0,90,1,1);//锁定内关节回归角度
	
	PCA_MG9XX(1,0,90,1,1);
	PCA_MG9XX(3,0,85,1,1);//弥补机械上的误差
	PCA_MG9XX(5,0,90,1,1);
	PCA_MG9XX(7,0,100,1,1);//锁定外关节回归角度
	for(i=0;i<50;i++)
	{
//		PCA_MG9XX(1,0,60,0,1);//1,7向内弯曲
//		PCA_MG9XX(7,0,60,0,1);
//		delay_ms(50);
//		PCA_MG9XX(1,0,90,0,1);
//		PCA_MG9XX(7,0,100,0,1);
//		delay_ms(50);
//		PCA_MG9XX(3,0,60,0,1);//3，5向外弯曲
//		PCA_MG9XX(5,0,60,0,1);
//		delay_ms(50);
//		PCA_MG9XX(3,0,85,0,1);
//		PCA_MG9XX(5,0,90,0,1);	
//		delay_ms(50);
		
		PCA_MG9XX(1,0,60,0,1);//1,7向内弯曲
		PCA_MG9XX(7,0,60,0,1);
		delay_ms(50);
		PCA_MG9XX(3,0,60,0,1);//3，5向外弯曲
		PCA_MG9XX(5,0,60,0,1);
		delay_ms(50);
		PCA_MG9XX(1,0,90,0,1);
		PCA_MG9XX(7,0,100,0,1);
		PCA_MG9XX(3,0,85,0,1);
		PCA_MG9XX(5,0,90,0,1);	
		delay_ms(50);
	}
	home();
}

void jog(int arg,bool dir)//小跑
{
	if(FORWARD==dir)
	{
		//两脚支撑
		PCA_MG9XX(1,0,L_UP,0,1);//抬脚
		PCA_MG9XX(3,0,UP_DE,0,1);
		delay_ms(30);
		PCA_MG9XX(0,0,60-arg,0,1);//转动 WALK_F_L
		PCA_MG9XX(2,0,60+arg,0,1);//WALK_F_R
		delay_ms(30);
		PCA_MG9XX(1,0,NOR_LU_2,0,1);//放脚
		PCA_MG9XX(3,0,NOR_RD_2,0,1);
		delay_ms(30);
		PCA_MG9XX(0,0,NOR_LU_1,0,1);//转动20--90 BACK_FL
		PCA_MG9XX(2,0,NOR_RD_1,0,1);//40//100--60
		delay_ms(30);
		
		PCA_MG9XX(5,0,R_UP,0,1);//抬脚
		PCA_MG9XX(7,0,UP_ADD,0,1);
		delay_ms(30);
		PCA_MG9XX(4,0,120+arg,0,1);//转动WALK_F_R4  160
		PCA_MG9XX(6,0,120-arg,0,1);//WALK_F_L4   80
		delay_ms(30);
		PCA_MG9XX(5,0,NOR_RU_2,0,1);//放脚
		PCA_MG9XX(7,0,NOR_LD_2,0,1);
		delay_ms(30);
		PCA_MG9XX(4,0,NOR_RU_1,0,1);//转动 BACK_FL
		PCA_MG9XX(6,0,NOR_LD_1,0,1);
		delay_ms(30);
	}else
	{
		//两脚支撑
		PCA_MG9XX(1,0,L_UP,0,1);//抬脚
		PCA_MG9XX(3,0,UP_DE,0,1);
		delay_ms(30);
		PCA_MG9XX(0,0,60+arg,0,1);//转动 WALK_F_L
		PCA_MG9XX(2,0,60-arg,0,1);//WALK_F_R
		delay_ms(30);
		PCA_MG9XX(1,0,NOR_LU_2,0,1);//放脚
		PCA_MG9XX(3,0,NOR_RD_2,0,1);
		delay_ms(30);
		PCA_MG9XX(0,0,NOR_LU_1,0,1);//转动20--90 BACK_FL
		PCA_MG9XX(2,0,NOR_RD_1,0,1);//40//100--60
		delay_ms(30);
		
		PCA_MG9XX(5,0,R_UP,0,1);//抬脚
		PCA_MG9XX(7,0,UP_ADD,0,1);
		delay_ms(30);
		PCA_MG9XX(4,0,120-arg,0,1);//转动WALK_F_R4  160
		PCA_MG9XX(6,0,120+arg,0,1);//WALK_F_L4   80
		delay_ms(30);
		PCA_MG9XX(5,0,NOR_RU_2,0,1);//放脚
		PCA_MG9XX(7,0,NOR_LD_2,0,1);
		delay_ms(30);
		PCA_MG9XX(4,0,NOR_RU_1,0,1);//转动 BACK_FL
		PCA_MG9XX(6,0,NOR_LD_1,0,1);
		delay_ms(30);
	}
}
void walk(int turn,int raise,bool dir)//0--2--4--6//蜘蛛单步缓慢走
{
	int i;
		//左上脚60度以下向前，90-120高度下降--0
		//右下脚60度以上向前，90-0高度下降--2//
		//右上脚120以上向前，90-0高度下降--4
		//左下脚120以下向前，90-120高度下降--6
	for(i=0;i<30;i++)
	{
		if(FORWARD==dir)
		{		
			action(0,WALK_F_L,L_UP,1,MOVE);//1腿迈出
			PCA_MG9XX(0,0,BACK_FL,1,1);//90//1腿回来
			action(2,WALK_F_R,UP_DE,1,MOVE);
			PCA_MG9XX(2,0,NOR_RD_1,1,1);//回归90度
			action(4,WALK_F_R4,R_UP,1,MOVE);
			PCA_MG9XX(4,0,BACK_FL,1,1);
			action(6,WALK_F_L4,UP_ADD,1,MOVE);
			PCA_MG9XX(6,0,NOR_LD_1,1,1);//回归90度
		}else
		{

		}
	}
}
void Turn(int arg,bool dir)//0--6--2--4
{
		if(LEFT==dir)
		{	
			//测试内调---完美
			PCA_MG9XX(1,0,L_UP,0,1);//抬脚
			PCA_MG9XX(3,0,UP_DE,0,1);
			delay_ms(30);
			PCA_MG9XX(0,0,60+arg,0,1);//转动 TURN_B_L1
			PCA_MG9XX(2,0,60+arg,0,1);//TURN_F_R2
			delay_ms(30);
			PCA_MG9XX(1,0,NOR_LU_2,0,1);//放脚
			PCA_MG9XX(3,0,NOR_RD_2,0,1);
			delay_ms(30);			
			PCA_MG9XX(5,0,R_UP,0,1);//抬脚
			PCA_MG9XX(7,0,UP_ADD,0,1);
			delay_ms(30);
			PCA_MG9XX(4,0,120+arg,0,1);//转动 TURN_F_R1
			PCA_MG9XX(6,0,120+arg,0,1);//TURN_B_L2
			delay_ms(30);
			PCA_MG9XX(5,0,NOR_RU_2,0,1);//放脚
			PCA_MG9XX(7,0,NOR_LD_2,0,1);
			delay_ms(30);
			PCA_MG9XX(0,0,NOR_LU_1,0,1);//转动
			PCA_MG9XX(2,0,NOR_RD_1,0,1);
			PCA_MG9XX(4,0,NOR_RU_1,0,1);//转动
			PCA_MG9XX(6,0,NOR_LD_1,0,1);
			delay_ms(60);
		}else//0--6--2--4
		{
			PCA_MG9XX(1,0,L_UP,0,1);//抬脚
			PCA_MG9XX(3,0,UP_DE,0,1);
			delay_ms(30);
			PCA_MG9XX(0,0,60-arg,0,1);//转动 TURN_F_L1
			PCA_MG9XX(2,0,60-arg,0,1);//TURN_B_R2
			delay_ms(30);
			PCA_MG9XX(1,0,NOR_LU_2,0,1);//放脚
			PCA_MG9XX(3,0,NOR_RD_2,0,1);
			delay_ms(30);			
			PCA_MG9XX(5,0,R_UP,0,1);//抬脚
			PCA_MG9XX(7,0,UP_ADD,0,1);
			delay_ms(30);
			PCA_MG9XX(4,0,60+arg,0,1);//转动TURN_B_R1
			PCA_MG9XX(6,0,60+arg,0,1);//TURN_F_L2
			delay_ms(30);
			PCA_MG9XX(5,0,NOR_RU_2,0,1);//放脚
			PCA_MG9XX(7,0,NOR_LD_2,0,1);
			delay_ms(30);
			PCA_MG9XX(0,0,NOR_LU_1,0,1);//转动
			PCA_MG9XX(2,0,NOR_RD_1,0,1);
			PCA_MG9XX(4,0,NOR_RU_1,0,1);//转动
			PCA_MG9XX(6,0,NOR_LD_1,0,1);
			delay_ms(60);

		}
}
void up_down()//0--6--2--4
{
	int i;
	PCA_MG9XX(0,0,NOR_LU_1,2,1);
	PCA_MG9XX(2,0,NOR_RD_1,2,1);
	PCA_MG9XX(4,0,NOR_RU_1,2,1);
	PCA_MG9XX(6,0,NOR_LD_1,2,1);//锁定关节回归角度
	for(i=0;i<15;i++)
	{
		//左上脚60度以下向前，90-120高度下降--0
		//右下脚60度以上向前，90-0高度下降--2//
		//右上脚120以上向前，90-0高度下降--4
		//左下脚120以下向前，90-120高度下降--6
		PCA_MG9XX(1,0,L_FUNUP,0,1);
		PCA_MG9XX(3,0,R_FUNUP,0,1);
		PCA_MG9XX(5,0,R_FUNUP,0,1);
		PCA_MG9XX(7,0,L_FUNUP,0,1);//锁定关节回归角度
		delay_ms(150);
		PCA_MG9XX(1,0,120,0,1);
		PCA_MG9XX(3,0,60,0,1);
		PCA_MG9XX(5,0,60,0,1);
		PCA_MG9XX(7,0,120,0,1);//锁定关节回归角度
		delay_ms(150);
	}
	home();
}
void Akid()
{
	int i;
	LowHome();
	//轮流上下
	for(i=0;i<15;i++)
	{
		PCA_MG9XX(1,0,L_FUNUP,1,10);
		delay_ms(50);
		PCA_MG9XX(1,0,130,1,10);
		delay_ms(50);
		PCA_MG9XX(3,0,R_FUNUP,1,10);
		delay_ms(50);
		PCA_MG9XX(3,0,50,1,10);
		delay_ms(50);
		PCA_MG9XX(5,0,R_FUNUP,1,10);
		delay_ms(50);
		PCA_MG9XX(5,0,50,1,10);
		delay_ms(50);
		
		PCA_MG9XX(7,0,L_FUNUP,1,10);//锁定关节回归角度
		delay_ms(50);
		PCA_MG9XX(7,0,130,1,10);//锁定关节回归角度
		delay_ms(50);

	}
}
//void Spider::wiring()
//{

//	
//}

robot.h

#ifndef __ROBOT_HPP
#define __ROBOT_HPP
#include "stm32_pca9685.h"
#include "delay.h"
#include "sys.h"
/*
   __________ __________ _________________
  |1_____)0                  4(______5|
  |__|       |left FRONT right|        |__|
             |                |
             |                |
             |                |
   _________ |                | __________
  |7_____)6     ___________   2(______3|
  |__|                                 |__|


*/
typedef  enum _BOOL
{
	false,
	true
}bool;
#define NOR_LU_1    60  //左上1关节常态   
#define NOR_LU_2    90//105///0

#define NOR_LD_1    120
#define NOR_LD_2    100//1086

#define NOR_RU_1    120
#define NOR_RU_2    90//72//4

#define NOR_RD_1    60
#define NOR_RD_2    85//78//2

#define BACK_FL     90
#define BACK_FR     90


//行走步距50
#define WALK_F_L   20//左向前60-15
#define WALK_F_R   100//右向前---2[原态60]
#define WALK_F_L4  80//左向前
#define WALK_F_R4  160///120+15
//转向
//左转
#define TURN_B_L1   90//左上脚向后    0
#define TURN_B_L2   150//左下脚向后   6
#define TURN_F_R2   90//右下脚向前    2
#define TURN_F_R1   150//右上脚向前    4

//右转
#define TURN_F_L1   30//左上脚向前   0
#define TURN_F_L2   90//左下脚向前   6
#define TURN_B_R1   90//右上脚向后   4
#define TURN_B_R2   30//右下脚向后   2

//抬脚放脚使用
#define L_UP          120//130//普通情况使用
#define L_DOWN				90//108//支撑
#define UP_ADD          130//直立加了10的特殊情况使用
#define DOWN_ADD				95
#define UP_DE          55//右下角使用
#define DOWN_DE				85


#define L_FUNUP       160
#define R_FUNUP       20
#define L_FUNDOWN     90
#define R_FUNDOWN     90


#define R_UP          60//50//抬起
#define R_DOWN				90//72//支撑

#define HELLO         40

#define FLY_BACK    90//关节回归角度      
#define FORWARD     true
#define BACK        false
	
#define MOVE     true
#define STILL    false
	
#define LEFT     true
#define RIGHT    false
void home(void);//原位置
void LowHome(void);
void action(int num,int turn,int raise,u16 measure_time,bool move);//某一条腿的封装
void walk(int turn,int raise,bool dir);//前进
void Turn(int arg,bool dir);//转向
void up_down(void);//原地上下
void say_hello(void);//打招呼
void swim(void);//浮游前进
void jump(void);//跳跃
void jog(int arg,bool dir);//小跑
void stroll(void);//踱步
void DogWalk(void);//小狗形态行走
void wiring(void);//腿轮流扭动
void Akid(void);//像小孩子一样调皮

#endif

pca9685.c

#include "stm32_pca9685.h"
#include "delay.h"
#include "math.h"



void pca_write(u8 adrr,u8 data)//向PCA写数据,adrrd地址,data数据
{ 
	IIC_Start();
	
	IIC_Send_Byte(pca_adrr);
	IIC_Wait_Ack();
	
	IIC_Send_Byte(adrr);
	IIC_Wait_Ack();
	
	IIC_Send_Byte(data);
	IIC_Wait_Ack();
	
	IIC_Stop();
}

u8 pca_read(u8 adrr)//从PCA读数据
{
	u8 data;
	IIC_Start();
	
	IIC_Send_Byte(pca_adrr);
	IIC_Wait_Ack();
	
	IIC_Send_Byte(adrr);
	IIC_Wait_Ack();
	
	IIC_Start();
	
	IIC_Send_Byte(pca_adrr|0x01);
	IIC_Wait_Ack();
	
	data=IIC_Read_Byte(0);
	IIC_Stop();
	
	return data;
}


void pca_setfreq(float freq)//设置PWM频率
{
		u8 prescale,oldmode,newmode;
		double prescaleval;
		freq *= 0.92; 
		prescaleval = 25000000;
		prescaleval /= 4096;
		prescaleval /= freq;
		prescaleval -= 1;
		prescale =floor(prescaleval + 0.5f);

		oldmode = pca_read(pca_mode1);
	
		newmode = (oldmode&0x7F) | 0x10; // sleep
	
		pca_write(pca_mode1, newmode); // go to sleep
	
		pca_write(pca_pre, prescale); // set the prescaler
	
		pca_write(pca_mode1, oldmode);
		delay_ms(2);
	
		pca_write(pca_mode1, oldmode | 0xa1); 
}

/*num:舵机PWM输出引脚0~15，on:PWM上升计数值0~4096,off:PWM下降计数值0~4096
一个PWM周期分成4096份，由0开始+1计数，计到on时跳变为高电平，继续计数到off时
跳变为低电平，直到计满4096重新开始。所以当on不等于0时可作延时,当on等于0时，
off/4096的值就是PWM的占空比。*/
void pca_setpwm(u8 num, u32 on, u32 off)
{
		pca_write(LED0_ON_L+4*num,on);
		pca_write(LED0_ON_H+4*num,on>>8);
		pca_write(LED0_OFF_L+4*num,off);
		pca_write(LED0_OFF_H+4*num,off>>8);
}


/*
	函数作用：初始化舵机驱动板
	参数：1.PWM频率
		  2.初始化舵机角度
*/
void PCA_MG9XX_Init(float hz,u8 angle)
{
	u32 off=0;
	IIC_Init();
	pca_write(pca_mode1,0x0);
	pca_setfreq(hz);//设置PWM频率
	off=(u32)(145+angle*2.4);
	pca_setpwm(0,0,off);pca_setpwm(1,0,off);pca_setpwm(2,0,off);pca_setpwm(3,0,off);
	pca_setpwm(4,0,off);pca_setpwm(5,0,off);pca_setpwm(6,0,off);pca_setpwm(7,0,off);
	pca_setpwm(8,0,off);pca_setpwm(9,0,off);pca_setpwm(10,0,off);pca_setpwm(11,0,off);
	pca_setpwm(12,0,off);pca_setpwm(13,0,off);pca_setpwm(14,0,off);pca_setpwm(15,0,off);
	delay_ms(500);
}

/*
	函数作用：控制舵机转动；
	参数：1.输出端口，可选0~15；
		  2.起始角度，可选0~180；
		  3.结束角度，可选0~180；
		  4.模式选择，0 表示函数内无延时，调用时需要在函数后另外加延时函数，且不可调速，第五个参数可填任意值；
					  1 表示函数内有延时，调用时不需要在函数后另外加延时函数，且不可调速，第五个参数可填任意值；
					  2 表示速度可调，第五个参数表示速度值；
		  5.速度，可填大于 0 的任意值，填 1 时速度最快，数值越大，速度越小；
	注意事项：模式 0和1 的速度比模式 2 的最大速度大；
*/
void PCA_MG9XX(u8 num,u8 start_angle,u8 end_angle,u8 mode,u8 speed)
{
	u8 i;
	u32 off=0;
	switch(mode)
	{
		case 0:
			off=(u32)(158+end_angle*2.2);
			pca_setpwm(num,0,off);
			break;
		case 1:
			off=(u32)(158+end_angle*2.2);
			pca_setpwm(num,0,off);
			if(end_angle>start_angle){delay_ms((u16)((end_angle-start_angle)*2.7));}
			else{delay_ms((u16)((start_angle-end_angle)*2.7));}
			break;
		case 2:
			if(end_angle>start_angle)
			{
				for(i=start_angle;i<=end_angle;i++)
				{
					off=(u32)(158+i*2.2);
					pca_setpwm(num,0,off);
					delay_ms(2);
					delay_us(speed*250);
				}
			}
			else if(start_angle>end_angle)
			{
				for(i=start_angle;i>=end_angle;i--)
				{
					off=(u32)(158+i*2.2);
					pca_setpwm(num,0,off);
					delay_ms(2);
					delay_us(speed*250);
				}
			}
			break;
	}
}


//----------------
//初始化IIC
void IIC_Init(void)
{					     
	GPIO_InitTypeDef GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(	RCC_APB2Periph_GPIOB, ENABLE );	//使能GPIOB时钟
	   
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //推挽输出
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
	GPIO_SetBits(GPIOB,GPIO_Pin_8|GPIO_Pin_9); 	//PB6,PB7 输出高
}
//产生IIC起始信号
void IIC_Start(void)
{
	SDA_OUT();     //sda线输出
	IIC_SDA=1;	  	  
	IIC_SCL=1;
	delay_us(4);
 	IIC_SDA=0;//START:when CLK is high,DATA change form high to low 
	delay_us(4);
	IIC_SCL=0;//钳住I2C总线，准备发送或接收数据 
}	  
//产生IIC停止信号                                                                                                                                            
void IIC_Stop(void)
{
	SDA_OUT();//sda线输出
	IIC_SCL=0;
	IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
 	delay_us(4);
	IIC_SCL=1; 
	IIC_SDA=1;//发送I2C总线结束信号
	delay_us(4);							   	
}
//等待应答信号到来
//返回值：1，接收应答失败
//        0，接收应答成功
u8 IIC_Wait_Ack(void)
{
	u8 ucErrTime=0;
	SDA_IN();      //SDA设置为输入  
	IIC_SDA=1;delay_us(1);	   
	IIC_SCL=1;delay_us(1);	 
	while(READ_SDA)
	{
		ucErrTime++;
		if(ucErrTime>250)
		{
			IIC_Stop();
			return 1;
		}
	}
	IIC_SCL=0;//时钟输出0 	   
	return 0;  
} 
//产生ACK应答
void IIC_Ack(void)
{
	IIC_SCL=0;
	SDA_OUT();
	IIC_SDA=0;
	delay_us(2);
	IIC_SCL=1;
	delay_us(2);
	IIC_SCL=0;
}
//不产生ACK应答		    
void IIC_NAck(void)
{
	IIC_SCL=0;
	SDA_OUT();
	IIC_SDA=1;
	delay_us(2);
	IIC_SCL=1;
	delay_us(2);
	IIC_SCL=0;
}					 				     
//IIC发送一个字节
//返回从机有无应答
//1，有应答
//0，无应答			  
void IIC_Send_Byte(u8 txd)
{                        
    u8 t;   
	SDA_OUT(); 	    
    IIC_SCL=0;//拉低时钟开始数据传输
    for(t=0;t<8;t++)
    {              
        IIC_SDA=(txd&0x80)>>7;
        txd<<=1; 	  
		delay_us(2);   //对TEA5767这三个延时都是必须的
		IIC_SCL=1;
		delay_us(2); 
		IIC_SCL=0;	
		delay_us(2);
    }	 
} 	    
//读1个字节，ack=1时，发送ACK，ack=0，发送nACK   
u8 IIC_Read_Byte(unsigned char ack)
{
	unsigned char i,receive=0;
	SDA_IN();//SDA设置为输入
    for(i=0;i<8;i++ )
	{
        IIC_SCL=0; 
        delay_us(2);
		IIC_SCL=1;
        receive<<=1;
        if(READ_SDA)receive++;   
		delay_us(1); 
    }					 
    if (!ack)
        IIC_NAck();//发送nACK
    else
        IIC_Ack(); //发送ACK   
    return receive;
}

pca9685.h

#ifndef __STM32PCA9685_H
#define __STM32PCA9685_H	

#include "stm32f10x.h"


#define pca_adrr 0x80

#define pca_mode1 0x0
#define pca_pre 0xFE

#define LED0_ON_L 0x6
#define LED0_ON_H 0x7
#define LED0_OFF_L 0x8
#define LED0_OFF_H 0x9

#define jdMIN  115 // minimum
#define jdMAX  590 // maximum
#define jd000  130 //0度对应4096的脉宽计数值
#define jd180  520 //180度对应4096的脉宽计算值



//IO方向设置
 
#define SDA_IN()  {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)8<<28;}
#define SDA_OUT() {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)3<<28;}

//IO操作函数	 
#define IIC_SCL    PBout(6) //SCL
#define IIC_SDA    PBout(7) //SDA	 
#define READ_SDA   PBin(7 )  //输入SDA 





void pca_write(u8 adrr,u8 data);
u8 pca_read(u8 adrr);
void PCA_MG9XX_Init(float hz,u8 angle);
void pca_setfreq(float freq);
void pca_setpwm(u8 num, u32 on, u32 off);
void PCA_MG9XX(u8 num,u8 start_angle,u8 end_angle,u8 mode,u8 speed);




//IIC所有操作函数
void IIC_Init(void);                //初始化IIC的IO口				 
void IIC_Start(void);				//发送IIC开始信号
void IIC_Stop(void);	  			//发送IIC停止信号
void IIC_Send_Byte(u8 txd);			//IIC发送一个字节
u8 IIC_Read_Byte(unsigned char ack);//IIC读取一个字节
u8 IIC_Wait_Ack(void); 				//IIC等待ACK信号
void IIC_Ack(void);					//IIC发送ACK信号
void IIC_NAck(void);				//IIC不发送ACK信号


#endif

 

shuiyihang0981
关注
专栏目录
PCA9685 多舵机控制器的编程
曾立文的博客
01-08 1万+
本文介绍通过写入寄存器的方法实现对PCA9685 的控制。 PCA9685 模块 制作机器人，舵机就是让它动起来的关键器件。而又由于通常设计中为了不影响处理器供电或者主控功率不够，都会另外制作一块板子用作舵机驱动，也叫舵机控制板。 PCA9685是一款用于产生16路PWM信号的LED控制芯片， 采用I2C总线与主控芯片进行通信。PCA9685具有可以产生16路PWM脉冲、控制独立精准、编程简单灵活等特点， 以其为基础实现的舵机控制能够有限减少硬件和软件设计的复杂度， 具有高可靠性 PCA9685的用途.
机器人学习-matlab四足机器人控制仿真
weixin_44609769的博客
07-12 5020
《机器人学，机器视觉与控制》学习笔记 使用工具箱版本9.10 题目与解决思路： 【1】. 通过减少复位期间的抬腿高度来缩短复位的轨迹 Z轴向下，为了减小复位器件的抬腿高度，应当缩小△Z，故可以将示例程序中zu值调大。 【2】. 增加腿的步幅 腿的步幅可由改变x方向上腿前进和后退运动的极限来达到，令xf = 7; xb = -xf;即可。 ...
STM32 (STM32F103C8T6) 用PCA9685控制舵机和Led,代码极简可用
seatest的专栏
12-16 4836
  我缺少积分，请各位下载此代码给点积分。     我的博客：https://blog.csdn.net/seatest     STM32F103C8T6  专用。使用IIC1通道，对应针脚：PA6,PA7     其他STM32板子，请修改默认针脚     代码自改，简单方便，亲测可用，不仅可以控制舵机，还可以直接控制Led亮度     stm32_pca9685只有一个c文件和h文件，不...
【2023海光杯】“智能储物柜系统”电控部分
最新发布
Akiiiira的博客
12-17 520
在代码实现部分会给出设计理念和分析，整体资源可以直接下载压缩包（手机端依然看不到，还是不知道为什么）。
stm32f103+PCA9685避坑点
qq_44014833的博客
11-07 2475
stm32f103+PCA9685驱动编写注意事项
基于STM32与PCA9685制作四足机器人（代码开源）
热门推荐
black_sneak的博客
12-15 2万+
基于STM32与PCA9685制作蓝牙控制四足机器人项目，超详细教学完成制作出自己的机器人（包含机器人3D打印文件以及HAL库版本代码）。
四足控制/机器人学笔记（一）
01-01
在机器人学领域，四足控制和机器人位姿表示及坐标变换是重要的基础知识。这篇笔记是一位大二学生基于自学经验所写，旨在为实验室的后辈提供学习参考，并巩固作者自己的知识。文章首先强调了理解机器人位姿表示和坐标...
MapLab笔记
10-23
- **行走机器人**（如四足机器人）利用飞行机器人收集的数据进行导航。通过对地形高度图进行分析，计算出斜率陡峭程度、局部粗糙度和最大步跨高度等参数，进而生成一个综合的可通行性地图。基于这个地图，行走机器人...
CS229的笔记
12-07
以四足机器人为例，设计一个能够使其稳定行走的控制系统是一项挑战。在这个例子中，并不清楚如何具体地指导机器人采取哪些动作才能实现稳定的行走。因此，采用监督学习的方法并不适用。相反，可以使用强化学习，通过...
机器人动力学与控制_MIT四足机器人控制方案理解笔记（3）——Mini Cheetah 19年的MPC+WBC控制方案...
weixin_39625008的博客
11-26 1901
2019年，MIT在Mini Cheetah上采用了MPC+WBC的控制方案，论文《Highly Dynamic Quadruped Locomotion via whole-body impulse control and model predictive control》中称加入WBC后Mini的最高运动速度由18年只采用MPC时的2.45m/s增加到19年的3.7m/s。​笔者这几天看了下M...
蜘蛛机器人STM32F103控制电路原理图
04-05
蜘蛛机器人STM32F103控制电路原理图
PWM输出模块PCA9685
电子爱好者磊雷
03-25 3201
1.该模块是由NXP公司研发的PWM输出模块 中文简介： 这是一个采用i2c通信 ，内置了PWM驱动器和一个时钟。这意味着，这将和TLC5940系列有很大不同。你不需要不断发送信号占用你的单片机！ 它是5V的兼容，这意味着你还可以用3.3V单片机控制并且安全地驱动到6V输出(当你想控制白色或蓝色指示灯用3.4+正电压也是可以的) 6地址选择引脚使你可以把62个驱动板挂在单个i2c总线上，总共有99...
四足机器人——舵机控制
m0_58585940的博客
11-16 7697
目录 1、51定时器控制单个舵机 2、51定时器控制多路舵机 3、stm32控制舵机 4、pca9685驱动模块 1、51定时器控制单个舵机 舵机的控制一般需要一个20ms左右的时基脉冲，该脉冲的高电平部分一般为0.5ms~2.5ms范围内的角度控制脉冲部分，总间隔为2ms，比如说180度伺服角度，对应的关系如下。 void main(void) { InitTimer0(); //定时器0初始化 EA = 1; //开总中断 while(1) //大循环 { Se
stm32 IIC 协议控制PCA9685舵机驱动板
richardgann的博客
07-30 1万+
这篇教程与网上的大部分教程都不相同，着重讲述如何使用编程PCA9685，而不是着重讲述原理，最后你还是一头雾水。这是一篇教你如何如何输出固定舵机角度，如何移植程序，从PCA9685的原理到如何移植的教程，在动手中学习理论。 单片机型号：stm32f103c8t6 使用stm32来控制一个舵机并不是难事，但是如果控制多个舵机，那硬件资源就显得捉襟见肘了。 因此，必须使用神器，PCA9685了，相信你能主动上网搜索PCA9685，也一定知道PCA9685是多牛了，我就不去转述了。 老规矩，将源码呈上
STM32F429阿波罗驱动PCA9685舵机驱动板
qq_41955679的博客
07-20 1001
本文修改于https://blog.csdn.net/MarkSoviet/article/details/79841366 若有侵权，联系删除 pca9685.c #include "pca9685.h" #include "delay.h" #include "myiic.h" #include <math.h> void PCA9685_write(unsigned ch...
[灯哥开源—四足机器人]程序算法讲解与STM32移植——运行框架（两个主线程）
weixin_41659552的博客
02-02 4397
写在前面 之前有幸参加过国内的机器人比赛，对阅读机器人控制算法有自己一定的心得。 在我看来控制机器人的程序是由一个主循环（主线程）和多个“次”循环（子线程）组成，主循环负责实时监测机器人的姿态数据反馈，并经过一步一步的算法计算，得出相应的值输出到执行器件。次循环有多个，他们的作用往往是负责实时接收传感器或者遥控器传入的数据，并将此数据反馈到主循环的某个环节，如下图所示： 我们如果要阅读一份程序，所要做的东西就非常清楚了 1.弄清主循，次循环分别是什么？ 2.主循环里的每个模块的功能分别是什么.
PCA9685--16路 PWM模块舵机驱动板--STM32 IIC接口模块
c1063891514的博客
11-23 2万+
目录 一、概述和硬件 1、概述 2、硬件 1、电压 2、i2c地址 3、使能脚 二、寄存器功能  MODE1寄存器 外面调用的接口     PCA9685是一款基于IIC总线通信的12位精度16通道PWM波输出的芯片，该芯片最初由NXP推出时主要面向LED开关调光， 16路12位PWM信号发生器，可用于控制舵机、led、电机等设备，i2c通信，节省主机资源。就是想控制好几...
STM32(HAL库) I2C 实现与 PCA9685 通信，控制多个舵机
qq_52111026的博客
08-02 5576
STM32 PCA9685 HAL库 舵机扩展板 概述 最近在学习机械臂控制，由于单片机的IO口有限，如果机械臂的舵机都使用单片机控制，过于占用资源，从网上购买了PCA9685这款舵机扩展板，通过I2C与单片机通信，实现对舵机的控制，节省了单片机的IO口。对于PCA9685的使用网上的资料很少，卖家给的资料也全部都是英文版的，目前还没有完全搞清楚，都是如果仅仅用于控制舵机啥的，不需要太关心PCA9685，以后有时间再好好研究研究。 I2C通信 STM32的I2C通信有两种方式，一种是硬件I2C，还有一种
[灯哥开源—四足机器人]程序算法讲解与STM32移植——目录
weixin_41659552的博客
02-02 4723
我之前有过STM32开发的经验，觉得四足机器人有点意思，在网上找了几个开源的项目和社区觉得灯哥做的是最不错的。 此项目的四足机器人，采用ESP32做为整个狗的主控和MPU6050陀螺仪，身体采用3D打印+标准件的组装方式，执行器件采用MG90S舵机，基本可以满足对四足机器人基础算法的理解。为了记录一下自己的踩过坑，也帮助后来的小伙伴更快的掌握，所以我准备把整个过程进行记录。 目录 1.硬件平台（esp32的资料很多，大伙可以在网上参考其他esp32专家的搭环境的教程） 2.软件框架 2.
四足机器人学入门：位姿表示与坐标变换解析
"这篇博客是作者自学机器人学过程中的笔记，旨在帮助实验室的后辈学习四足机器人控制和运动控制算法。作者强调了基础知识的重要性，特别是机器人位姿表示和坐标变换，这些都是运动控制算法的基础。文章提到了自由度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值