STM32H7 스테핑모터 & JOYSTICK 키 제어

스테핑모터 드라이버

http://www.newtc.co.kr/dpshop/shop/item.php?it_id=1314666709

뉴티씨

STM32CubeMX

모터 설정 디자인합니다.

프로그래밍

스테핑 모터를 제어하는 드라이버

#define SM_STEP_CLK			8		// Half : 8, Quarter : 16, Eighth : 32, Sixteenth : 64

#define SM_DEGREE				SM_STEP_CLK/1.8	
#define SM_DEGREE_90			90*SM_STEP_CLK/1.8

#define SM_MODE_SIXTEENTH		0x00
#define SM_MODE_EIGHTH			0x02
#define SM_MODE_QUARTER		0x01
#define SM_MODE_HALF			0x03

#define SM_DIR_LEFT			0x00
#define SM_DIR_RIGHT			0x01

void SM_Enable(void)		// Step Motor Enable
{
	HAL_GPIO_WritePin(STEP_ENABLE_GPIO_Port, STEP_ENABLE_Pin, GPIO_PIN_SET);
}

void SM_Disable(void)		// Step Motor Disable
{
	HAL_GPIO_WritePin(STEP_ENABLE_GPIO_Port, STEP_ENABLE_Pin, GPIO_PIN_RESET);
}

void SM_SetMode(uint8_t mMode)		// Step Motor Set Mode
{
	if(mMode & 0x01)
		HAL_GPIO_WritePin(STEP_M0_GPIO_Port, STEP_M0_Pin, GPIO_PIN_SET);
	else
		HAL_GPIO_WritePin(STEP_M0_GPIO_Port, STEP_M0_Pin, GPIO_PIN_RESET);
	
	if(mMode & 0x02)
		HAL_GPIO_WritePin(STEP_M1_GPIO_Port, STEP_M1_Pin, GPIO_PIN_SET);
	else 
		HAL_GPIO_WritePin(STEP_M1_GPIO_Port, STEP_M1_Pin, GPIO_PIN_RESET);
}

void SM_SetDirect(uint8_t mDir)
{
	HAL_GPIO_WritePin(STEP_DIR_GPIO_Port, STEP_DIR_Pin, (GPIO_PinState)mDir);
}

void SM_ClockToggle(void)
{
	HAL_GPIO_TogglePin(STEP_CLK_GPIO_Port, STEP_CLK_Pin);
}

void SM_LEFT(void)
{
	mSM_Count = mAirSetting.StepDegree*SM_DEGREE;
	SM_SetDirect(SM_DIR_LEFT);
	SM_Enable();
}

void SM_RIGHT(void)
{
	mSM_Count = mAirSetting.StepDegree*SM_DEGREE;
	SM_SetDirect(SM_DIR_RIGHT);
	SM_Enable();
}

void SM_Init(void)
{
	SM_SetMode(SM_MODE_QUARTER);
	SM_SetDirect(SM_DIR_RIGHT);
}

타이머를 이용하여 스테핑모터를 제어합니다.

#if 1	
uint8_t mSec=0, mMinute=0, mHour=0;
unsigned short mMS = 0, mCurrMS = 0, mCurr10MS = 0, mCurr100MS = 0, mCurr500MS = 0;
unsigned int mCurrentSec = 0, mTimerSec = 0;
unsigned char mCurrSec = 0;

unsigned char mMainMode = 0;


void HAL_SYSTICK_Callback(void)
{
	mMS++;
	if(mMS >= 1000)
	{
		mCurrentSec++;
		mSec++;
		if(mSec >= 60)
		{
			mMinute++;
			if(mMinute >= 60)
			{
				mHour++;
				mMinute = 0;
			}
			mSec = 0;
		}
		mMS = 0;
	}			
}

#endif

void Main_1ms_Timer(void)		// Fast 
{
	if(mPowerOn)
	{
	}

	if(mSM_Count == 0)
	{
		SM_Disable();
	}
	else
	{
		mSM_Count--;
		HAL_GPIO_TogglePin(STEP_CLK_GPIO_Port, STEP_CLK_Pin);
	}
}

void Main_10ms_Timer(void)
{
}

void Main_100ms_Timer(void)
{
}

void Main_500ms_Timer(void)
{
	if(mPowerOn)
	{
		HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_SET);	
	}
	else
	{
		HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);	
	}
}

void Main_1S_Timer(void)
{
	if(mPowerOn)
	{
	
	}
}

// Timer Functions
void (*f10msTimer_FuncList[MODE_MAX])(void) = 
{
	Main_10ms_Timer,
};

void (*f100msTimer_FuncList[MODE_MAX])(void) = 
{
	Main_100ms_Timer,
};

void (*f500msTimer_FuncList[MODE_MAX])(void) = 
{
	Main_500ms_Timer,
};

void (*f1sTimer_FuncList[MODE_MAX])(void) = 
{
	Main_1S_Timer,
};

void Process_1ms(void)
{
	Main_1ms_Timer();	
}

void Process_10ms(void)
{
	if(f10msTimer_FuncList[mMainMode] != NULL)
		f10msTimer_FuncList[mMainMode]();
}

void Process_100ms(void)
{
	if(f100msTimer_FuncList[mMainMode] != NULL)
		f100msTimer_FuncList[mMainMode]();
}

void Process_500ms(void)
{
	if(f500msTimer_FuncList[mMainMode] != NULL)
		f500msTimer_FuncList[mMainMode]();
}

void Process_1sec(void)
{
	if(f1sTimer_FuncList[mMainMode] != NULL)
		f1sTimer_FuncList[mMainMode]();
}

void Timer_Process(void)
{
	if(mMS != mCurrMS)
	{
		Process_1ms();

		if(mCurr10MS != (mMS/10))
		{
			mCurr10MS = mMS/10;
			Process_10ms();
		}
		
		if(mCurr100MS != (mMS/100))
		{
			mCurr100MS = mMS/100;
			Process_100ms();
		}
		
		if(mCurr500MS != (mMS/500))
		{
			mCurr500MS = mMS/500;
			Process_500ms();
		}

		if(mCurrSec != mSec)
		{
			mCurrSec = mSec;
			Process_1sec();
		}
		
		mCurrMS = mMS;
	}
}

main 루프 : 조이스틱키를 입력 수신하여 스테핑모터를 제어합니다.

	uint32_t startTime = 0;
  uint32_t elapsedTime = 0;
	
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		
				elapsedTime = HAL_GetTick();

			if(800 < (elapsedTime - startTime)) {
				keyKinds = KEY_UNDEFINED;
				keyKindsOld = KEY_UNDEFINED;
			}
#if 1
		
			if(HAL_GPIO_ReadPin(KEY_CTRL_GPIO_Port, KEY_CTRL_Pin) == GPIO_PIN_SET){
				HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_SET);
				
			}else{
				HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_RESET);
				keyKinds = KEY_ENTER;
			}
			
			if(HAL_GPIO_ReadPin(KEY_RIGHT_GPIO_Port, KEY_RIGHT_Pin) == GPIO_PIN_SET){
			}else{
				keyKinds = KEY_RIGHT;
			}
			if(HAL_GPIO_ReadPin(KEY_LEFT_GPIO_Port, KEY_LEFT_Pin) == GPIO_PIN_SET){

			}else{
				keyKinds = KEY_LEFT;
			}
			if(HAL_GPIO_ReadPin(KEY_UP_GPIO_Port, KEY_UP_Pin) == GPIO_PIN_SET){

			}else{

				//printf("push KEY_UP\r\n");
				keyKinds = KEY_UP;
			}		
			if(HAL_GPIO_ReadPin(KEY_DOWN_GPIO_Port, KEY_DOWN_Pin) == GPIO_PIN_SET){

			}else{
				keyKinds = KEY_DOWN;
			}
			
			if(HAL_GPIO_ReadPin(KEY_WAKEUP_GPIO_Port, KEY_WAKEUP_Pin) == GPIO_PIN_SET){
				//printf("push KEY_WAKEUP\r\n");
				keyKinds = KEY_WAKEUP;
			}else{
			}
			
		if(keyKinds == KEY_UNDEFINED || keyKinds != keyKindsOld)
		{
			
			  switch(keyKinds)
			  {
			  	case KEY_UNDEFINED: break;
					case KEY_ENTER: 	printf("JOY_KEY_ENTER # \r\n");  break;
					case KEY_LEFT: 		
							printf("JOY_KEY_LEFT # \r\n");  
							mAirSetting.StepDegree = 45;
							SM_LEFT();
							break;
					case KEY_RIGHT: 	
							printf("JOY_KEY_RIGHT # \r\n");  
							mAirSetting.StepDegree = 45;
							SM_RIGHT();
							break;
					case KEY_UP: 		
							printf("JOY_KEY_UP # \r\n");  
							mAirSetting.StepDegree = 90;
							SM_LEFT();
					break;
					case KEY_DOWN: 		
							printf("JOY_KEY_DOWN # \r\n");  
							mAirSetting.StepDegree = 90;
							SM_RIGHT();
							break;
					case KEY_WAKEUP: 	printf("JOY_KEY_WAKEUP # \r\n");  break;
			  }

				if(keyKinds != KEY_UNDEFINED)
				{
			  		keyKindsOld = keyKinds;
						startTime = elapsedTime;
				}
		}
		
		Timer_Process();
#endif
  }

테스트영상