예제 #1
0
void Init_LCD(void )			/* This is called once to initialise the display */
{

    LCD_RS=0;
    delay_ms(30);


    LCDWriteNibble(0b0010);
    delay_ms(4);

    LCDWriteNibble(0b0010);
    LCDWriteNibble(0b1000);
    delay_100uS();
    LCDWriteNibble(0b0010);
    LCDWriteNibble(0b1000);
    delay_100uS();
    LCDWriteNibble(0b0000); /* set 4 bits */
    LCDWriteNibble(0b1100); /* set 4 bits */
    delay_100uS();
    LCDWriteNibble(0b0000); /* set 4 bits */
    LCDWriteNibble(0b0001); /* set 4 bits */
    delay_100uS();
    delay_ms(8);
    LCDWriteNibble(0b0000); /* set 4 bits */
    LCDWriteNibble(0b0010); /* set 4 bits */
    delay_100uS();
    delay_ms(14);

    LCDWrite(0x4E);

    delay_100uS();
    LCDWrite(0x80);

}
예제 #2
0
파일: 3310.c 프로젝트: vincent290587/nRF52
//This function takes in a character, looks it up in the font table/array
//And writes it to the screen
//Each character is 8 bits tall and 5 bits wide. We pad one blank column of
//pixels on each side of the character for readability.
void LCDCharacter(char character) {
  LCDWrite(LCD_DATA, 0x00); //Blank vertical line padding

  for (int index = 0 ; index < 5 ; index++)
    LCDWrite(LCD_DATA, ASCII[character - 0x20][index]);
    //0x20 is the ASCII character for Space (' '). The font table starts with this character

  LCDWrite(LCD_DATA, 0x00); //Blank vertical line padding
}
예제 #3
0
//This takes a large array of bits and sends them to the LCD
void LCDBitmap(char my_array[]){
	int index;
	for (index = 0 ; index < (LCD_X * LCD_Y / 8) ; index++)
	{
    	LCDWrite(LCD_DATA, my_array[index]);
	}
}
예제 #4
0
/**
 * Called when a track is changed (instrument id, muted status...)
 */
void
TranzportClient::trackChanged(const Composition *c,
                              Track* track)
{
    RG_DEBUG << "TranzportClient, CompostionObserver::trackChanged";
    
    if (device_online) {
        const Track* track2 = c->getTrackById(c->getSelectedTrack());

        // If the changed track is the selected track
        if (track == track2) {
            RG_DEBUG << "TranzportClient, CompostionObserver::trackChanged updateing";
            
            if (track->isArmed()) {
                LightOn(LightTrackrec);
            } else {
                LightOff(LightTrackrec);
            }

            if (track->isMuted()) {
                LightOn(LightTrackmute);
            } else {
                LightOff(LightTrackmute);
            }

            LCDWrite(track->getLabel(), Bottom);
        }
    }
}
예제 #5
0
/**
 * Called when solo status changes (solo on/off, and selected track)
 */
void
TranzportClient::soloChanged(const Composition * c,
                             bool  solo,
                             TrackId  selectedTrack )
{
    RG_DEBUG << "TranzportClient, CompostionObserver::soloChanged";

    if (device_online) {
        if (solo) {
            LightOn(LightAnysolo);
        } else {
            LightOff(LightAnysolo);
        }

        Track* track = c->getTrackById(selectedTrack);

        if (track->isArmed()) {
            LightOn(LightTrackrec);
        } else {
            LightOff(LightTrackrec);
        }

        if (track->isMuted()) {
            LightOn(LightTrackmute);
        } else {
            LightOff(LightTrackmute);
        }

        LCDWrite(track->getLabel(), Bottom);
    }
}
예제 #6
0
//Clears the LCD by writing zeros to the entire screen
void LCDClear(void)
{
  for (u16 index = 0 ; index < (LCD_X * LCD_Y / 8) ; index++)
    LCDWrite(LCD_DATA, 0x00);
    
  gotoXY(0, 0); //After we clear the display, return to the home position
}
예제 #7
0
void LCDCat()
{
	int index;
	for (index = 0 ; index < (LCD_X * LCD_Y / 8) ; index++)
	{
    	LCDWrite(LCD_DATA, cat[index]);
	}
}
예제 #8
0
/******************************************************************************
 * Function:        void LCDUpdate(void)
 *
 * PreCondition:    LCDInit() must have been called once
 *
 * Input:           LCDText[]
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Copies the contents of the local LCDText[] array into the 
 *					LCD's internal display buffer.  Null terminators in 
 *					LCDText[] terminate the current line, so strings may be 
 *					printed directly to LCDText[].
 *
 * Note:            None
 *****************************************************************************/
void LCDUpdate(void)
{
	BYTE i, j;

	// Go home
	LCDWrite(0, 0x02);
	DelayMs(2);

	// Output first line
	for(i = 0; i < 16u; i++)
	{
		// Erase the rest of the line if a null char is 
		// encountered (good for printing strings directly)
		if(LCDText[0][i] == 0u)
		{
			for(j=i; j < 16u; j++)
			{
				LCDText[0][j] = ' ';
			}
		}
		LCDWrite(1, LCDText[0][i]);
		Delay10us(5);
	}
	
	// Set the address to the second line
	LCDWrite(0, 0xC0);
	Delay10us(5);
    
	// Output second line
//	for(i = 16; i < 32u; i++)
    for(i = 0; i < 16u; i++)
	{
		// Erase the rest of the line if a null char is 
		// encountered (good for printing strings directly)
		if(LCDText[1][i] == 0u)
		{
			//for(j=i; j < 32u; j++)
            for(j=i; j < 16u; j++)
			{
				LCDText[1][j] = ' ';
			}
		}
		LCDWrite(1, LCDText[1][i]);
		Delay10us(5);
	}
}
예제 #9
0
//This sends the magical commands to the PCD8544
void LCDInit(void) {
  //Configure control pins as output
	TRISAbits.TRISA3 = 0;  //SCE
	TRISAbits.TRISA4 = 0;	//Reset
	TRISAbits.TRISA5 = 0;	//DC


	Delay10TCYx(255);
  //Reset the LCD to a known state
	_LCDReset = 0;
	Delay10TCYx(255);
	_LCDReset = 1; 


	LCDWrite(LCD_COMMAND, 0x21); //Tell LCD that extended commands follow
	LCDWrite(LCD_COMMAND, 0x90); //0xa5 0x95 //Set LCD Vop (Contrast): Try 0xB1(good @ 3.3V) or 0xBF if your display is too dark
			//You'll probably need to play around with the contrast value above on your screen to make it look good. Mine vary depending on the room temperature
	LCDWrite(LCD_COMMAND, 0x03); //Set Temp coefficent
	LCDWrite(LCD_COMMAND, 0x14); //LCD bias mode 1:48: Try 0x13 or 0x14
	LCDWrite(LCD_COMMAND, 0x0C); //Set display control, normal mode. 0x0D for inverse (0x0C for normal)
	LCDWrite(LCD_COMMAND, 0x20); //We must send 0x20 before modifying the display control mode
	LCDWrite(LCD_COMMAND, 0x0C); //Set display control, normal mode. 0x0D for inverse (0x0C for normal)

	
}
예제 #10
0
void LCDCharacter(char character, char invertMode) {
	int index;
	LCDWrite(LCD_DATA, 0x00); //Blank vertical line padding
	for (index = 0 ; index < 5 ; index++)
    {
		if (invertMode == 1){
		LCDWrite(LCD_DATA, ~ASCII[character - 0x20][index]);
		} else {
		LCDWrite(LCD_DATA, ASCII[character - 0x20][index]);
		}
    	//0x20 is the ASCII character for Space (' '). The font table starts with this character
	}
	if (invertMode == 1){
		LCDWrite(LCD_DATA, 0xff); //Blank vertical line padding
	} else {
		LCDWrite(LCD_DATA, 0x00); //Blank vertical line padding
	}
}
예제 #11
0
//Clears the LCD by writing zeros to the entire screen
void LCDClear(void) {
	int index;
	gotoXY(0, 0); //Make sure that we start at the home position since the LCD seems to pick up where it left off. 
	for (index = 0 ; index < 504  ; index++) //(LCD_X * LCD_Y / 8) = 504  //Doesn't seem to work with the defined macros, but does if I hard-code the number of pixels/8
	{
		LCDWrite(LCD_DATA, 0x00);
	}   
  gotoXY(0, 0); //After we clear the display, return to the home position
}
예제 #12
0
/******************************************************************************
 * Function:        void LCDErase(void)
 *
 * PreCondition:    LCDInit() must have been called once
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Clears LCDText[] and the LCD's internal display buffer
 *
 * Note:            None
 *****************************************************************************/
void LCDErase(void)
{
	// Clear display
	LCDWrite(0, 0x01);
	DelayMs(2);

	// Clear local copy
	memset(LCDText, ' ', 32);
}
예제 #13
0
void
TranzportClient::stateUpdate()
{
    if (device_online) {
        LCDWrite("Rosegarden");

        if (m_composition->isSolo()) {
            LightOn(LightAnysolo);
        } else {
            LightOff(LightAnysolo);
        }

        if (m_composition->isLooping()) {
            LightOn(LightLoop);
        } else {
            LightOff(LightLoop);
        }

        TrackId trackID = m_composition->getSelectedTrack();
        Track* track = m_composition->getTrackById(trackID);

        if (track->isArmed()) {
            LightOn(LightTrackrec);
        } else {
            LightOff(LightTrackrec);
        }

        if (track->isMuted()) {
            LightOn(LightTrackmute);
        } else {
            LightOff(LightTrackmute);
        }

        LCDWrite(track->getLabel().substr(0,9), Bottom);

        int bar, beat, fraction, remainder;
        m_composition->getMusicalTimeForAbsoluteTime(
                m_composition->getPosition(), bar, beat, fraction, remainder);
        std::stringstream ss;
        ss << bar+1 << ":" << beat;
        LCDWrite(ss.str(), Bottom, 10);
    }
}
예제 #14
0
/*
 * Function implementations
 */
void show_screen(void) {
	// Reset our position in the LCD RAM
	LCDPosition(0,0);

	// Iterate through our buffer and write each byte to the LCD.
	unsigned int i;
	for(i = 0; i < LCD_BUFFER_SIZE; i++){
		LCDWrite(LCD_D, screenBuffer[i]);
	}
}
예제 #15
0
void LCD_build(unsigned char location, unsigned char *ptr){
       unsigned char i;
       if(location<8){
    	   LCDCommand(0x40+(location*8));
           for(i=0;i<8;i++)
        	   LCDWrite(ptr[ i ] );
           LCDCommand(0x80);
      }

 }
예제 #16
0
파일: LCD.c 프로젝트: bobomb/ColdFireSynth
void LCDWriteChar(uint8_t data)
{
	/*
	if (data=='\n') 
	{
		if (g_nCurrentLine >= LCD_LINES - 1)
			lcd_setline(0);
		else
			lcd_setline(g_nCurrentLine+1);
	}
	else
	*/
	LCDWrite(data,1);
	Cpu_Delay100US(20);
}
예제 #17
0
파일: LCD.C 프로젝트: tsuckow/LanComm
void lcdTest()
{
	LCDConfiguration();
	TMRConfiguration();
	LCDInitialization();

	LCDWrite(0x53);		//S
	LCDWrite(0x75);		//u
	LCDWrite(0x63);		//c
	LCDWrite(0x6B);		//k

	LCDWrite(0x20);		//' '

	LCDWrite(0x69);		//i
	LCDWrite(0x74);		//t
	LCDWrite(0x21);		//!
}
예제 #18
0
void
TranzportClient::pointerPositionChanged(timeT time)
{
    RG_DEBUG << "TranzportClient, pointerPositionChanged" << endl;

    if (device_online) {
        static int prevbeat = 0;
        int bar, beat, fraction, remainder;

        m_composition->getMusicalTimeForAbsoluteTime(time,bar,beat,fraction,remainder);
        if (prevbeat != beat) {
            std::stringstream ss;
            ss << bar+1 << ":" << beat;
            LCDWrite(ss.str(), Bottom, 10);
            prevbeat = beat;
        }
    }
}
예제 #19
0
void LCDWScrollText(char* inputText,unsigned char row, unsigned char col) {
	unsigned char address_d = 0;		// address of the data in the screen.
	switch(row)
	{
	case 0: address_d = 0x80 + col;		// at zeroth row
	break;
	case 1: address_d = 0xC0 + col;		// at first row
	break;
	case 2: address_d = 0x94 + col;		// at second row
	break;
	case 3: address_d = 0xD4 + col;		// at third row
	break;
	default: address_d = 0x80 + col;	// returns to first row if invalid row number is detected
	break;
	}

	LCDCommand(address_d);

	while(*inputText)					// Place a string, letter by letter.
		LCDWrite(*inputText++);
}
예제 #20
0
//This sends the magical commands to the PCD8544
void LCDInit(void)
{

  //Configure control pins
  LCD_DDR |= (1 << PIN_SCE) | (1 << PIN_RESET) | (1 << PIN_DC) | (1 << PIN_SDIN) | (1 << PIN_SCLK);

  //Reset the LCD to a known state
  LCD_PORT &= ~(1 << PIN_RESET);
  LCD_PORT |= (1 << PIN_RESET);

  LCDWrite(LCD_COMMAND, 0x21); //Tell LCD that extended commands follow
  LCDWrite(LCD_COMMAND, 0xB0); //Set LCD Vop (Contrast): Try 0xB1(good @ 3.3V) or 0xBF if your display is too dark
  LCDWrite(LCD_COMMAND, 0x04); //Set Temp coefficent
  LCDWrite(LCD_COMMAND, 0x14); //LCD bias mode 1:48: Try 0x13 or 0x14

  LCDWrite(LCD_COMMAND, 0x20); //We must send 0x20 before modifying the display control mode
  LCDWrite(LCD_COMMAND, 0x0C); //Set display control, normal mode. 0x0D for inverse
}
예제 #21
0
파일: 3310.c 프로젝트: vincent290587/nRF52
//This sends the magical commands to the PCD8544
void LCDInit(void) {

  //Configure control pins
  pinMode(PIN_SCE, OUTPUT);
  pinMode(PIN_RESET, OUTPUT);
  pinMode(PIN_DC, OUTPUT);
  pinMode(PIN_SDIN, OUTPUT);
  pinMode(PIN_SCLK, OUTPUT);

  //Reset the LCD to a known state
  digitalWrite(PIN_RESET, LOW);
  digitalWrite(PIN_RESET, HIGH);

  LCDWrite(LCD_COMMAND, 0x21); //Tell LCD that extended commands follow
  LCDWrite(LCD_COMMAND, 0xC0); //Set LCD Vop (Contrast): Try 0xB1(good @ 3.3V) or 0xBF if your display is too dark
  LCDWrite(LCD_COMMAND, 0x04); //Set Temp coefficent
  LCDWrite(LCD_COMMAND, 0x15); //LCD bias mode 1:48: Try 0x13 or 0x14

  LCDWrite(LCD_COMMAND, 0x20); //We must send 0x20 before modifying the display control mode
  LCDWrite(LCD_COMMAND, 0x0C); //Set display control, normal mode. 0x0D for inverse
}
예제 #22
0
파일: LCD.c 프로젝트: bobomb/ColdFireSynth
void LCDHome()
{
   	LCDWrite(1, 0);
   	Cpu_Delay100US(5);
}
예제 #23
0
파일: LCD.c 프로젝트: bobomb/ColdFireSynth
void LCDClear()
{
	
   	LCDWrite(0, 0);
   	Cpu_Delay100US(5);
}
예제 #24
0
파일: LCD.c 프로젝트: bobomb/ColdFireSynth
void LCDCommand(uint8_t command)
{
	LCDWrite(command, 0);
}
예제 #25
0
/******************************************************************************
 * Function:        void LCDInit(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        LCDText[] is blanked, port I/O pin TRIS registers are 
 *					configured, and the LCD is placed in the default state
 *
 * Note:            None
 *****************************************************************************/
void LCDInit(void)
{
	BYTE i;

	memset(LCDText, ' ', sizeof(LCDText)-1);
	LCDText[sizeof(LCDText)-1] = 0;

	// Setup the I/O pins
	LCD_E_IO = 0;
	LCD_RD_WR_IO = 0;


	#if defined(LCD_DATA_TRIS)
		LCD_DATA_TRIS = 0x00;
	#else
		LCD_DATA0_TRIS = 0;
		LCD_DATA1_TRIS = 0;
		LCD_DATA2_TRIS = 0;
		LCD_DATA3_TRIS = 0;
		#if !defined(FOUR_BIT_MODE)
		LCD_DATA4_TRIS = 0;
		LCD_DATA5_TRIS = 0;
		LCD_DATA6_TRIS = 0;
		LCD_DATA7_TRIS = 0;
		#endif
	#endif
	LCD_RD_WR_TRIS = 0;
	LCD_RS_TRIS = 0;
	LCD_E_TRIS = 0;


	// Wait the required time for the LCD to reset
	DelayMs(40);

	// Set the default function
	// Go to 8-bit mode first to reset the instruction state machine
	// This is done in a loop 3 times to absolutely ensure that we get 
	// to 8-bit mode in case if the device was previously booted into 
	// 4-bit mode and our PIC got reset in the middle of the LCD 
	// receiving half (4-bits) of an 8-bit instruction
	LCD_RS_IO = 0;
	#if defined(LCD_DATA_IO)
		LCD_DATA_IO = 0x03;
	#else
		LCD_DATA0_IO = 1;
		LCD_DATA1_IO = 1;
		LCD_DATA2_IO = 0;
		LCD_DATA3_IO = 0;
		#if !defined(FOUR_BIT_MODE)
		LCD_DATA4_IO = 0;
		LCD_DATA5_IO = 0;
		LCD_DATA6_IO = 0;
		LCD_DATA7_IO = 0;
		#endif
	#endif
	Nop();					// Wait Data setup time (min 40ns)
	Nop();
	for(i = 0; i < 3u; i++)
	{
		LCD_E_IO = 1;
		Delay10us(1);			// Wait E Pulse width time (min 230ns)
		LCD_E_IO = 0;
		DelayMs(2);
	}
	
#if defined(FOUR_BIT_MODE)
	#if defined(SAMSUNG_S6A0032)
		// Enter 4-bit mode (requires only 4-bits on the S6A0032)
		#if defined(LCD_DATA_IO)
			LCD_DATA_IO = 0x02;
		#else
			LCD_DATA0_IO = 0;
			LCD_DATA1_IO = 1;
			LCD_DATA2_IO = 0;
			LCD_DATA3_IO = 0;
		#endif
		Nop();					// Wait Data setup time (min 40ns)
		Nop();
		LCD_E_IO = 1;
		Delay10us(1);			// Wait E Pulse width time (min 230ns)
		LCD_E_IO = 0;
	#else
		// Enter 4-bit mode with two lines (requires 8-bits on most LCD controllers)
		LCDWrite(0, 0x28);
	#endif
#else
	// Use 8-bit mode with two lines
	LCDWrite(0, 0x38);
#endif
	Delay10us(5);
	
	// Set the entry mode
	LCDWrite(0, 0x06);	// Increment after each write, do not shift
	Delay10us(5);

	// Set the display control
	LCDWrite(0, 0x0C);		// Turn display on, no cusor, no cursor blink
	Delay10us(5);

	// Clear the display
	LCDWrite(0, 0x01);	
	DelayMs(2);
	
}
예제 #26
0
파일: 3310.c 프로젝트: vincent290587/nRF52
void gotoXY(int x, int y) {
  LCDWrite(0, 0x80 | x);  // Column  x - range: 0 to 84
  LCDWrite(0, 0x40 | y);  // Row     y - range: 0 to 5
}
예제 #27
0
void i_write(unsigned char v)
{
    LCD_RS=0;
    LCDWrite(v);
}
예제 #28
0
void gotoXY(int x, int y) {
  LCDWrite(0, 0x80 | x);  // Column in Pixels
  LCDWrite(0, 0x40 | y);  // Row in char_rows
}
예제 #29
0
void Pos_xy_LCD(int x,int y) 	/* Sets the position for the next character write */
{
    LCD_RS=0;
    if (!y) LCDWrite(0x80+x);
    else LCDWrite(0xc0+x);
}
예제 #30
0
void Put_LCD(char v)		/* Writes the character v to the display */
{
    LCD_RS=1;
    LCDWrite(v);
}