基于stm32f103c8t6与oled实现恐龙快跑小游戏

最新推荐文章于 2024-09-23 10:48:56 发布
最新推荐文章于 2024-09-23 10:48:56 发布
阅读量939 收藏 20
点赞数 7
文章标签： stm32 嵌入式硬件 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L0000ps/article/details/138571133
版权

文章目录

         功能简介
         准备材料
         实物展示
         代码实现

一、功能简介

本项目使用STM32F103C8T6单片机控制器，使用按键、IIC OLED模块等。

主要功能：

系统运行后，将代码烧录，按下reset复位键复位随后即可开始游戏，左键用于跳跃，右键用于开始。游戏右上角为本局游戏得分

本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。

             

二、准备材料

一块stm32f103c8t6芯片，两个按键，一块oled屏，一块stlingk转串口，几条杜邦线，一块面包板

三、实物展示

正在游戏中的画面

四、代码实现

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "tim.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdlib.h>
#include "OLED.h"
#include "Key.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void OLED_Proc(void);
void Key_Proc(void);

//ؖ˽
uint8_t Grade_Count = 0;
uint16_t Grade = 0;

//Љɋֆ
uint16_t Cactus_CreatTime = 3000;
uint16_t Cactus_CreatTime_Multiplier = 1000;
uint8_t Cactus_CreatNumber = 0;
const int8_t Cactus_Length1 = 8;
int8_t Cactus_Position1 = 127;
uint8_t Cactus_Flag1 = 1;
const int8_t Cactus_Length2 = 16;
int8_t Cactus_Position2 = 127;
uint8_t Cactus_Flag2 = 1;
const int8_t Cactus_Length3 = 16;
int8_t Cactus_Position3 = 127;
uint8_t Cactus_Flag3 = 1;
uint16_t Cactus_Count = 0;

//Dino
uint8_t Height = 0;
uint8_t Dino_Flag = 0;
uint8_t Dino_Jump_Key = 0;
uint8_t Dino_Jump_Flag = 0;
uint8_t Dino_Jump_Flag_Flag = 0;
uint8_t Dino_Count = 0;
uint8_t Jump_FinishFlag = 0;

//Cloud
const uint8_t Cloud_Length = 27;
int8_t Cloud_Positon_1 = 100;
int8_t Cloud_Positon_2 = 0;

//Ground
uint8_t OLED_Slow = 0;
uint16_t Ground_Move_Number = 0;
uint8_t Speed = 3;

//Key
uint8_t Key_Slow = 0;
uint8_t Key_Value = 0;
uint8_t Key_Old = 0;
uint8_t Key_Down = 0;
uint8_t Key_Test = 0;
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM2_Init();
  /* USER CODE BEGIN 2 */
	OLED_Init();
	HAL_Delay(100);
	OLED_Clear();
	OLED_ShowGameBegin(0, 0, 127, 7);
	while(1)
	{
		if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_15) == 0)
			break;
	}
	OLED_Clear();
	
	HAL_TIM_Base_Start_IT(&htim2);
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
		OLED_Proc();
		Key_Proc();
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

void OLED_Proc(void)
{
	if(OLED_Slow) return;
	OLED_Slow = 1;
	
	OLED_ShowNum(1, 12, Grade, 5);
	
	//֘Ħ
	Ground_Move_Number += Speed;																															//لҤƫӆ
	Ground_Move_Number %= 560;																																//
	OLED_ShowGround(0, 6 , 127, 7, Ground_Move_Number);																				//Дʾ՚كƫӆЂք֘Ħ
	
	//Ն1
	OLED_ClearPicture(Cloud_Positon_1 + 1, 3, Cloud_Positon_1 + Cloud_Length - 1, 3);					//лӰ
	Cloud_Positon_1 -= (Speed - 1);																														//لҤՆפ1քλ׃
	if(Cloud_Positon_1 < -27)																																	//ɧڻӬԶǁĻسӠìղܘսǁĻԒӠ
		Cloud_Positon_1 = 127;																																	//
	OLED_ShowCloud(Cloud_Positon_1, 3, Cloud_Positon_1 + Cloud_Length - 1, 3);								//ДʾՆפ1
	
	//Ն2
	OLED_ClearPicture(Cloud_Positon_2 + 1, 2, Cloud_Positon_2 + Cloud_Length - 1, 2);					//лӰ
	Cloud_Positon_2 -= (Speed - 1);																														//لҤՆפ2քλ׃
	if(Cloud_Positon_2 < -27)																																	//ɧڻӬԶǁĻسӠìղܘսǁĻԒӠ
		Cloud_Positon_2 = 127;																																	//
	OLED_ShowCloud(Cloud_Positon_2, 2, Cloud_Positon_2 + Cloud_Length - 1, 2);								//ДʾՆפ2
	
	
	//Сࠖº
	if(Dino_Jump_Key == 0)
	{
		OELD_ShowDino(0, 5, 15, 6, Dino_Flag);																									//ДʾࠖºѼƜքۭĦ
	}
	else
	{
		if(Jump_FinishFlag == 1)
			Jump_FinishFlag = 2;
		OELD_ShowDino_Jump(0, 2, 15, 6, Dino_Jump_Flag);																				//Дʾࠖº͸ǰքۭĦ
		if(Jump_FinishFlag == 2 && Dino_Jump_Flag == 0)
		{
			Jump_FinishFlag = 0;
			Dino_Jump_Key = 0;
		}
	}
	
	//Љɋֆ1
	if(Cactus_Flag1 == 0)																																			//ʺӺЉɋֆ1քҪ־,ɴCactus_Flag1 = 0,ղʺԉЉɋֆ1
	{
		OLED_ClearPicture(Cactus_Position1 + 3, 5, Cactus_Position1 + Cactus_Length1 - 1, 6);		//лӰ
		Cactus_Position1 -= Speed;																															//вسӆ֯
		if(Cactus_Position1 < -8)																																//ɧڻӬԶǁĻسӠ,ղܘսǁĻԒӠ,Ȓ޲ֹ
		{																																												//һ֯ìһՓǁĻԒӠԶЖ
			Cactus_Flag1 = 1;																																			//
			Cactus_Position1 = 127;																																//
		}																																												//
		OLED_ShowCactus1(Cactus_Position1, 5, Cactus_Position1 + Cactus_Length1 - 1, 6);				//ДʾЉɋֆ1
		
	}
	
	//Љɋֆ2
	if(Cactus_Flag2 == 0)																																			//ʺӺЉɋֆ2քҪ־,ɴCactus_Flag2 = 0,ղʺԉЉɋֆ2
	{
		OLED_ClearPicture(Cactus_Position2 + 8, 5, Cactus_Position2 + Cactus_Length2 - 1, 6);		//лӰ
		Cactus_Position2 -= Speed;																															//вسӆ֯
		if(Cactus_Position2 < -16)																															//ɧڻӬԶǁĻسӠ,ղܘսǁĻԒӠ,Ȓ޲ֹ
		{																																												//һ֯ìһՓǁĻԒӠԶЖ
			Cactus_Flag2 = 1;																																			//
			Cactus_Position2 = 127;																																//
		}																																												//
		OLED_ShowCactus2(Cactus_Position2, 5, Cactus_Position2 + Cactus_Length2 - 1, 6);				//ДʾЉɋֆ2
	}
	
	//Љɋֆ3
	if(Cactus_Flag3 == 0)																																			//ʺӺЉɋֆ3քҪ־,ɴCactus_Flag3 = 0,ղʺԉЉɋֆ3
	{
		OLED_ClearPicture(Cactus_Position3 + 8, 6, Cactus_Position3 + Cactus_Length3 - 1, 6);		//лӰ
		Cactus_Position3 -= Speed;																															//вسӆ֯
		if(Cactus_Position3 < -16)																															//ɧڻӬԶǁĻسӠ,ղܘսǁĻԒӠ,Ȓ޲ֹ
		{																																												//һ֯ìһՓǁĻԒӠԶЖ
			Cactus_Flag3 = 1;																																			//
			Cactus_Position3 = 127;																																//
		}																																												//
		OLED_ShowCactus3(Cactus_Position3, 6, Cactus_Position3 + Cactus_Length3 - 1, 6);				//ДʾЉɋֆ3
	}
	
	//Game Over
	if(Cactus_Position3 + Cactus_Length3 - 1 <= 26 && Cactus_Position3 + Cactus_Length3 - 1 >= 0 && Height <= 6 || 		//Ɛ֨ˇرԥƶ
			Cactus_Position2 + Cactus_Length2 - 1 <= 26 && Cactus_Position2 + Cactus_Length2 - 1 >= 0 && Height <= 14 || 	//սЉɋֆ
			Cactus_Position1 + Cactus_Length1 - 1 <= 24 && Cactus_Position1 + Cactus_Length1 - 1 >= 0 && Height <= 14)		//
	{
		while(1)																																								//ԎϷޡ˸
		{																																												//
			HAL_Delay(1000);																																			//
			OLED_ShowGameOver(0, 0, 127, 7);																											//
		}																																												//
	}
}

void Key_Proc(void)
{
	if(Key_Slow) return;
	Key_Slow = 1;
	
	Key_Value = Get_KeyNumber();
	Key_Down = Key_Value & (Key_Value ^ Key_Old);
	Key_Old = Key_Value;
	
	if(Key_Down == 12 && Dino_Jump_Key == 0)
	{
		Dino_Jump_Key = 1;
	}
}

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(htim == &htim2)//1ms޸ɫһՎא׏ؾϱگ˽
	{
		if(++OLED_Slow == 40) OLED_Slow = 0;
		if(++Key_Slow == 10) Key_Slow = 0;
		
		//ԦmСࠖºքѼƜ͸Ծ
		Dino_Count++;
		if(Dino_Count == 50)
		{
			Dino_Flag ^= 1;
			
			if(Dino_Jump_Key == 1)
			{
				if(Dino_Jump_Flag_Flag == 0 && Jump_FinishFlag == 0)
				{
					Dino_Jump_Flag ++;
					if(Dino_Jump_Flag == 8)
						Dino_Jump_Flag_Flag = 1;
				}
				else if(Dino_Jump_Flag_Flag == 1)
				{
					Dino_Jump_Flag --;
					if(Dino_Jump_Flag == 0)
					{
						Dino_Jump_Flag_Flag = 0;
						Jump_FinishFlag = 1;
					}
				}
			}
			
			switch(Dino_Jump_Flag)
			{
				case 0:Height = 0; break;
				case 1:Height = 6; break;
				case 2:Height = 10;break;
				case 3:Height = 15;break;
				case 4:Height = 18;break;
				case 5:Height = 21;break;
				case 6:Height = 23;break;
				case 7:Height = 25;break;
				case 8:Height = 25;break;
			}
			
			Dino_Count = 0;
		}
		
		//̦ܺʺԉЉɋֆ
		Cactus_Count++;
		if(Cactus_Count >= Cactus_CreatTime)
		{
			Cactus_CreatTime = rand() % 3;
			Cactus_CreatTime += 1;
			Cactus_CreatTime *= Cactus_CreatTime_Multiplier;
			
			Cactus_CreatNumber = rand() % 3;
			switch(Cactus_CreatNumber)
			{
				case 0:
					Cactus_Flag1 = 0;
				break;
				case 1:
					Cactus_Flag2 = 0;
				break;
				case 2:
					Cactus_Flag3 = 0;
				break;
			}
			Cactus_Count= 0;
		}
		
		//ݓ̙
		Grade_Count++;
		if(Grade_Count == 200)
		{
			Grade ++;
			if(Grade ==  50)
				Speed ++;
			if(Grade == 100)
			{
				Speed ++;
				Cactus_CreatTime_Multiplier = 500;
			}
			if(Grade == 150)
			{
				Speed ++;
				Cactus_CreatTime_Multiplier = 800;
			}
			if(Grade == 200)
				Speed ++;
			Grade_Count = 0;
		}
	}
}
/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

以上为开源代码主函数main.c文件内容，开源文件放在最后。

五、开源地址

源视频来自bilibili博主     “庚庚庚敏敏敏稚稚稚”

链接：https://pan.baidu.com/s/1Hrwn7aI6QnB11osurl4ylw?pwd=yuan

提取码：yuan

L0000ps
关注
STM32F103C8T6控制的OLED IIC 4针
CHINESEmen6的博客
05-03 2万+
简介 介绍一个c8t6驱动OLED的程序，之前做设计的时候，在网上找的内容较少，所以和大家分享下。分享下采用C8T6设计时出现的问题，避免大家走弯路。由于能力有限，程序大部分来自网路，只用于学习交流。 第一次写的博客，本想把程序去不传上去，后来发现好像不能。有问题大家再问吧，互相学习。 所采用的OLED 采用4针，IIC通信协议的0.96寸OLED屏幕；显示中文需要取模软件； 采用ZET6需要配...
基于STM32的小游戏——谷歌小恐龙（Chrome Dino Game）_chromedion游戏(1)
2401_83641392的博客
04-06 3114
关于OLED的使用与原理不熟悉的笔者欢迎去笔者另一篇文章学习，由于篇幅问题，这里就不过多讲诉。【强烈推荐】基于stm32的OLED各种显示实现（含动态图）_混分巨兽龙某某的博客-CSDN博客_oled显示stm32。
【毕业设计】_基于STM32单片机的俄罗斯方块游戏设计（原理图+源码）
最新发布
2301_79003325的博客
09-23 414
系统以stm32单片机为控制核心，以ST7735R为显示模块，显示俄罗斯方块游戏，有四个按键，进行操作，分别是开始，左，右，翻转并显示下一个方块，当积满一行加一分，到最顶端时游戏结束。进入仿真此时是待启动界面，按下开始按键就能开始进行游戏。可以看到方块在不断下降，右侧会显示下次出现的方块，另外还会显示分数。通过下方的三个方向控制按键可以控制左右以及反转。
【STM32单片机】小恐龙游戏设计
Hello_Muyi的博客
09-22 1064
本项目使用STM32F103C8T6单片机控制器，使用按键、IIC OLED模块等。主要功能：系统运行后，OLED液晶显示游戏初始界面，按下K4键开始，K1键跳跃；在初始界面状态下，按下K3键进入设置界面，K1用于选择，K4确定，K3返回；游戏界面左上角为最高得分，右上角为本次游戏得分。
基于stm32f103c8t6与OLED实现的贪吃蛇游戏（附完整代码）
汘荨的博客
09-27 3802
我是用的是四线IIC接口的OLED因为0.96寸OLED屏幕是128*64，将每2*2的四个OLED上的节点看做蛇的一个节点，所以定义地图大小为32*12#define MAXLENGTH 100 //蛇的最大长度//地图大小 x,y（一个坐标为4*4个像素点） 实际按4倍尺寸放大后地图大小为128*48个像素点int score;//分数//蛇吃到食物的标记//获取按键值struct {//二维数组，行坐标表示蛇节点，列表示当前节点的x，y坐标int length;//蛇的长度。
STM32单片机OLED贪吃蛇游戏记分计时
LS840233684的博客
09-06 1154
STM32单片机OLED贪吃蛇游戏记分计时 关键词：单片机小游戏，STM32单片机小游戏，STM32单片机贪吃蛇游戏，单片机贪吃蛇游戏，贪吃蛇游戏，贪吃蛇
OLED显示屏STM32F103C8T6驱动程序.zip_oled stm32f103c8t6_oled显示屏程序_stm32f
07-13
总之，这个压缩包中的OLED显示屏STM32F103C8T6驱动程序提供了微控制器与OLED显示屏之间的关键桥梁，对于那些希望利用STM32F103C8T6打造具有出色视觉体验的嵌入式项目的工程师来说，是必不可少的资源。通过学习和应用...
基于STM32F103C8T6的OLED+超声波传感器+温湿度传感器DHT11功能实现。
07-25
在本项目中，我们主要探讨如何使用STM32F103C8T6微控制器，结合OLED显示屏和超声波传感器以及温湿度传感器DHT11，来实现环境参数的实时监测与显示。STM32F103C8T6是一款基于ARM Cortex-M3内核的微控制器，具有高性能...
基于STM32F103C8T6+OLED的菜单UI源码
02-21
基于STM32F103C8T6+OLED的菜单UI源码，基于STM32F103C8T6+OLED的菜单UI源码，基于STM32F103C8T6+OLED的菜单UI源码，基于STM32F103C8T6+OLED的菜单UI源码，基于STM32F103C8T6+OLED的菜单UI源码，基于STM32F103C8T6+...
基于STM32F103C8T6的OLED实验.zip
11-15
在“基于STM32F103C8T6的OLED实验”中，我们将深入探讨如何利用STM32F103C8T6微控制器驱动OLED显示器，并通过IIC接口实现通信。 OLED（有机发光二极管）显示技术因其高对比度、响应速度快、视角宽以及低功耗等优点...
stm32f103c8t6接0.96寸OLED屏， 包含原理图和PCB，不含程序
07-09
STM32F103C8T6是一款广泛使用的微控制器，属于STM32系列的高性能、低成本的ARM Cortex-M3内核芯片。这款MCU适用于各种嵌入式应用，如工业控制、消费电子和物联网设备。在本项目中，它被用来驱动0.96英寸的OLED显示屏...
stm32f103c8t6 OLED 硬件SPI
04-10
OLED HARDWARE_SPI TEST INTERFACE: PB13:SCK(D0/SCL) PB15:MOSI(D1/SDA) PB12:D/C PB8: RES CS: GND (如果引出来) CAUTION:PLEASE ENSURE YOUR OLED_MODE IS 4WIRE_SPI MODE
基于stm32f107的2048小游戏
05-30
基于stm32f107的2048小游戏 分享给大家 一起加油 多多体谅
STM32例程(STM32F103C8T6)（OLED）.zip_STM32F103C8T6 OLED_stm32 oled
07-15
STM32例程(STM32F103C8T6)（OLED）
STM32F103C8T6硬件IIC控制4针0.96寸OLED显示屏
07-16
本程序使用STM32F103C8T6作为主控单片机，4针0.96寸OLED屏幕作为显示。采用硬件IIC方式，硬件IIC的特点就是比模拟IIC数据传输速度快，并且数据传输速度是可控的。程序可完成基本的英文字符显示、数字显示以及汉字显示，也可实现画点、画线以及图片的显示。该程序经本人测试可以正常使用，也可先去搜索我的同名博客（STM32F103C8T6硬件IIC控制4针0.96寸OLED显示屏）先查看是否符合你的要求再进行下载，以免浪费下载积分，博客内容介绍有如何获取字模等步骤。
STM32F103C8T6-OLED屏幕显示.rar
06-03
STM32F103C8T6-OLED屏幕显示含主要代码、参考程序、相关资料
STM32F103C8T6 使用 HAL 库驱动 OLED 显示屏
qq_58404700的博客
08-12 1152
本报告旨在概述使用STM32F103C8T6微控制器结合HAL库来驱动OLED显示屏的过程。OLED显示屏因其高对比度、低功耗和快速响应时间等特点，在嵌入式系统中得到广泛应用。本项目通过STM32的I2C接口与OLED显示屏进行通信，实现文字、图像等信息的显示。
Android物联网应用程序开发基础_基于android的物联网应用开发
2401_84010457的博客
05-13 697
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年嵌入式&物联网开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上嵌入式&物联网开发知识点，真正体系化！
stm32f103c8t6驱动oled
weixin_35753291的博客
02-16 2190
要驱动OLED显示屏，您可以使用STM32F103C8T6微控制器及其相关的GPIO引脚和SPI总线接口。 以下是驱动OLED显示屏的一些基本步骤： 配置STM32F103C8T6的SPI总线接口。 通过SPI总线发送命令和数据给OLED显示屏。这些命令和数据将用于控制显示屏的显示内容和其他属性，例如亮度和对比度。 将OLED显示屏的引脚连接到STM32F103C8T6的GPIO引脚。这些引...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值