Вывод информации на TFT через SPI

#include "ILI9341.h"
 
 
void DMA1_Channel3_IRQHandler() {
  
  if(DMA1->ISR & DMA_ISR_TCIF3) {
     
    GPIOC->BSRR = GPIO_BSRR_BS8;
    
    DMA1->IFCR &= ~DMA_IFCR_CTCIF3;
    
    //TFT_DrawVerticalLine (40, 40, 150, 40,  RED);
    
  }
  
}
 
 
 
void rcc_init (void) {
  
  RCC->CR |= ((uint32_t)RCC_CR_HSEON);                      // Enable HSE
    while (!(RCC->CR & RCC_CR_HSERDY));                 // Ready start HSE      
    
    FLASH->ACR = FLASH_ACR_PRFTBE | FLASH_ACR_LATENCY;          // Cloclk Flash memory
    
    RCC->CFGR |= RCC_CFGR_HPRE_DIV1;                    // AHB = SYSCLK/1
    RCC->CFGR |= RCC_CFGR_PPRE1_DIV1;                   // APB1 = HCLK/1
    RCC->CFGR |= RCC_CFGR_PPRE2_DIV1;                   // APB2 = HCLK/1
    
    RCC->CFGR &= ~RCC_CFGR_PLLMULL;                             // clear PLLMULL bits
    RCC->CFGR &= ~RCC_CFGR_PLLSRC;                      // clearn PLLSRC bits
    RCC->CFGR &= ~RCC_CFGR_PLLXTPRE;                    // clearn PLLXTPRE bits
    
    RCC->CFGR |= RCC_CFGR_PLLSRC_PREDIV1;                   // source HSE
    RCC->CFGR |= RCC_CFGR_PLLXTPRE_PREDIV1_Div2;                // source HSE/2 = 4 MHz
    RCC->CFGR |= RCC_CFGR_PLLMULL6;                     // PLL x6: clock = 4 MHz * 6 = 24 MHz
    
    RCC->CR |= RCC_CR_PLLON;                                    // enable PLL
    while((RCC->CR & RCC_CR_PLLRDY) == 0) {}                    // wait till PLL is ready
    
    RCC->CFGR &= ~RCC_CFGR_SW;                                  // clear SW bits
        RCC->CFGR |= RCC_CFGR_SW_PLL;                                   // select source SYSCLK = PLL
    while((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_1) {}          // wait till PLL is used
        
        //Тактирование периферии
  
RCC->APB2ENR |= RCC_APB2ENR_IOPAEN | RCC_APB2ENR_IOPCEN | RCC_APB2ENR_AFIOEN | RCC_APB2ENR_SPI1EN;//Тактируем порты A,B,C, регистр альтернативных функций выводов, АЦП, SPI1 и TIM1
  
RCC->AHBENR |= RCC_AHBENR_DMA1EN; //Тактируем DMA1
 
}
 
void ALLpins_init () { 
  
  //PA0 - CS(3),PA1-DC(5), PA2 - RST(4),PA3 - LED, PA5 _SCK(7),PA6 - MISO(9),PA7 - MOSI(6)
  
GPIOC->CRL &= ~GPIO_CRL_CNF0;    GPIOC->CRL &= ~GPIO_CRL_CNF1;
GPIOC->CRL |= GPIO_CRL_MODE0;    GPIOC->CRL |= GPIO_CRL_MODE1;
 
GPIOC->CRH &= ~GPIO_CRH_CNF8;    GPIOC->CRH &= ~GPIO_CRH_CNF9;
GPIOC->CRH |= GPIO_CRH_MODE8;    GPIOC->CRH |= GPIO_CRH_MODE9;
   
GPIOA->CRL &= ~GPIO_CRL_CNF2;    GPIOA->CRL &= ~GPIO_CRL_CNF3;
GPIOA->CRL |= GPIO_CRL_MODE2;    GPIOA->CRL |= GPIO_CRL_MODE3;
   
   
     //вывод SCK: выход двухтактный, альтернативная функция, 50MHz
GPIOA->CRL   |=  GPIO_CRL_MODE5; GPIOA->CRL   &= ~GPIO_CRL_CNF5; GPIOA->CRL   |=  GPIO_CRL_CNF5_1;   
 
//вывод MISO: вход цифровой с подтягивающим резистором, подтяжка к плюсу
GPIOA->CRL   &= ~GPIO_CRL_MODE6; GPIOA->CRL   &= ~GPIO_CRL_CNF6; GPIOA->CRL   |=  GPIO_CRL_CNF6_1; GPIOA->BSRR   =  GPIO_BSRR_BS6;     
 
//вывод MOSI: выход двухтактный, альтернативная функция, 50MHz
GPIOA->CRL   |=  GPIO_CRL_MODE7; GPIOA->CRL   &= ~GPIO_CRL_CNF7; GPIOA->CRL   |=  GPIO_CRL_CNF7_1;   
 
}
 
 
void main () { 
  
  rcc_init ();
  ALLpins_init ();
  spi1_init ();
  TFT_init();
  
  TFT_led(1);
  
 
  
  
  
  while(1);
  
}

#include "ILI9341.h"
 
 
void spi1_init () { 
  
  SPI1->CR1 &= ~SPI_CR1_BIDIMODE;
  SPI1->CR1 &= ~SPI_CR1_BIDIOE;
  SPI1->CR1    |= SPI_CR1_MSTR;       //контроллер должен быть мастером 
  SPI1->CR1 &= ~SPI_CR1_DFF;               //8 bit data
  SPI1->CR1 &= ~SPI_CR1_CPOL;             //Polarity cls signal CPOL = 0;
  SPI1->CR1 &= ~SPI_CR1_CPHA;             //Phase cls signal    CPHA = 0;
  SPI1->CR1    |= SPI_CR1_SSI;        //обеспечить высокий уровень программного NSS
  SPI1->CR1    |= SPI_CR1_SSM;        //разрешить программное формирование NSS
  SPI1->CR1 |= SPI_CR1_BR_2; // fpclk/32
  SPI1->CR1 &= ~SPI_CR1_LSBFIRST;
  SPI1->CR2 |= SPI_CR2_TXDMAEN;//Разрешили передачу по DMA1_CH3
  SPI1->CR1    |= SPI_CR1_SPE;        //разрешить работу модуля SPI1
  
}
 
 
void spi8 () { 
  
  SPI1->CR1 &= ~SPI_CR1_SPE; //Отключили SPI1
  SPI1->CR1 &= ~SPI_CR1_DFF;//Передача 8 бит
  SPI1->CR1 |= SPI_CR1_SPE; //Включили SPI1
  
}
 
void spi16 () { 
  
  SPI1->CR1 &= ~SPI_CR1_SPE; //Отключили SPI1
  SPI1->CR1 |= SPI_CR1_DFF;//Передача 16 бит
  SPI1->CR1 |= SPI_CR1_SPE; //Включили SPI1
  
}
 
 
void sendDMA8(uint8_t data) {
    
        
        //spi8 ();
    DMA1_Channel3->CCR |= DMA_CCR3_DIR; //направление передачи из памяти в периферию
    DMA1_Channel3->CPAR |= (uint32_t)(&SPI1->DR); //В SPI1
    DMA1_Channel3->CMAR = (uint32_t)data; //е
    DMA1_Channel3->CNDTR = 1; //Количество пересылаемых значений = 1
    DMA1_Channel3->CCR |= DMA_CCR3_MINC;// Инкрементация памяти после каждой передачи включена
    DMA1_Channel3->CCR &= ~DMA_CCR3_PSIZE;//Размерность данных периферии 8 бит
        DMA1_Channel3->CCR &= ~DMA_CCR3_MSIZE;//Размерность данных памяти 8 бит
    DMA1_Channel3->CCR |= DMA_CCR3_PL; //Приоритет - очень высокий 
        DMA1_Channel3->CCR &= ~DMA_CCR3_CIRC; //Запрещвем работу DMA в циклическом режиме
        DMA1_Channel3->CCR |= DMA_CCR3_TCIE;//Разрешили прерывание после передачи 8 бит
        NVIC_EnableIRQ(DMA1_Channel3_IRQn); //общее разрешение прерываний
         __enable_irq(); //Глобальное разрешение прерываний
        DMA1_Channel3->CCR |= DMA_CCR3_EN; //Разрешаем работу 3-го канала DMA
        
}
 
void sendDMA16(uint16_t data) {
    
        
        //spi16 ();
    DMA1_Channel3->CCR |= DMA_CCR3_DIR; //направление передачи из памяти в периферию
    DMA1_Channel3->CPAR |= (uint32_t)(&SPI1->DR); //В SPI1
    DMA1_Channel3->CMAR = (uint32_t)data; //е
    DMA1_Channel3->CNDTR = 1; //Количество пересылаемых значений = 1
    DMA1_Channel3->CCR |= DMA_CCR3_MINC;// Инкрементация памяти после каждой передачи включена
    DMA1_Channel3->CCR &= ~DMA_CCR3_PSIZE;//Размерность данных периферии 8 бит
        DMA1_Channel3->CCR &= ~DMA_CCR3_MSIZE;//Размерность данных памяти 8 бит
    DMA1_Channel3->CCR |= DMA_CCR3_PL; //Приоритет - очень высокий 
        DMA1_Channel3->CCR &= ~DMA_CCR3_CIRC; //Запрещвем работу DMA в циклическом режиме
        DMA1_Channel3->CCR |= DMA_CCR3_TCIE;//Разрешили прерывание после передачи 8 бит
        NVIC_EnableIRQ(DMA1_Channel3_IRQn); //общее разрешение прерываний
         __enable_irq(); //Глобальное разрешение прерываний
        DMA1_Channel3->CCR |= DMA_CCR3_EN; //Разрешаем работу 3-го канала DMA
        
}
 
 
 
 
 
/*-----------------------------------------------Инит TFT-------------------------------------------------------------------------------*/
void TFT_init() {
     
    TFT_RST_LOW;
    for(int i=0; i<0x0FFFF; i++);
    TFT_RST_HIGH;
 
    TFT_sendCMD(0xCB);
    TFT_sendDATA(0x39);
    TFT_sendDATA(0x2C);
    TFT_sendDATA(0x00);
    TFT_sendDATA(0x34);
    TFT_sendDATA(0x02);
 
    TFT_sendCMD(0xCF);
    TFT_sendDATA(0x00);
    TFT_sendDATA(0xC1);
    TFT_sendDATA(0x30);
 
    TFT_sendCMD(0xE8);
    TFT_sendDATA(0x85);
    TFT_sendDATA(0x00);
    TFT_sendDATA(0x78);
 
    TFT_sendCMD(0xEA);
    TFT_sendDATA(0x00);
    TFT_sendDATA(0x00);
 
    TFT_sendCMD(0xED);
    TFT_sendDATA(0x64);
    TFT_sendDATA(0x03);
    TFT_sendDATA(0x12);
    TFT_sendDATA(0x81);
 
    TFT_sendCMD(0xF7);
    TFT_sendDATA(0x20);
 
    TFT_sendCMD(0xC0);      //Power control
    TFT_sendDATA(0x23);     //VRH[5:0]
 
    TFT_sendCMD(0xC1);      //Power control
    TFT_sendDATA(0x10);     //SAP[2:0];BT[3:0]
 
    TFT_sendCMD(0xC5);      //VCM control
    TFT_sendDATA(0x3e);     //Contrast
    TFT_sendDATA(0x28);
 
    TFT_sendCMD(0xC7);      //VCM control2
    TFT_sendDATA(0x86);      //--
 
    TFT_sendCMD(0x36);      // Memory Access Control
    TFT_sendDATA(0x48);     //C8       //48 68з»”ж*§зќ†//28 E8 е¦ЇоЃ„зќ†
 
    TFT_sendCMD(0x3A);
    TFT_sendDATA(0x55);
 
    TFT_sendCMD(0xB1);
    TFT_sendDATA(0x00);
    TFT_sendDATA(0x18);
 
    TFT_sendCMD(0xB6);      // Display Function Control
    TFT_sendDATA(0x08);
    TFT_sendDATA(0x82);
    TFT_sendDATA(0x27);
 
    TFT_sendCMD(0xF2);      // 3Gamma Function Disable
    TFT_sendDATA(0x00);
 
    TFT_sendCMD(0x26);      //Gamma curve selected
    TFT_sendDATA(0x01);
 
    TFT_sendCMD(0xE0);      //Set Gamma
    TFT_sendDATA(0x0F);
    TFT_sendDATA(0x31);
    TFT_sendDATA(0x2B);
    TFT_sendDATA(0x0C);
    TFT_sendDATA(0x0E);
    TFT_sendDATA(0x08);
    TFT_sendDATA(0x4E);
    TFT_sendDATA(0xF1);
    TFT_sendDATA(0x37);
    TFT_sendDATA(0x07);
    TFT_sendDATA(0x10);
    TFT_sendDATA(0x03);
    TFT_sendDATA(0x0E);
    TFT_sendDATA(0x09);
    TFT_sendDATA(0x00);
 
    TFT_sendCMD(0xE1);      //Set Gamma
    TFT_sendDATA(0x00);
    TFT_sendDATA(0x0E);
    TFT_sendDATA(0x14);
    TFT_sendDATA(0x03);
    TFT_sendDATA(0x11);
    TFT_sendDATA(0x07);
    TFT_sendDATA(0x31);
    TFT_sendDATA(0xC1);
    TFT_sendDATA(0x48);
    TFT_sendDATA(0x08);
    TFT_sendDATA(0x0F);
    TFT_sendDATA(0x0C);
    TFT_sendDATA(0x31);
    TFT_sendDATA(0x36);
    TFT_sendDATA(0x0F);
 
    TFT_sendCMD(0x11);      //Exit Sleep
    for(int i=0; i<0x00FFF; i++);
 
    TFT_sendCMD(0x29);    //Display on
    TFT_sendCMD(0x2c);
}
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
/*---------------------------------------------------Функции отправки----------------------------------------------------------------------------*/
void TFT_sendByte(uint8_t data)
{
 
    while(!(SPI1->SR & SPI_SR_TXE));
    //SPI1->DR =  data;
    sendDMA8(data);
}
 
void TFT_sendCMD(int index)
{
// ждем чтобы старые данные ушли до того как мы поменяем состояние линий управления дисплеем
 
    while(SPI1->SR & SPI_SR_BSY);
    
    TFT_DC_LOW;
    TFT_CS_LOW;
 
    sendDMA8(index);
    TFT_CS_HIGH;
}
 
void TFT_sendDATA(int data)
{
  
  while(SPI1->SR & SPI_SR_BSY);
    TFT_DC_HIGH;
    sendDMA8(data);
    TFT_CS_HIGH;
}
 
void TFT_sendWord(uint16_t data)
{
 
    while(SPI1->SR & SPI_SR_BSY);
    TFT_DC_HIGH;
 
    sendDMA16(data);
    TFT_CS_HIGH;
}
 
void TFT_led(int state)
{
    if (state)
        GPIOA->BSRR = GPIO_BSRR_BS3;
    else
        GPIOA->BSRR = GPIO_BSRR_BR3;
}
 
void TFT_setCol(int StartCol, int EndCol)
{
    TFT_sendCMD(0x2A);                                                      // Column Command address
    TFT_sendWord(StartCol);
    TFT_sendWord(EndCol);
}
 
void TFT_setPage(int StartPage, int EndPage)
{
    TFT_sendCMD(0x2B);                                                      // Column Command address
    TFT_sendWord(StartPage);
    TFT_sendWord(EndPage);
}
 
void TFT_setXY(int poX, int poY)
{
    TFT_setCol(poX, poX);
    TFT_setPage(poY, poY);
    TFT_sendCMD(0x2c);
}
 
void TFT_setPixel(int poX, int poY, int color)
{
    TFT_setXY(poX, poY);
    TFT_sendWord(color);
}
 
 
/*-----------------------------------------------------Вертикальная линия---------------------------------------------------------------*/
 
void TFT_DrawVerticalLine (uint16_t PosX, uint16_t PosY, uint16_t height, uint16_t thickness, uint16_t colour)  {
  
    int i=0,j=0;
  
    if (thickness>0) {
  
  for (i=PosY; i<height+PosY; i++) {
    for (j=PosX;j<thickness+PosX;j++) {
      
    TFT_setPixel(i,j, colour);
    
 
  } 
    }
      }
        }
 
/*-----------------------------------------------------Горизонтальная линия---------------------------------------------------------------*/
 
void TFT_DrawHorizontalLine (uint16_t PosX, uint16_t PosY, uint16_t width, uint16_t thickness, uint16_t colour)  {
  
    int i=0,j=0;
  
    if (thickness>0) {
  
  for (i=PosX; i<width+PosX; i++) {
    for (j=PosY;j<thickness+PosY;j++) {
      
    TFT_setPixel(j,i, colour);
    
 
  } 
    }
      }
        }
 
 
 
/*-----------------------------------------------------Пустой прямоугольник---------------------------------------------------------------*/
 
void TFT_DrawRectangle (uint16_t PosX, uint16_t PosY, uint16_t width, uint16_t height, uint16_t thickness, uint16_t colour)  {
  
  TFT_DrawHorizontalLine (PosX, PosY,  width, thickness, colour);
  TFT_DrawVerticalLine (PosX,  PosY,  height, thickness, colour);
  TFT_DrawHorizontalLine (PosX, PosY+height,  width+thickness, thickness, colour);
  TFT_DrawVerticalLine (PosX+width,  PosY,  height+thickness, thickness, colour);
  
        }

#include "Sinus.h"
#include "stm32f10x.h"
 
unsigned int sin[256] = {0,12,25,35,50,62,74,86,97,109,120,131,141,151,161,171,180,188,196,204,211,
218,224,230,235,239,243,246,249,251,253,254 /*32*/,
254,254,253,251,249,246,243,239,235,230,224,218,211,204,196,188,180,171,161,151,141,131,120,109,97,86,74,62,50,35,25,12,/*64*/
0,12,25,35,50,62,74,86,97,109,120,131,141,151,161,171,180,188,196,204,211,
218,224,230,235,239,243,246,249,251,253,254 /*96*/,
254,254,253,251,249,246,243,239,235,230,224,218,211,204,196,188,180,171,161,151,141,131,120,109,97,86,74,62,50,35,25,12,/*128*/};
 
int ax=0,bx=0,cx=0; //Переменные для прохода по массиву синуса
int A1x,A2x,A3x,A4x,A5x,A6x; //Переменные. для отслеживания содержимого CCRx счетчиков по напряжениям А,В,С
 
int Ua=1, Ub=1, Uc=1; //Амплитуда фаз напряжения А,B,C
int  phUa = 0, phUb=43, phUc=86; //Начальная фаза напряжений А,В,С
float freqU=750; //Частота sin U
 
 
/*-------------------------------------------------Формирование фазы А--------------------------------------------------------*/
void Form_Ua () {
 
                                         /*PA8 - Ua1, PA9 - Ua2*/
 
 ax++;
 if (ax<phUa+64) {TIM1->CCR1 = Ua*sin[ax-phUa];A1x=TIM1->CCR1;} // Это положительная полуволна фазы А
 if(ax>phUa+64) {TIM1->CCR1 = 0; A1x = 0; TIM1->CCR2 = Ua*sin[ax-phUa-64]; A2x=TIM1->CCR2;}// Это отрицательная полуволна фазы А
 if(ax>phUa+128) {ax = phUa; TIM1->CCR1 = 0; A1x = 0; TIM1->CCR2 = 0; A2x = 0;} // Ограничение. Если досчитали до 128-ми, сбрасываем счет до нуля и по-новой!!!
 
}
 
/*----------------------------------------------Формирование фазы В------------------------------------------------------------*/
void Form_Ub () {
 
                                           /*PA10 - Ub1, PA11 - Ub2*/
  
 bx++;
 if (bx>phUb) {TIM1->CCR3 = Ub*sin[bx-phUb];A3x=TIM1->CCR3;} //Это положительная полуволна фазы B
 if(bx>phUb+64) {TIM1->CCR3 = 0; A3x = 0; TIM1->CCR4 = Ub*sin[bx-phUb-64]; A4x=TIM1->CCR4;}//Это отрицательная полуволна фазы B
 if(bx>phUb+128) {bx = phUb; TIM1->CCR3 = 0; A3x = 0; TIM1->CCR4 = 0; A4x = 0;} // Ограничение. Если досчитали до 128-ми, сбрасываем счет до нуля и по-новой!!!
 
}
 
 
/*----------------------------------------------Формирование фазы C------------------------------------------------------------*/
void Form_Uc () {
  
                                            /*PB0 - Uc1, PB1 - Uc2*/
  
 cx++;
 if (cx>phUc) {TIM3->CCR3 = Uc*sin[cx-phUc];A5x=TIM3->CCR3;} //Это положительная полуволна фазы C
 if(cx>phUc+64) {TIM3->CCR3 = 0; A5x = 0; TIM3->CCR4 = Uc*sin[cx-phUc-64]; A6x=TIM3->CCR4;}//Это отрицательная полуволна фазы С
 if(cx>phUc+128) {cx = phUc; TIM3->CCR3 = 0; A5x = 0; TIM3->CCR4 = 0; A6x = 0;} // Ограничение. Если досчитали до 128-ми, сбрасываем счет до нуля и по-новой!!!
  
}