stm32samples/F1:F103/chronometer_v3/screen.c

/*
 * This file is part of the LED_screen project.
 * Copyright 2019 Edward V. Emelianov <eddy@sao.ru, edward.emelianoff@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <string.h> // memset, memcpy
#include <stdio.h>
#include "fonts.h"
#include "hardware.h"
#include "screen.h"
#include "spi.h"
#include "usart.h"

#undef DBG
#define DBG(x)

// !!!FOR LITTLE-ENDIAN!!!

// X coordinate - from left to right!
// Y coordinate - from top to bottom!
// (0,0) is top left corner

// all-screen buffer
static uint8_t screenbuf[SCREENBUF_SZ];
// buffers for DMA - for each of four parts
static uint8_t dmabuf[4][DMABUF_SZ];

/**
 * @brief FillScreen - fill screen buffer with 0 or 1
 * @param setclear   - !=1 to set & ==0 to reset
 */
void FillScreen(uint8_t setclear){
    uint8_t pattern = 0;
    if(setclear) pattern = 0xff;
    if(SCREEN_IS_NEGATIVE) pattern = ~pattern;
    for(int i = 0; i < SCREENBUF_SZ; ++i) screenbuf[i] = pattern;
        // memset -> halt
    //memset(screenbuf, pattern, SCREENBUF_SZ);
}

/**
 * @brief DrawPix - set or clear pixel
 * @param X, Y - pixel coordinates (could be outside of screen)
 * @param pix - == 1 to set and 0 to clear
 */
void DrawPix(int16_t X, int16_t Y, uint8_t pix){
    if(X < 0 || X > SCREEN_WIDTH-1 || Y < 0 || Y > SCREEN_HEIGHT-1) return; // outside of screen
    // now calculate coordinate of pixel
    uint8_t *ptr = &screenbuf[Y*SCREEN_WIDTH/8 + X/8];
    if(SCREEN_IS_NEGATIVE)pix = !pix;
    if(pix) *ptr |= 1 << (7 - (X%8));  // only for little-endian
    else *ptr &= ~(1 << (7 - (X%8))); // only for little-endian
}

/**
 * @brief DrawCharAt - draws character @ position X,Y (this point is left baseline corner of char!)
 * @param X, Y  - started point
  * @param Char - char to draw
 * @return char width
 */
uint8_t DrawCharAt(int16_t X, int16_t Y, uint8_t Char){
    const uint8_t *curchar = font_char(Char);
    if(!curchar) return 0;
    // now change Y coordinate to left upper corner of font
    Y += 1 - curfont->height + curfont->baseline;
    // height and width of letter in pixels
    uint8_t h = curfont->height, w = *curchar++; // now curchar is pointer to bits array
    uint8_t lw = curfont->bytes / h; // width of letter in bytes
    for(uint8_t row = 0; row < h; ++row){
        for(uint8_t col = 0; col < w; ++col){
            DrawPix(X + col, Y + row, curchar[row*lw + (col/8)] & (1 << (7 - (col%8)))); // only for little-endian
        }
    }
    return w;
}

/**
 * @brief GetStrWidth - get width of string (in pixels)
 * @param str - text string
 * @return amount of pixels
 */
uint16_t GetStrWidth(const char *str){
    uint16_t w = 0;
    while(*str){
        const uint8_t *curchar = font_char(*str);
        if(curchar){
            w += *curchar;
        }
        ++str;
    }
    return w;
}

/**
 * @brief ConvertScreenBuf - convert scscreenbuf into dmabuf
 *
 */
void ConvertScreenBuf(){
    for(uint8_t partNo = 0; partNo < 4; ++ partNo){ // cycle by strings
        uint8_t *dmaptr = dmabuf[partNo];
        for(int X = 0; X < SCREEN_WIDTH/8; ++X){
            for(int Y = SCREEN_HEIGHT-4+partNo; Y >= 0; Y -= 4){ // and cycle by Y
                *dmaptr++ = screenbuf[X + Y*(SCREEN_WIDTH/8)];
            }
        }
    }
}

/**
 * @brief PutStringAt - draw text string @ screen
 * @param X, Y - base coordinates
 * @param str  - string to draw
 * @return - text width in pixels
 */
uint8_t PutStringAt(int16_t X, int16_t Y, const char *str){
    if(!str) return 0;
    int16_t Xold = X;
    while(*str){
        X += DrawCharAt(X, Y, *str++);
    }
    return X - Xold;
}

uint8_t *getScreenBuf(){return screenbuf;}
uint8_t *getDmaBuf(uint8_t N){
    if(N > 3) return NULL;
    return dmabuf[N];
}

extern volatile uint32_t Tms;
typedef enum{ // screen states
    SCREEN_RELAX,       // nothing to do (screen is off)
    SCREEN_SPIACTIVE,   // SPI transmission active
    SCREEN_WAIT,        // pause - current quarter is ON
    SCREEN_UPDATENXT    // update next quarter
} screen_state;

static screen_state ScrnState = SCREEN_RELAX;

/**
 * @brief process_screen - screen state machine processing
 */
void process_screen(){
    static uint32_t Tscr_last = 0;
    static uint8_t currentQ = 0; // current quarter
    switch(ScrnState){
        case SCREEN_SPIACTIVE: // SPI transmission active
            if(SPI_status == SPI_READY){
                DBG("SPI ready\n");
                Tscr_last = Tms;
                ScrnState = SCREEN_WAIT;
                SET(SCLK); // lock data
            }
        break;
        case SCREEN_WAIT: // wait
            if(Tms - Tscr_last > SCREEN_PAUSE){
                DBG("Pause ends\n");
                ScrnState = SCREEN_UPDATENXT;
            }
        break;
        case SCREEN_UPDATENXT:
            if(SPI_status == SPI_NOTREADY){
                DBG("SPI not ready - setup");
                spi_setup();
                return;
            }
            if(SPI_status != SPI_READY){
                DBG("SPI busy");
                return; // SPI not ready - try next time
            }
            if(SPI_transmit(dmabuf[currentQ], DMABUF_SZ)){
                DBG("SPI error");
                return; // transmission error - try next time
            }
            DBG("Send next");
            ScrnState = SCREEN_SPIACTIVE;
            // now prepare selectors
            CLEAR(SCLK);
            switch(currentQ){ // set address bits
                case 0:
                    CLEAR(A);
                    CLEAR(B);
                break;
                case 1:
                    SET(A);
                    CLEAR(B);
                break;
                case 2:
                    CLEAR(A);
                    SET(B);
                break;
                case 3:
                    SET(A);
                    SET(B);
                break;
            }
            if(++currentQ > 3) currentQ = 0; // roll next
        break;
        default:
            return;
    }
}

/**
 * @brief ShowScreen - turn on data transmission
 */
void ShowScreen(){
    if(ScrnState == SCREEN_RELAX) ScrnState = SCREEN_UPDATENXT;
}

/**
 * @brief ScreenOFF - turn off screen & clear screen buffer
 */
void ScreenOFF(){
    DBG("Screen off");
    CLEAR(SCLK);
    CLEAR(A);
    CLEAR(B);
    FillScreen(0);
    ScrnState = SCREEN_RELAX;
}

void setdmabuf0(uint8_t pattern, uint8_t N){
    for(int i = 0; i < N; ++i) dmabuf[0][i] = pattern;
}