728x90

728x90

Tuesday, November 18, 2025

STM32 Blue Pill and MCP23S17 16x4 LCD Example

In previous post I use the HSPI1 of the STM32F103C8T6 to interfaces with the MCP23S17 16-bit SPI I/O Expander chip. However this chip can interface with any digital I/O devices for instance a conventional HD44780 LCD or a matrix keypad.

STM32 Blue Pill and MCP23S17 16x4 LCD Example

 

In this example the MCP23S17 control an HD44780 compatible LCM at GPIOA and an 8-bit digital input switch at GPIOB. This 8-bit data reading will display on that character LCD in decimal, hexadecimal and binary format.

First we need to set the MCU parameter as follow.

STM32 Blue Pill HSPI1 and MCP23S17 GPIO Example
Clock Configuration


STM32 Blue Pill HSPI1 and MCP23S17 GPIO Example
SPI Setting

I only use the baud rate of 4Mbits per second due to data missing at the MCU SPI master data reception. However the this master MCU can transmit data up to 16Mbits per second to the MCP23S17 chip without error. 

STM32 Blue Pill and MCP23S17 16x4 LCD Example
Schematic

The NSS (or SPI slave select) pin disabled here because it's activated for every one or two data bytes packet. It is not applicable here that use three data bytes packet, slave address, register address and data to be written (SPI sequential write mode).

The HSPI port can be map into GPIO Port A or GPIO Port B. 

MCP23S17 pin latches data at logic low of its CS pin. So at start up or inactive state the master MCU must set its CS pin to logic high. 

  1. /* USER CODE BEGIN Header */
  2. /**
  3.   ******************************************************************************
  4.   * @file           : main.c
  5.   * @brief          : Main program body
  6.   ******************************************************************************
  7.   * @attention
  8.   *
  9.   * <h2><center>&copy; Copyright (c) 2025 STMicroelectronics.
  10.   * All rights reserved.</center></h2>
  11.   *
  12.   * This software component is licensed by ST under BSD 3-Clause license,
  13.   * the "License"; You may not use this file except in compliance with the
  14.   * License. You may obtain a copy of the License at:
  15.   *                        opensource.org/licenses/BSD-3-Clause
  16.   *
  17.   ******************************************************************************
  18.   */
  19. /* USER CODE END Header */
  20. /* Includes ------------------------------------------------------------------*/
  21. #include "main.h"
  22. #include <stdio.h>

  24. /* Private includes ----------------------------------------------------------*/
  25. /* USER CODE BEGIN Includes */

  27. /* USER CODE END Includes */

  29. /* Private typedef -----------------------------------------------------------*/
  30. /* USER CODE BEGIN PTD */

  32. /* USER CODE END PTD */

  34. /* Private define ------------------------------------------------------------*/
  35. /* USER CODE BEGIN PD */
  36. /* USER CODE END PD */

  38. /* Private macro -------------------------------------------------------------*/
  39. /* USER CODE BEGIN PM */

  41. /* USER CODE END PM */

  43. /* Private variables ---------------------------------------------------------*/
  44. SPI_HandleTypeDef hspi1;

  46. /* USER CODE BEGIN PV */

  48. /* USER CODE END PV */

  50. /* Private function prototypes -----------------------------------------------*/
  51. void SystemClock_Config(void);
  52. static void MX_GPIO_Init(void);
  53. static void MX_SPI1_Init(void);
  54. /* USER CODE BEGIN PFP */

  56. /*mcp23x17 registers at bank0*/
  57. #define IODIRA_0 	0x00
  58. #define IODIRB_0 	0x01
  59. #define IPOLA_0		0x02
  60. #define IPOLB_0		0x03
  61. #define GPINTENA	0x04
  62. #define GPINTENB	0x05
  63. #define GPPUA_0 	0x0C
  64. #define GPPUB_0 	0x0D
  65. #define GPIOA_0		0x12
  66. #define GPIOB_0 	0x13
  67. #define OLATA_0 	0x14
  68. #define OLATB_0 	0x15

  70. void mcp23s17_send(uint8_t address, uint8_t data){
  71. 	uint8_t temp[3];
  72. 	temp[0]=0x40;
  73. 	temp[1]=address;
  74. 	temp[2]=data;
  75. 	HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,0);
  76. 	HAL_SPI_Transmit(&hspi1, temp, 3, 1);
  77. 	HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,1);
  78. }

  80. uint8_t mcp23s17_receive(uint8_t addr){

  82. 	uint8_t temp[2], data=0;
  83. 	temp[0]=0x41;
  84. 	temp[1]=addr;

  86. 	HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,0);
  87. 	HAL_SPI_Transmit(&hspi1, temp, 2, 1);
  88. 	HAL_SPI_Receive(&hspi1,&data,1,1);
  89. 	HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,1);

  91. 	return data;
  92. }

  94. uint8_t DPORT;

  96. void delay1(uint16_t dTime){
  97. 	for(uint16_t i=0;i<dTime;i++);
  98. }

  100. void delay2(uint8_t dTime){
  101. 	for(uint8_t i=0;i<dTime;i++) delay1(5000);
  102. }

  104. void en(void){
  105. 	HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_SET);
  106. 	//delay1(10);
  107. 	HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_RESET);
  108. 	//delay1(10);
  109. }

  111. void lcdCmd(uint8_t cmd){
  112. 	uint8_t temp=0x08;
  113. 	DPORT=temp|(cmd&0xF0);
  114. 	mcp23s17_send(OLATA_0,DPORT);
  115. 	en();
  116. 	//delay1(10);
  117. 	temp=0;
  118. 	DPORT=temp|(cmd&0xF0);
  119. 	mcp23s17_send(OLATA_0,DPORT);
  120. 	en();

  122. 	temp=0x08;
  123. 	DPORT=temp|(cmd<<4);
  124. 	mcp23s17_send(OLATA_0,DPORT);
  125. 	en();
  126. 	//delay1(10);
  127. 	temp=0;
  128. 	DPORT=temp|(cmd<<4);
  129. 	mcp23s17_send(OLATA_0,DPORT);
  130. 	en();
  131. }

  133. void lcdDat(uint8_t dat){
  134. 	uint8_t temp=0x0A;
  135. 	DPORT=temp|(dat&0xF0);
  136. 	mcp23s17_send(OLATA_0,DPORT);
  137. 	en();
  138. 	//delay1(10);
  139. 	temp=0x02;
  140. 	DPORT=temp|(dat&0xF0);
  141. 	mcp23s17_send(OLATA_0,DPORT);
  142. 	en();

  144. 	temp=0x0A;
  145. 	DPORT=temp|(dat<<4);
  146. 	mcp23s17_send(OLATA_0,DPORT);
  147. 	en();
  148. 	//delay1(10);
  149. 	temp=0x02;
  150. 	DPORT=temp|(dat<<4);
  151. 	mcp23s17_send(OLATA_0,DPORT);
  152. 	en();
  153. }

  155. void lcdInit(void){
  156. 	DPORT=0x00;
  157. 	delay1(2000);
  158. 	mcp23s17_send(IODIRA_0,0x00);
  159. 	lcdCmd(0x33);
  160. 	delay1(100);
  161. 	lcdCmd(0x32);
  162. 	delay1(100);
  163. 	lcdCmd(0x28);
  164. 	delay1(100);
  165. 	lcdCmd(0x0F);
  166. 	delay1(100);
  167. 	lcdCmd(0x01);
  168. 	delay2(100);
  169. 	lcdCmd(0x06);
  170. 	delay1(100);
  171. }

  173. void lcdStr(uint8_t *str){
  174. 	while(*str) lcdDat(*str++);
  175. }

  177. void lcdXY(uint8_t x,uint8_t y){
  178. 	// 20x4 LCD
  179. 	//uint8_t tbe[]={0x80,0xC0,0x94,0xD4};
  180. 	// 16x4 LCD
  181. 	uint8_t tbe[]={0x80,0xC0,0x90,0xD0};
  182. 	lcdCmd(tbe[y-1]+x-1);
  183. 	delay1(100);
  184. }

  186. void lcdClear(void){
  187. 	lcdCmd(0x01);
  188. 	delay2(100);
  189. }

  191. int main(void)
  192. {
  193.   /* USER CODE BEGIN 1 */

  195.   /* USER CODE END 1 */

  197.   /* MCU Configuration--------------------------------------------------------*/

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

  202.   /* USER CODE BEGIN Init */

  204.   /* USER CODE END Init */

  206.   /* Configure the system clock */
  207.   SystemClock_Config();

  209.   /* USER CODE BEGIN SysInit */

  211.   /* USER CODE END SysInit */

  213.   /* Initialize all configured peripherals */
  214.   MX_GPIO_Init();
  215.   MX_SPI1_Init();

  217.   HAL_SPI_Init(&hspi1);
  218.   /*GPIOB As Inputs With Pull Ups*/
  219.   mcp23s17_send(IODIRB_0,0xFF);
  220.   mcp23s17_send(GPPUB_0,0xFF);

  222.   lcdInit();
  223.   lcdClear();
  224.   lcdCmd(0x0C);

  226.   lcdXY(3,1);
  227.   lcdStr("Hello World!");

  229.   lcdXY(3,2);
  230.   lcdStr("STM32F103C8T6 ");

  232.   lcdXY(1,3);
  233.   lcdStr("HSPI1 MCP23S17");

  235.   lcdXY(1,4);
  236.   lcdStr("TC1604A-01R LCD");

  238.   HAL_Delay(3000);
  239.   lcdClear();

  241.   lcdXY(1,1);
  242.   lcdStr("STM32CubeIDE");

  244.   lcdXY(1,2);
  245.   lcdStr("version 1.6.0");

  247.   lcdXY(1,3);
  248.   lcdStr("HAL Library...");

  250.   lcdXY(1,4);
  251.   lcdStr("18/11/2025");

  253.   HAL_Delay(3000);
  254.   lcdClear();

  256.   char dec[3],hex[4],bin[8],input=0,input_old=1;
  257.   lcdXY(1,1); lcdStr("GPB 8-Bit Input: ");
  258.   lcdXY(1,2); lcdStr("Decimal: ");
  259.   lcdXY(1,3); lcdStr("Hexadecimal:");
  260.   lcdXY(1,4); lcdStr("Binary: ");
  261.   while (1)
  262.   {
  263.     input = mcp23s17_receive(GPIOB_0);
  264.     if(input!=input_old){
  265.     	sprintf(&dec, "%3d",input);
  266.     	lcdXY(13,2); lcdStr(dec);
  267.     	sprintf(&hex, "0x%02X",input);
  268.     	lcdXY(13,3); lcdStr(hex);
  269.     	for(int8_t i=0;i<8;i++){
  270.     		if((input&(1<<i))==0) bin[7-i]='0';
  271.     		else bin[7-i]='1';
  272.     }
  273.     lcdXY(9,4); lcdStr(bin);
  274.     }
  275.     input_old=input;
  276.   }
  277.   /* USER CODE END 3 */
  278. }

  280. /**
  281.   * @brief System Clock Configuration
  282.   * @retval None
  283.   */
  284. void SystemClock_Config(void)
  285. {
  286.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  287.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  289.   /** Initializes the RCC Oscillators according to the specified parameters
  290.   * in the RCC_OscInitTypeDef structure.
  291.   */
  292.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  293.   RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  294.   RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  295.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  296.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI_DIV2;
  297.   RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL16;
  298.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  299.   {
  300.     Error_Handler();
  301.   }
  302.   /** Initializes the CPU, AHB and APB buses clocks
  303.   */
  304.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
  305.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  306.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  307.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  308.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  309.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  311.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  312.   {
  313.     Error_Handler();
  314.   }
  315. }

  317. /**
  318.   * @brief SPI1 Initialization Function
  319.   * @param None
  320.   * @retval None
  321.   */
  322. static void MX_SPI1_Init(void)
  323. {

  325.   /* USER CODE BEGIN SPI1_Init 0 */

  327.   /* USER CODE END SPI1_Init 0 */

  329.   /* USER CODE BEGIN SPI1_Init 1 */

  331.   /* USER CODE END SPI1_Init 1 */
  332.   /* SPI1 parameter configuration*/
  333.   hspi1.Instance = SPI1;
  334.   hspi1.Init.Mode = SPI_MODE_MASTER;
  335.   hspi1.Init.Direction = SPI_DIRECTION_2LINES;
  336.   hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
  337.   hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
  338.   hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
  339.   hspi1.Init.NSS = SPI_NSS_SOFT;
  340.   hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
  341.   hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
  342.   hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
  343.   hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  344.   hspi1.Init.CRCPolynomial = 10;
  345.   if (HAL_SPI_Init(&hspi1) != HAL_OK)
  346.   {
  347.     Error_Handler();
  348.   }
  349.   /* USER CODE BEGIN SPI1_Init 2 */

  351.   /* USER CODE END SPI1_Init 2 */

  353. }

  355. /**
  356.   * @brief GPIO Initialization Function
  357.   * @param None
  358.   * @retval None
  359.   */
  360. static void MX_GPIO_Init(void)
  361. {
  362.   GPIO_InitTypeDef GPIO_InitStruct = {0};

  364.   /* GPIO Ports Clock Enable */
  365.   __HAL_RCC_GPIOA_CLK_ENABLE();

  367.   /*Configure GPIO pin Output Level */
  368.   HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);

  370.   /*Configure GPIO pin : PA4 */
  371.   GPIO_InitStruct.Pin = GPIO_PIN_4;
  372.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  373.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  374.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  375.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  377. }

  379. /* USER CODE BEGIN 4 */

  381. /* USER CODE END 4 */

  383. /**
  384.   * @brief  This function is executed in case of error occurrence.
  385.   * @retval None
  386.   */
  387. void Error_Handler(void)
  388. {
  389.   /* USER CODE BEGIN Error_Handler_Debug */
  390.   /* User can add his own implementation to report the HAL error return state */
  391.   __disable_irq();
  392.   while (1)
  393.   {
  394.   }
  395.   /* USER CODE END Error_Handler_Debug */
  396. }

  398. #ifdef  USE_FULL_ASSERT
  399. /**
  400.   * @brief  Reports the name of the source file and the source line number
  401.   *         where the assert_param error has occurred.
  402.   * @param  file: pointer to the source file name
  403.   * @param  line: assert_param error line source number
  404.   * @retval None
  405.   */
  406. void assert_failed(uint8_t *file, uint32_t line)
  407. {
  408.   /* USER CODE BEGIN 6 */
  409.   /* User can add his own implementation to report the file name and line number,
  410.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  411.   /* USER CODE END 6 */
  412. }
  413. #endif /* USE_FULL_ASSERT */

  415. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

 

The simulation process in Proteus VSM is slow. However I think I can test this program in physical hardware whenever I have this SPI chip. 

 

STM32 Blue Pill and MCP23S17 16x4 LCD Example

STM32 Blue Pill and MCP23S17 16x4 LCD Example

STM32 Blue Pill and MCP23S17 16x4 LCD Example

STM32 Blue Pill and MCP23S17 16x4 LCD Example

STM32 Blue Pill and MCP23S17 16x4 LCD Example

Click here to download its source file. 


 

on
Labels: , , , , , , ,

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)

320x50

Search This Blog

tyro-728x90