Olimex STM32-103STK LCD 8544 über SPI

[U. B. (ub007)]

Hallo.

Ich versuche seit geraumer Zeit das oben genannte Olimex-Board bzw. das 
daran-hängende LCD-Display PCD 8544 am SPI über STM32CubeIDE zum laufen 
zu bekommen. Dazu benutze ich die HAL-Funktionen von STM32.
Ich hab schon alles versucht aber das LCD-Display läßt sich einfach 
nicht ansprechen.
Irgendwie hab ich so langsam den Eindruck, dass es Timing-Probleme vom 
SPI sind. Als Programmer nütze ich den JLink-EDU. Selbst das im 
LCD-Datasheet aufgeführte Beispiel hab ich programmiert, aber es 
reagiert nicht.
Ich häng mal den Source hier mit rein vielleicht kann mir jemand 
weiterhelfen.

Gruß ub

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2019 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

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

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
#define LED_PortC       GPIO_PIN_12
#define LCD_CS_PortC    GPIO_PIN_10
#define LCD_DC_PortB    GPIO_PIN_2
#define LCD_Reset_PortC GPIO_PIN_7
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
#define LED_On()       GPIOC->BRR  |= LED_PortC
#define LED_Off()      GPIOC->BSRR |= LED_PortC

#define LCD_CS_Hi()    GPIOC->BSRR |= LCD_CS_PortC
#define LCD_CS_Lo()    GPIOC->BRR  |= LCD_CS_PortC

#define LCD_Data()     GPIOB->BSRR |= LCD_DC_PortB
#define LCD_Command()  GPIOB->BRR  |= LCD_DC_PortB

#define LCD_Reset_Lo() GPIOC->BRR  |= LCD_Reset_PortC
#define LCD_Reset_Hi() GPIOC->BSRR |= LCD_Reset_PortC

// Display Function Set = 0 0 1 0 0 PD V H
// PD=PowerDown 0=Chip active - 1=CHip in PowerDown
// V=Vertical-Mode 0=Horizontal-Adressing - 1=Vertical Adressing
// H=0 Basic Instruction H=1 Extended Instruction
// => PD=0 V=0 H=0    => 0010 0000 = 0x20
#define Disp_FunctionSet 0x20
#define Disp_FunctionSet_H 0x21

//      BankX = 0 1 0 0 0 Y2 Y1 Y0
#define Bank0 0x40
#define Bank1 0x41
#define Bank2 0x42
#define Bank3 0x43
#define Bank4 0x44
#define Bank5 0x45

// Display-Control bei DC=0=Command    0000 1D0E
// und H=0
// Blank               D=0 E=0       = 0000 1000 = 0x08
// Normal-Mode         D=1 E=0       = 0000 1100 = 0x0C
// All-Displaysegments D=0 E=1       = 0000 1001 = 0x09
// Invers              D=1 E=1       = 0000 1101 = 0x0D
#define Disp_Ctrl_Blank 0x08
#define Disp_Ctrl_Norm  0x0C
#define Disp_Ctrl_All   0x09
#define Disp_Ctrl_Inv   0x0D

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
SPI_HandleTypeDef hspi1;

/* USER CODE BEGIN PV */
HAL_StatusTypeDef spi1_status;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_SPI1_Init(void);

/* USER CODE BEGIN PFP */
void myDelay(unsigned long delay);
void LCD_Reset(void);
void Test_LCD(void);
void Write_Data(uint8_t v);
/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 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. */
  // Schön wärs, aber dann läuft der Debugger nich...
  // auskommentiert und damit gehts weiter.
  //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_SPI1_Init();

  /* USER CODE BEGIN 2 */
  uint8_t k=0,k1=0;
  LCD_Reset();
  LCD_CS_Hi();              // CS auf High damit LCD deaktiviert
  Test_LCD();
  LED_Off();
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  LCD_Data();      //D/C = High => Data

  while (1)
  {
    /* USER CODE BEGIN 3 */
    LED_Off();
    myDelay(500000);
    LED_On();
    myDelay(500000);
    k+=1;
    if (k >= 0x1F) { k = 0; }
    k1 = k & 0x1F;     // vordere 3 Bits ausblenden sonst inverse Darstellung
    //k1=0x1F;
    Write_Data(k1);

    /* USER CODE END 3 */
  }
  /* USER CODE END WHILE */
}

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

  /** Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

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

/**
  * @brief SPI1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_SPI1_Init(void)
{

  /* USER CODE BEGIN SPI1_Init 0 */

  /* USER CODE END SPI1_Init 0 */

  /* USER CODE BEGIN SPI1_Init 1 */

  /* USER CODE END SPI1_Init 1 */
  /* SPI1 parameter configuration*/
  hspi1.Instance = SPI1;
  hspi1.Init.Mode = SPI_MODE_MASTER;
  hspi1.Init.Direction = SPI_DIRECTION_2LINES;
  hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi1.Init.NSS = SPI_NSS_SOFT;
  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
  hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi1.Init.CRCPolynomial = 7;
  if (HAL_SPI_Init(&hspi1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI1_Init 2 */

  /* USER CODE END SPI1_Init 2 */

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOC_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_7|GPIO_PIN_10|GPIO_PIN_12, GPIO_PIN_RESET);

  /*Configure GPIO pin : PB2 */
  GPIO_InitStruct.Pin = GPIO_PIN_2;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pins : PC7 PC10 PC12 */
  GPIO_InitStruct.Pin = GPIO_PIN_7|GPIO_PIN_10|GPIO_PIN_12;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /*Configure GPIO pin : PA5 PA7  war nicht notwendig LCD geht trotzdem nicht*/
  GPIO_InitStruct.Pin = GPIO_PIN_5 | GPIO_PIN_7;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  //GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  //GPIO_PinRemapConfig(GPIO_Remap_SPI1, DISABLE);
}

/* USER CODE BEGIN 4 */
/**-------------------------------------------------------------------------
  * @brief  This function is to delay some seconds.
  * @retval None
  * ------------------------------------------------------------------------
  */
void myDelay(unsigned long delay)
{
   while(delay)
   {
      delay=delay-1;
      if (delay == 0) break;
      asm volatile ("nop");
   }
}

void LCD_Reset(void)
{
    LCD_CS_Lo();             // Enable auf High damit LCD aktiviert
    LCD_Reset_Lo();
    myDelay(10000);          // RST f. 10us auf Low dann wieder High
    LCD_Reset_Hi();
    LCD_CS_Hi();
}

void Test_LCD(void)
{
    uint8_t k1=0;

    LCD_Command();    // D/C = Low => Command
    Write_Data(Disp_FunctionSet_H);
    k1=0x90;
    Write_Data(k1);
    Write_Data(Disp_FunctionSet);
    Write_Data(Disp_Ctrl_Inv);
}

void Write_Data(uint8_t v)
{
    uint8_t k1=0;
    uint32_t timeout=2,error;

    //PCD8544_CS_L();
    //PCD8544_DATA();
    //SPI_I2S_SendData(SPI1, Data);
    //while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == SET);
    //PCD8544_CS_H();
    LCD_CS_Lo();    // LCD aktivieren
    k1 = v;
    spi1_status = HAL_SPI_Transmit(&hspi1,&k1,1,timeout);
    while(spi1_status == HAL_BUSY);
    LCD_CS_Hi();    // LCD deaktivieren
    error = HAL_SPI_GetError(&hspi1);
    if (error != 0)
    {
        Error_Handler();
    }
    myDelay(100);
}

/* 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 */
    int i=1;
    for (i=1;i<=5;i++)
    {
        /* USER CODE BEGIN 3 */
        LED_Off();
        myDelay(50000);
        LED_On();
        myDelay(50000);
        /* USER CODE END 3 */
    }
    myDelay(500000);

  /* 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,
     tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

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

[Verzwei Felter (Gast)]

U. B. schrieb:
> Ich häng mal den Source hier mit rein vielleicht kann mir jemand
> weiterhelfen.

Aber bitte nicht so.

Eigentlich sollte man annehmen können dass du lesen kannst.
Und den Inhalt entsprechend umsetzen.

[Stefan F. (Gast)]

> Ich hab schon alles versucht aber das LCD-Display läßt sich
> einfach nicht ansprechen.

Das ist eine Menge Quelltext mit einer noch viel größeren Menge 
Framework dahinter, welches nach meiner Erfahrung oft fehlerhaft ist 
(insbesondere was die STM32F1 Serie angeht).

Aber ich will Dir die HAL nicht madig machen, besser konstruktive 
Ratschläge geben. Das heisst in diesem Fall, Strukturiert vorgehen.

Zuerstmal solltest du mit einem Messgerät (z.B. Logic Analyzer) klären, 
was auf der SPI Schnittstelle passiert. Tut sich überhaupt irgend etwas? 
Und du solltest Unterbrechungspunkte in die Errorhandler setzen um 
nachzuschauen, welche Fehlercodes die HAL meldet. Dann suchst du die 
Erklärungen zu diesen Codes heraus.

Was ist mit deiner LED, blinkt die wenigstens regelmäßig alle 500ms?