Setting Cursor Position in LCD

LCDFunctions.h

#ifndef LCDFunctionsHeader

#include <stdio.h>
#include <float.h>

#define LCDFunctionsHeader

#define LCDD0Pin 12
#define LCDD0Port GPIOB
#define LCDD1Pin 13
#define LCDD1Port GPIOB
#define LCDD2Pin 14
#define LCDD2Port GPIOB
#define LCDD3Pin 15
#define LCDD3Port GPIOB
#define LCDD4Pin 8
#define LCDD4Port GPIOA
#define LCDD5Pin 9
#define LCDD5Port GPIOA
#define LCDD6Pin 10
#define LCDD6Port GPIOA
#define LCDD7Pin 11
#define LCDD7Port GPIOA

#define LCDRegisterSelectPin 7
#define LCDRegisterSelectPort GPIOB
#define LCDReadWritePin 8
#define LCDReadWritePort GPIOB
#define LCDEnablePin 9
#define LCDEnablePort GPIOB

#define LCD_8_bit_dataline 0x38
#define LCD_DisplayON_CursorON 0x0F
#define LCD_Increment_Cursor_Position 0x06
#define LCD_Clear_Display 0x01
#define LCD_Next_Line_Command 0xC0

#define delayBeforeEnable 400
#define delayAfterEnable 800

void notExactTimedelay(int delayTime)
{
volatile int i;
for (i = 0; i < delayTime; ++i)
{

}
}

void SetupBitsAndPorts(GPIO_TypeDef *port, int pinNumber)
{
//Setup Reset and Clock Control Register
if(port == GPIOA)
{
RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;  //Enable clock to Port A
}
if(port == GPIOB)
{
RCC->APB2ENR |= RCC_APB2ENR_IOPBEN;  //Enable clock to Port B
}
if(port == GPIOC)
{
RCC->APB2ENR |= RCC_APB2ENR_IOPCEN;  //Enable clock to Port C
}
if(port == GPIOD)
{
RCC->APB2ENR |= RCC_APB2ENR_IOPDEN;  //Enable clock to Port D
}
if(port == GPIOE)
{
RCC->APB2ENR |= RCC_APB2ENR_IOPEEN;  //Enable clock to Port E
}

if(pinNumber>7)//If pinNumber>7 setup CRH else set CRL
{
//Setting Port as Push-Pull Configuration by setting CNF bits
port->CRH &= ~((1<<(4*(pinNumber-8)+3))|(1<<(4*(pinNumber-8)+2)));
//Setting Port as Output and at Max. Speed by setting MODE bits
port->CRH |= (1<<(4*(pinNumber-8)+1))|(1<<((4*pinNumber)));
}
else
{
//Setting Port as Push-Pull Configuration by setting CNF bits
port->CRL &= ~((1<<(4*(pinNumber)+3))|(1<<(4*(pinNumber)+2)));
//Setting Port as Output and at Max. Speed by setting MODE bits
port->CRL |= (1<<(4*(pinNumber)+1))|(1<<((4*pinNumber)));

}
}

void InitializePortsForLCD()
{
SetupBitsAndPorts(LCDD0Port, LCDD0Pin);
SetupBitsAndPorts(LCDD1Port, LCDD1Pin);
SetupBitsAndPorts(LCDD2Port, LCDD2Pin);
SetupBitsAndPorts(LCDD3Port, LCDD3Pin);
SetupBitsAndPorts(LCDD4Port, LCDD4Pin);
SetupBitsAndPorts(LCDD5Port, LCDD5Pin);
SetupBitsAndPorts(LCDD6Port, LCDD6Pin);
SetupBitsAndPorts(LCDD7Port, LCDD7Pin);

SetupBitsAndPorts(LCDRegisterSelectPort, LCDRegisterSelectPin);
SetupBitsAndPorts(LCDReadWritePort, LCDReadWritePin);
SetupBitsAndPorts(LCDEnablePort, LCDEnablePin);
}

void LCDDisplaySetup()
{
LCDsendACommand(LCD_8_bit_dataline); //8 bit data line for initialization
LCDsendACommand(LCD_DisplayON_CursorON); //Display ON, Cursor ON
LCDsendACommand(LCD_Increment_Cursor_Position); //Increment Cursor Position
LCDsendACommand(LCD_Clear_Display); //Clear display and return cursor
}

void LCDEnable()
{
sendBitToPortAndPin(LCDEnablePort, LCDEnablePin, 1);
}

void LCDDisable()
{
notExactTimedelay(delayAfterEnable);
sendBitToPortAndPin(LCDEnablePort, LCDEnablePin, 0);
}

void LCDReadEnable()
{
sendBitToPortAndPin(LCDReadWritePort, LCDReadWritePin, 1);
notExactTimedelay(delayBeforeEnable);
}

void LCDWriteEnable()
{
sendBitToPortAndPin(LCDReadWritePort, LCDReadWritePin, 0);
notExactTimedelay(delayBeforeEnable);
}

void LCDcommandMode()
{
sendBitToPortAndPin(LCDRegisterSelectPort, LCDRegisterSelectPin, 0); //RS=0
}

void LCDcharacterMode()
{
sendBitToPortAndPin(LCDRegisterSelectPort, LCDRegisterSelectPin, 1); //RS=1
}

void sendAByteToLCDDataPins(char character)
{
//Test bit 0 of character and send it to PB12
sendBitToPortAndPin(LCDD0Port, LCDD0Pin, character & 0b00000001);
//Test bit 1 of character and send it to PB13
sendBitToPortAndPin(LCDD1Port, LCDD1Pin, character & 0b00000010);
//Test bit 2 of character and send it to PB14
sendBitToPortAndPin(LCDD2Port, LCDD2Pin, character & 0b00000100);
//Test bit 3 of character and send it to PB15
sendBitToPortAndPin(LCDD3Port, LCDD3Pin, character & 0b00001000);
//Test bit 4 of character and send it to PA8
sendBitToPortAndPin(LCDD4Port, LCDD4Pin, character & 0b00010000);
//Test bit 5 of character and send it to PA9
sendBitToPortAndPin(LCDD5Port, LCDD5Pin, character & 0b00100000);
//Test bit 6 of character and send it to PA10
sendBitToPortAndPin(LCDD6Port, LCDD6Pin, character & 0b01000000);
//Test bit 7 of character and send it to PA11
sendBitToPortAndPin(LCDD7Port, LCDD7Pin, character & 0b10000000);
}

void sendBitToPortAndPin(GPIO_TypeDef *port, int pinNumber, uint8_t bitState)
{
if(bitState) {
port->BSRR |= (1 << pinNumber);
} else {
port->BRR |= (1 << pinNumber);
}
}

void LCDsendACommand(char command)
{
LCDcommandMode();
LCDWriteEnable();
LCDEnable();
sendAByteToLCDDataPins(command);
LCDDisable();
}

void LCDsendACharacter(char character)
{
LCDcharacterMode();
LCDWriteEnable();
LCDEnable();
sendAByteToLCDDataPins(character);
LCDDisable();
}

void LCDsendAString(char* StringOfCharacters)
{
while(*StringOfCharacters)
{
LCDsendACharacter(*StringOfCharacters++);
}
}

void LCDsendAnInteger(int number,uint8_t digitLength)
{
char StringInt[digitLength];
sprintf(StringInt,"%d",number);
LCDsendAString(StringInt);
}

void LCDsendAFloat(float number)
{
float x = number;
int intPart = x;
int fracPart = (x-intPart)*100000;
char IntegerPart[5];
char FractionPart[5];
char FloatString[10];
sprintf(IntegerPart, "%d", intPart);
sprintf(FractionPart, "%d", fracPart);
sprintf(FloatString,"%s.%s",IntegerPart,FractionPart);

LCDsendAString(FloatString);
}

void LCDSetCursorPosition(uint8_t x, uint8_t y)
{
uint8_t baseDisplayAddress = 0x80;
LCDsendACommand(baseDisplayAddress+x+y*64);
}

void LCDSendStringsIn2Lines(char* String1, char* String2)
{
LCDsendAString(String1);
LCDsendACommand(LCD_Next_Line_Command);
LCDsendAString(String2);
}

#endif


main.c

#include "stm32f1xx.h"
#include "LCDFunctions.h"

int main(void)
{
InitializePortsForLCD();
LCDDisplaySetup();

/*
char StringFloat[4];
float number=669.5326;
LCDsendAFloat(number);
*/
//uint8_t baseAddress = 0x80;

//Code for moving char 'x' through LCD
for(uint8_t y=0; y<2; y++)
{
for (uint8_t x= 0; x < 16; x++)
{
LCDSetCursorPosition(x,y);
LCDsendACharacter('x');
notExactTimedelay(500000);
LCDSetCursorPosition(x,y);
LCDsendACharacter(' ');
}

}

    while(1)
    {
    //Code for determining the DDRAM address
    /*
    for(uint8_t i=0; i<128; i++)
    {
    LCDsendACommand(baseAddress);
    LCDsendAnInteger(i+1,2);
    LCDsendACommand(baseAddress+i+1);
    LCDsendACharacter('x');
    notExactTimedelay(1000000);
    LCDsendACommand(baseAddress+i+1);
    LCDsendACharacter(' ');
    }
*/
    }
}

Comments

Post a Comment

Popular posts from this blog

HackRF with srsLTE and openlte

HackRF with srsLTE srsLTE supports USRP, bladeRF and SoapySDR. HackRF is interfaced to srsLTE via SoapySDR. 1)First build srsLTE 2)Install SoapySDR and test SoapySDR to detect HackRF One Follow link here: https://github.com/pothosware/SoapyHackRF/wiki Dependencies Install libhackrf - https://github.com/mossmann/hackrf/wiki Install SoapySDR: https://github.com/pothosware/SoapySDR/wiki Or install Hack RF packages on Ubuntu: I have followed this procedure: sudo add-apt-repository -y ppa:myriadrf/drivers sudo apt-get update sudo apt-get install hackrf libhackrf-dev Building Soapy Hack RF The CMake build system will locate libhackrf and SoapySDR development files on your system. The plugin module will be built and installed into the SoapySDR modules directories. git clone https://github.com/pothosware/SoapyHackRF.git cd SoapyHackRF mkdir build cd build cmake .. make sudo make install Probing Soapy Hack RF SoapySDRUtil --probe=...
Read more

Blinking a LED in STM32F103C8T6 (Blue Pill) Board

1) First Include STM32F103xB_CUBELIB and cmsis_core in the project #include "stm32f1xx.h" void waitForAmoment(int Moment) { volatile int i,j; for (i = 0; i < Moment; ++i) { j++; } } int main(void) { //Enable the GPIO Clock by AHB and RCC RCC->APB2ENR |= RCC_APB2ENR_IOPCEN; GPIOC ->CRH |= GPIO_CRH_MODE13; //PC13 in output mode, 50 MHz GPIOC->CRH &= ~(GPIO_CRH_CNF13); //PC13 General Purpose Output, Push Pull Config     while(1)     {     GPIOC->BSRR |= GPIO_BSRR_BS13;     waitForAmoment(1000000);     GPIOC->BRR |= GPIO_BRR_BR13;     waitForAmoment(1000000);     } }
Read more

Read Continuously from Serial Port in QT

#include <QCoreApplication> #include <QtSerialPort/QSerialPort> #include <Qdebug> QSerialPort serial; int main() { //COM Port Configuration serial.setPortName( "COM6" ); serial.setBaudRate( QSerialPort :: Baud9600 ); serial.setDataBits( QSerialPort :: Data8 ); serial.setParity( QSerialPort :: NoParity ); serial.setStopBits( QSerialPort :: OneStop ); serial.setFlowControl( QSerialPort :: NoFlowControl ); serial. open ( QIODevice :: ReadWrite ); char buffer[ 50 ]; while ( 1 ) { serial.waitForReadyRead(); // blocks calls until new data is available for reading. serial.readLine(buffer, 50 ); qDebug ()<<buffer; } serial. close (); }
Read more