STM32F4无法驱动OLED

2019-03-23 18:57发布

站内问答 / STM32/STM8
3653 2 1279
代码在Arduino上可以运行, 但是移植到STM32上就不行了, 求高手赐教如何解决.
Arduino.h

  2. #include "Arduino.h"

  4. int _sda, _scl;
  5. void IO_Init(void);
  6. void Set_Pin(int pin, bool status);

  8. void IIC_without_ACK::IO_Init(void)
  9. {
  10.         pinMode(_sda, OUTPUT);
  11.         pinMode(_scl, OUTPUT);
  12. }

  14. void IIC_without_ACK::Set_Pin(int pin, bool status)
  15. {
  16.         digitalWrite(pin, status);
  17. }

  19. IIC_without_ACK::IIC_without_ACK(int sda, int scl)
  20. {
  21.         _sda = sda;
  22.         _scl = scl;
  23.         IO_Init();
  24. }

  26. void IIC_without_ACK::IIC_Start(void)
  27. {
  28.         Set_Pin(_scl, HIGH);
  29.         Set_Pin(_sda, HIGH);
  30.         Set_Pin(_sda, LOW);
  31.         Set_Pin(_scl, LOW);
  32. }

  34. void IIC_without_ACK::IIC_Stop(void)
  35. {
  36.         Set_Pin(_scl, LOW);
  37.         Set_Pin(_sda, LOW);
  38.         Set_Pin(_scl, HIGH);
  39.         Set_Pin(_sda, HIGH);
  40. }

  42. void IIC_without_ACK::Write_IIC_Byte(unsigned char IIC_Byte)
  43. {
  44.         for(int i=0; i<8; i++)
  45.         {
  46.                 if((IIC_Byte << i) & 0x80) Set_Pin(_sda, HIGH);
  47.                 else Set_Pin(_sda, LOW);
  48.                 Set_Pin(_scl, HIGH);
  49.                 Set_Pin(_scl, LOW);
  50.         }
  51.         Set_Pin(_sda, HIGH);
  52.         Set_Pin(_scl, HIGH);
  53.         Set_Pin(_scl, LOW);
  54. }

  56. void IIC_without_ACK::Write_IIC_Command(unsigned char IIC_Command)
  57. {
  58.          IIC_Start();
  59.          Write_IIC_Byte(0x78);
  60.          Write_IIC_Byte(0x00);
  61.          Write_IIC_Byte(IIC_Command);
  62.          IIC_Stop();
  63. }

  65. void IIC_without_ACK::Begin_IIC_Data()
  66. {
  67.          IIC_Start();
  68.          Write_IIC_Byte(0x78);
  69.          Write_IIC_Byte(0x40);
  70. }

  72. void IIC_without_ACK::Fill_Screen(unsigned char fill_Data)
  73. {
  74.         unsigned char m,n;
  75.         for(m=0; m<8; m++)
  76.         {
  77.                 Write_IIC_Command(0xb0 + m);
  78.                 Write_IIC_Command(0x00);
  79.                 Write_IIC_Command(0x10);
  80.                 Begin_IIC_Data();
  81.                 for(n=0; n<128; n++) Write_IIC_Byte(fill_Data);
  82.                 IIC_Stop();
  83.         }
  84. }

  86. void IIC_without_ACK::Initial()
  87. {
  88.         unsigned char shellcode[] = {0xAE, 0x00, 0x10, 0x40, 0x81, 0xCF, 0xA1, 0xC8, 0xA6, 0xA8, 0x3F, 0xD3, 0x00, 0xD5, 0x80, 0xD9, 0xF1, 0xDA, 0x12, 0xDB, 0x40, 0x20, 0x02, 0x8D, 0x14, 0xA4, 0xA6, 0xAF};
  89.         for (int i=0; i<28; i++) Write_IIC_Command(shellcode[i]);
  90. }
复制代码
STM32F4-main.c
  1. #include "main.h"

  3. static void SystemClock_Config(void);
  4. static void Error_Handler(void);
  5. static void EXTILine0_Config(void);

  7. void IIC_Start(void);
  8. void IIC_Stop(void);
  9. void Write_IIC_Byte(unsigned char IIC_Byte);
  10. void Write_IIC_Command(unsigned char IIC_Command);
  11. void Begin_IIC_Data(void);
  12. void Fill_Screen(unsigned char fill_Data);
  13. void Initial(void);
  14. int _sda = 0x8080, _scl = 0x8000;
  15. int HIGH = 0x7000, LOW = 0x7070;
  16. void IO_Init(void);
  17. void Set_Pin(int pin, int status);

  19. void IIC_Init(void);
  20. void IIC_Start(void);
  21. void IIC_Stop(void);
  22. void Write_IIC_Byte(unsigned char IIC_Byte);
  23. void Write_IIC_Command(unsigned char IIC_Command);
  24. void Begin_IIC_Data(void);
  25. void IIC_SetPos(unsigned char x, unsigned char y);
  26. void Fill_Screen(unsigned char fill_Data);
  27. void SSD1306_Init(void);

  29. int main(void)
  30. {
  31.   HAL_Init();
  32.        
  33.   BSP_LED_Init(LED3);
  34.   BSP_LED_Init(LED4);
  35.        
  36.   SystemClock_Config();

  38.   EXTILine0_Config();
  39.   
  40.         IO_Init();
  41.         HAL_Delay(10);
  42.         Initial();
  43.         HAL_Delay(10);
  44.         Fill_Screen(0xff);
  45.        
  46.   while (1)
  47.         {
  48.                 HAL_Delay(500);
  49.                 BSP_LED_Toggle(LED4);
  50.         }
  51. }

  53. static void SystemClock_Config(void)
  54. {
  55.   RCC_ClkInitTypeDef RCC_ClkInitStruct;
  56.   RCC_OscInitTypeDef RCC_OscInitStruct;
  57.   __PWR_CLK_ENABLE();
  58.   __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
  59.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  60.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  61.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  62.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  63.   RCC_OscInitStruct.PLL.PLLM = 8;
  64.   RCC_OscInitStruct.PLL.PLLN = 360;
  65.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  66.   RCC_OscInitStruct.PLL.PLLQ = 7;
  67.   if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) Error_Handler();
  68.   HAL_PWREx_ActivateOverDrive();
  69.   RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
  70.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  71.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  72.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;  
  73.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;  
  74.   if(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK) Error_Handler();
  75. }

  77. static void EXTILine0_Config(void)
  78. {
  79.   GPIO_InitTypeDef GPIO_InitStructure;
  80.   __GPIOA_CLK_ENABLE();
  81.   GPIO_InitStructure.Mode = GPIO_MODE_IT_FALLING;
  82.   GPIO_InitStructure.Pull = GPIO_NOPULL;
  83.   GPIO_InitStructure.Pin = GPIO_PIN_0;
  84.         HAL_GPIO_Init(GPIOA, &GPIO_InitStructure);
  85.        
  86.   HAL_NVIC_SetPriority(EXTI0_IRQn, 2, 0);
  87.   HAL_NVIC_EnableIRQ(EXTI0_IRQn);
  88. }

  90. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
  91. {
  92.   if(GPIO_Pin == KEY_BUTTON_PIN)
  93.   {
  94.     BSP_LED_Toggle(LED3);
  95.   }
  96. }

  98. void IO_Init(void)
  99. {
  100.         GPIO_InitTypeDef GPIO_InitStructure;
  101.         __GPIOE_CLK_ENABLE();
  102.         GPIO_InitStructure.Pin = GPIO_PIN_2 | GPIO_PIN_3;
  103.         GPIO_InitStructure.Mode = GPIO_MODE_AF_OD;
  104.         GPIO_InitStructure.Pull = GPIO_PULLDOWN;
  105.         GPIO_InitStructure.Speed = GPIO_SPEED_LOW;
  106.        
  107.         HAL_GPIO_Init(GPIOE, &GPIO_InitStructure);
  108. }

  110. void Set_Pin(int pin, int status)
  111. {
  112.         if (pin == _sda) HAL_GPIO_WritePin(GPIOE, GPIO_PIN_2, status == HIGH ? GPIO_PIN_SET : GPIO_PIN_RESET);
  113.         if (pin == _scl) HAL_GPIO_WritePin(GPIOE, GPIO_PIN_3, status == HIGH ? GPIO_PIN_SET : GPIO_PIN_RESET);
  114. }

  116. void IIC_Start(void)
  117. {
  118.         Set_Pin(_scl, HIGH);
  119.         Set_Pin(_sda, HIGH);
  120.         Set_Pin(_sda, LOW);
  121.         Set_Pin(_scl, LOW);
  122. }

  124. void IIC_Stop(void)
  125. {
  126.         Set_Pin(_scl, LOW);
  127.         Set_Pin(_sda, LOW);
  128.         Set_Pin(_scl, HIGH);
  129.         Set_Pin(_sda, HIGH);
  130. }

  132. void Write_IIC_Byte(unsigned char IIC_Byte)
  133. {
  134.         for(int i=0; i<8; i++)
  135.         {
  136.                 if((IIC_Byte << i) & 0x80) Set_Pin(_sda, HIGH);
  137.                 else Set_Pin(_sda, LOW);
  138.                 Set_Pin(_scl, HIGH);
  139.                 Set_Pin(_scl, LOW);
  140.         }
  141.         Set_Pin(_sda, HIGH);
  142.         Set_Pin(_scl, HIGH);
  143.         Set_Pin(_scl, LOW);
  144. }

  146. void Write_IIC_Command(unsigned char IIC_Command)
  147. {
  148.          IIC_Start();
  149.          Write_IIC_Byte(0x78);
  150.          Write_IIC_Byte(0x00);
  151.          Write_IIC_Byte(IIC_Command);
  152.          IIC_Stop();
  153. }

  155. void Begin_IIC_Data()
  156. {
  157.          IIC_Start();
  158.          Write_IIC_Byte(0x78);
  159.          Write_IIC_Byte(0x40);
  160. }

  162. void Fill_Screen(unsigned char fill_Data)
  163. {
  164.         unsigned char m,n;
  165.         for(m=0; m<8; m++)
  166.         {
  167.                 Write_IIC_Command(0xb0 + m);
  168.                 Write_IIC_Command(0x00);
  169.                 Write_IIC_Command(0x10);
  170.                 Begin_IIC_Data();
  171.                 for(n=0; n<128; n++) Write_IIC_Byte(fill_Data);
  172.                 IIC_Stop();
  173.         }
  174. }

  176. void Initial()
  177. {
  178.         unsigned char shellcode[] = {0xAE, 0x00, 0x10, 0x40, 0x81, 0xCF, 0xA1, 0xC8, 0xA6, 0xA8, 0x3F, 0xD3, 0x00, 0xD5, 0x80, 0xD9, 0xF1, 0xDA, 0x12, 0xDB, 0x40, 0x20, 0x02, 0x8D, 0x14, 0xA4, 0xA6, 0xAF};
  179.         for (int i=0; i<28; i++) Write_IIC_Command(shellcode[i]);
  180. }

  182. static void Error_Handler(void)
  183. {
  184.   BSP_LED_On(LED4);
  185.   while(1);
  186. }

  188. #ifdef  USE_FULL_ASSERT

  190. void assert_failed(uint8_t* file, uint32_t line)
  191. {
  192.   while (1);
  193. }
  194. #endif
复制代码 此帖出自小平头技术问答
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
2条回答
dontium
2019-03-24 02:12
/ 楼主在完全照搬，这怎么能行呢？

一周热门 更多>

相关问题