Go Down

Topic: Nokia 3310 / 5510 LCD assistance without library (Read 3315 times) previous topic - next topic

Coders:

I'm trying to figure out how to get the LCD display the Arduino calculated variables without using the PCD8544.h libraries. I've tried to use different ones from different sites, saved under different names  so I know which one I'm using, but none of them seem to work. So, I found some code that will make LCD display in bitmap, which is fine for what I want to use it for.

It works until I try to make the LCD display a variable using such code as:

Code: [Select]
LCDString("%i V\n",batteryVoltage);

The compiler generates output errors stating it does not like this code:
Code: [Select]
void LCDString(char *characters)
{
   while (*characters);
      LCDCharacter(*characters++);
}


here is the full code. It is pieced together from other code.
Code: [Select]


#define PIN_SCE   7 //Pin 3 on LCD
#define PIN_RESET 6 //Pin 4 on LCD
#define PIN_DC    5 //Pin 5 on LCD
#define PIN_SDIN  4 //Pin 6 on LCD
#define PIN_SCLK  3 //Pin 7 on LCD
#define LCD_COMMAND 0
#define LCD_DATA  1
#define LCD_X     84
#define LCD_Y     48

int batMonPin = A4;   
int batVal = 0;       // variable for the A/D value
float pinVoltage = 0; // variable to hold the calculated voltage
float batteryVoltage = 0;
float ratio = 2.4;  // Change this to match the MEASURED ration of the circuit, 12k R1 and 5k R2
int analogInPin = A0;  // Analog input pin that the carrier board OUT is connected to
int sensorValue = 0;        // value read from the carrier board
int outputValue = 0;        // output in milliamps
unsigned long msec = 0;
float time = 0.0;
int sample = 0;
float totalCharge = 0.0;
float averageAmps = 0.0;
float ampSeconds = 0.0;
float ampHours = 0.0;
float wattHours = 0.0;
float amps = 0.0;

//This table contains the hex values that represent pixels
//for a font that is 5 pixels wide and 8 pixels high
static const byte ASCII[][5] = {
  *** code snipped***

void setup()
{
  Serial.begin(9600);
  LCDInit();
}

void gotoXY(int x, int y)
{
  LCDWrite(0, 0x80 | x);  // Column.
  LCDWrite(0, 0x40 | y);  // Row.  ?
}

void LCDBitmap(char my_array[])
{
  for (int index = 0 ; index < (LCD_X * LCD_Y / 8) ; index++)
   LCDWrite(LCD_DATA, my_array[index]);

}


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]);

  LCDWrite(LCD_DATA, 0x00); //Blank vertical line padding
}

//Given a string of characters, one by one is passed to the LCD
void LCDString(char *characters)
{
  while (*characters)
    LCDCharacter(*characters++);
}

//Clears the LCD by writing zeros to the entire screen
void LCDClear(void)
{
  for (int 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
}

//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, 0xB9); //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
}

//There are two memory banks in the LCD, data/RAM and commands. This
//function sets the DC pin high or low depending, and then sends
//the data byte
void LCDWrite(byte data_or_command, byte data)
{
  digitalWrite(PIN_DC, data_or_command); //Tell the LCD that we are writing either to data or a command

  //Send the data
  digitalWrite(PIN_SCE, LOW);
  shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data);
  digitalWrite(PIN_SCE, HIGH);
}

void loop()
{
    // read the analog in value:
  sensorValue = analogRead(analogInPin);           
  // convert to milli amps
  outputValue = (((long)sensorValue * 5000 / 1024) - 500 ) * 1000 / 133; 
 
/* sensor outputs about 100 at rest.
Analog read produces a value of 0-1023, equating to 0v to 5v.
"((long)sensorValue * 5000 / 1024)" is the voltage on the sensor's output in millivolts.
There's a 500mv offset to subtract.
The unit produces 133mv per amp of current, so
divide by 0.133 to convert mv to ma
         
*/

 
  batVal = analogRead(batMonPin);    // read the voltage on the divider
  pinVoltage = batVal * 0.00488;       //  Calculate the voltage on the A/D pin
                                    //  A reading of 1 for the A/D = 0.0048mV
                                    //  if we multiply the A/D reading by 0.00488 then
                                    //  we get the voltage on the pin. 

  batteryVoltage = pinVoltage * ratio;    //  Use the ratio calculated for the voltage divider
                                          //  to calculate the battery voltage
                                         
                                           
  amps = (float) outputValue / 1000;
  float watts = amps * batteryVoltage;
   
  Serial.print("Volts = " );                       
  Serial.print(batteryVoltage);     
  Serial.print("\t Current (amps) = ");     
  Serial.print(amps); 
  Serial.print("\t Power (Watts) = ");   
  Serial.print(watts);   
 
   
  sample = sample + 1;
 
  msec = millis();
 
 
 
time = (float) msec / 1000.0;
 
totalCharge = totalCharge + amps;
 
averageAmps = totalCharge / sample;
 
ampSeconds = averageAmps*time;

ampHours = ampSeconds/3600;
 
wattHours = batteryVoltage * ampHours;
 


  Serial.print("\t Time (hours) = ");
  Serial.print(time/3600);
 
  Serial.print("\t Amp Hours (ah) = ");
  Serial.print(ampHours);
  Serial.print("\t Watt Hours (wh) = ");
  Serial.println(wattHours);
 
  // LCD readout 
  // LCDClear();
  gotoXY(0,0);
  LCDString("12.13V 3.48A");  // should be displaying batteryVoltage and amps
  gotoXY(0,1);
  LCDString("42.2W 0.5H");  // should be batteryVoltage*amps and time
  gotoXY(0,3);
  LCDString("21.1WH 1.74AH");  //should be displaying wattHours and ampHours

 
  delay(10);
}

olikraus

Hi

Code: [Select]
LCDString("%i V\n",batteryVoltage);
In your code LCDString is not defined with 2 arguments or variable arguments, so you can not use this statement.

Quote
The compiler generates output errors stating it does not like this code:

Is this another problem or is this releated to the LCDString? What kind of error is generated?

Code: [Select]
void LCDString(char *characters)
{
   while (*characters);
      LCDCharacter(*characters++);
}

Probably a very smart compiler, which detects the endless loop here. You see the problem  8) ?
And: The code above does not match the code in the full listing.

All in all, i guess your poblem is: You want to output a number, but you only have a procedure to output a string.
You have the following options: Derive a new class from the Arduino "Print" class or use sprintf()

Oliver

I'm using the 1.0.3 Arduino IDE. The error that is being generated when I try to use:
Code: [Select]
void LCDString(char *characters);
"In function 'void loop()', error: too many arguments to function 'void LCDString(char*)'

I honestly have zero idea what any of the syntax for the LCDString means.

And, the code given, where does it go? I tried a few different ways, and either I get errors, or nothing is displayed on the on the LCD. Yes I checked the connections. I reverted back to the original code to make sure I didn't break anything.

Nick_Pyner

I have to ask why you want to do this without using the libraries.  The intent of the code is hard to read but I get the impression there is nothing unusual. Here is code that doesn't use the library, but does work. It is from Stuart Lewis and was the best I found, so the vital bits may be of use.

Code: [Select]
/*
Scrolling text example code
Modified from: http://www.arduino.cc/playground/Code/PCD8544
*/

// The pins to use on the arduino
//            ARDUINO       5110
#define PIN_RESET 6     // PIN 1
#define PIN_SCE   7     // PIN 2
#define PIN_DC    5     // PIN 3
#define PIN_SDIN  16    // PIN 4
#define PIN_SCLK  8     // PIN 5

// Configuration for the LCD
#define LCD_C     LOW
#define LCD_D     HIGH
#define LCD_CMD   0

// Size of the LCD
#define LCD_X     84
#define LCD_Y     48

int scrollPosition = -10;

static const byte ASCII[][5] =
{
{0x00, 0x00, 0x00, 0x00, 0x00} // 20
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <
,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =
,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e >
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c ¥
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ?
,{0x00, 0x06, 0x09, 0x09, 0x06} // 7f ?
};

void LcdCharacter(char character)
{
  LcdWrite(LCD_D, 0x00);
  for (int index = 0; index < 5; index++)
  {
    LcdWrite(LCD_D, ASCII[character - 0x20][index]);
  }
  LcdWrite(LCD_D, 0x00);
}

void LcdClear(void)
{
  for (int index = 0; index < LCD_X * LCD_Y / 8; index++)
  {
    LcdWrite(LCD_D, 0x00);
  }
}

void LcdInitialise(void)
{
  pinMode(PIN_SCE,   OUTPUT);
  pinMode(PIN_RESET, OUTPUT);
  pinMode(PIN_DC,    OUTPUT);
  pinMode(PIN_SDIN,  OUTPUT);
  pinMode(PIN_SCLK,  OUTPUT);

  digitalWrite(PIN_RESET, LOW);
  digitalWrite(PIN_RESET, HIGH);

  LcdWrite(LCD_CMD, 0x21);  // LCD Extended Commands.
  LcdWrite(LCD_CMD, 0xBf);  // Set LCD Vop (Contrast). //B1
  LcdWrite(LCD_CMD, 0x04);  // Set Temp coefficent. //0x04
  LcdWrite(LCD_CMD, 0x14);  // LCD bias mode 1:48. //0x13
  LcdWrite(LCD_CMD, 0x0C);  // LCD in normal mode. 0x0d for inverse
  LcdWrite(LCD_C, 0x20);
  LcdWrite(LCD_C, 0x0C);
}

void LcdString(char *characters)
{
  while (*characters)
  {
    LcdCharacter(*characters++);
  }
}

void LcdWrite(byte dc, byte data)
{
  digitalWrite(PIN_DC, dc);
  digitalWrite(PIN_SCE, LOW);
  shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data);
  digitalWrite(PIN_SCE, HIGH);
}

/**
* gotoXY routine to position cursor
* x - range: 0 to 84
* y - range: 0 to 5
*/
void gotoXY(int x, int y)
{
  LcdWrite( 0, 0x80 | x);  // Column.
  LcdWrite( 0, 0x40 | y);  // Row.
}

void drawBox(void)
{
  int j;
  for(j = 0; j < 84; j++) // top
  {
    gotoXY(j, 0);
    LcdWrite(1, 0x01);
  }

  for(j = 0; j < 84; j++) //Bottom
  {
    gotoXY(j, 5);
    LcdWrite(1, 0x80);
  }

  for(j = 0; j < 6; j++) // Right
  {
    gotoXY(83, j);
    LcdWrite(1, 0xff);
  }

  for(j = 0; j < 6; j++) // Left
  {
    gotoXY(0, j);
    LcdWrite(1, 0xff);
  }
}

void Scroll(String message)
{
  for (int i = scrollPosition; i < scrollPosition + 11; i++)
  {
    if ((i >= message.length()) || (i < 0))
    {
      LcdCharacter(' ');
    }
    else
    {
      LcdCharacter(message.charAt(i));
    }
  }
  scrollPosition++;
  if ((scrollPosition >= message.length()) && (scrollPosition > 0))
  {
    scrollPosition = -10;
  }
}

void setup(void)
{
  LcdInitialise();
  LcdClear();
  //drawBox();

  gotoXY(1,1);
  LcdString("Nick Pyner's");
gotoXY(6,2);
LcdString("amazing");
  gotoXY(4,3);
  LcdString("Scroll Demo");
}

void loop(void)
{
  gotoXY(4,4);
  Scroll("Greetings from beautiful Dee Why Beach, just one small step short of paradise");
  delay(500);
}

I would love to use the libraries...

if they worked. I'm not understanding how for an LCD screen so common, with LOTS of different libraries for it, I cannot find one that will work.

However, I would like to gain an understanding to how make an LCD screen work without the use of a library so I can make use of the other LCD screens I have that do not have publicly available libraries for, like a couple of these larger Optrex 30x4 screens I have.

And going about this project this way, I don't have to stick with one LCD screen, I can change screens without changing many lines of code.

So I tried this in void loop, and still no dice. Perhaps some of this is in the wrong place? Wrong Syntax?
Code: [Select]
LCDClear();
gotoXY(0,0);
char buf[8];
sprintf(buff,"%2f",batteryVoltage);
LCDString(buff,"V");

trying to compile this mess gives the following error:
"In function voidloop() error; too many arguments is 'void LCDString(char*) at this point in file. I have not made any modifications to that section of the code since I first posted this thread.

Do I need something in the 'void setup()' that converts float to char, or string or whatever the hell this is?

I tried removing the LCDString mess from the 'void loop()' and it supposedly compiles and uploads, but nothing on the LCD screen is shown

olikraus

If you did not change the definition of LCDString(), then this procedure accepts exactly one argument, but you have passed two: [LCDString(buff,"V");], namely [buff] and ["V"], which causes he error.


Quote
if they worked. I'm not understanding how for an LCD screen so common, with LOTS of different libraries for it, I cannot find one that will work.


Did you try http://code.google.com/p/u8glib/? Let me know if u8glib does not work.

Oliver



Nick_Pyner


I would love to use the libraries...

if they worked. I'm not understanding how for an LCD screen so common, with LOTS of different libraries for it, I cannot find one that will work.



I guess this might be determined by something you specifically want. I wasn't actually aware there are lots of libraries. I just use the Philips PCD8544, it does nearly everything I want, and the related on-line glyph editor provides what I want that the the library doesn't.  Your code suggests that your end-product is much the same as mine, so I don't understand why you have such a problem.
I might point out that there are some mysteries and limitations with the 5110. The Stuart Little programme is the only one I found not using a library that gave me a decent display. Others were streaky and/or low contrast.  I tried making the setup common to all but never got to the bottom of this, and no longer have the problem now that I use the library.

Quote

And going about this project this way, I don't have to stick with one LCD screen, I can change screens without changing many lines of code.


I don't think that counts for much. It's just personal preference rather than technical advantage. You would have individual sketches for individual screens, and just call the relevant libraries for them all. I use three different screens interchangeably and don't see that a reason for dispensing with the relevant libararies.


Quote

If you did not change the definition of LCDString(), then this procedure accepts exactly one argument, but you have passed two: [LCDString(buff,"V");], namely [buff] and ["V"], which causes he error.


That much I figured as much. But, having zero idea what to change it to, or where can I find different options? Options such as changing the LCDString definition to something else entirely, to enable 'printing' of float data, or modifying it to print changing float data.

ok, I tried the libraries, both from Adafruit, and PCD8544.h. Errors, errors, more errors. Shit having to do with abstract, not being able to define something that is in the top of the damn code. What the hell is going on here?

This shit is really pissing me off. What in the hell am I doing wrong here?

Someone please point this dumb ass in the right direction about how to use a damn display

Nick_Pyner

#10
Feb 06, 2013, 06:11 am Last Edit: Feb 06, 2013, 01:16 pm by Nick_Pyner Reason: 1

Adafruit, and PCD8544.h. Errors, errors, more errors.
This shit is really pissing me off. What in the hell am I doing wrong here?


Probably quite a lot; and all the errors are probably yours and not the libraries'.  But nothing that isn't fixable.

Rather than the usual admonition to post your code that you will soon get from all and sundry, here is some that works, using a library. If you can't get a result then maybe, just maybe, there is something wrong with the library, in which case try this.

http://code.google.com/p/pcd8544/

Code: [Select]

//  This Arduino sketch reads DS18B20 "1-Wire" digital
//  temperature sensors.
//  Copyright (c) 2010 Mark McComb, hacktronics LLC
//  License: http://www.opensource.org/licenses/mit-license.php (Go crazy)
//  Tutorial:
//  http://www.hacktronics.com/Tutorials/arduino-1-wire-tutorial.html

//  Serial print commands are for PLX-DAQ
//  Research your own pins!

#include <OneWire.h>
#include <DallasTemperature.h>
#include "Wire.h"
#define DS1307_ADDRESS 0x68
#include <PCD8544.h>
static PCD8544 lcd;

int flag;
// Data wire is on pin 3
#define ONE_WIRE_BUS 3
// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);

// A custom "degrees" symbol...
static const byte DEGREES_CHAR = 1;
static const byte degrees_glyph[] = {
 0x00, 0x07, 0x05, 0x07, 0x00 };
static const byte SLASH_CHAR = 2;
static byte custom_glyph[] = {0x00,0x20,0x10,0x08};


// Assign the addresses of your 1-Wire temp sensors.
DeviceAddress InThermo = {
 0x28, 0x69, 0xC2, 0xB0, 0x03, 0x00, 0x00, 0X9F };
DeviceAddress OutThermo = {
 0x28, 0x7A, 0x8B, 0xC0, 0x03, 0x00, 0x00, 0x2F };
DeviceAddress DrainThermo = {
 0x28, 0x09, 0xA9, 0xC0, 0x03, 0x00, 0x00, 0x95 };    

//temperature variables
float InTemp, OutTemp, diff, DrainTemp, flow, power, tempC;

int conv;

void setup(){
 Wire.begin();
 Serial.begin(9600);
 lcd.begin(84, 48);
 // Register the custom symbol...
 lcd.createChar(DEGREES_CHAR, degrees_glyph);
 lcd.createChar(SLASH_CHAR, custom_glyph);

 lcd.setCursor(0,0);
 lcd.print("In");
 lcd.print("\001C ");
 lcd.setCursor(0,1);
 lcd.print("Out");
 lcd.print("\001C ");
 lcd.setCursor(0,2);
 lcd.print("Drain");
 lcd.print("\001C ");
 lcd.setCursor(0,3);
 lcd.print("F");
 lcd.setCursor(5,3);
 lcd.print("l");
 lcd.setCursor(10,3);
 lcd.print("ow");
 lcd.setCursor(24,3);
 lcd.print("l");
 lcd.setCursor(28,3);
 lcd.print("\002");
 lcd.print("m");
 lcd.setCursor(39,3);
 lcd.print("i");  
 lcd.setCursor(44,3);
 lcd.print("n");
 lcd.setCursor(14,4);
 lcd.print("Conv %");
 lcd.setCursor(21,5);
 lcd.print("kW");


 Serial.println("LABEL,Time,TempIn,TempOut,diff");
 // Print a message to the LCD.


 // Start up the library
 sensors.begin();
 sensors.setResolution(InThermo, 12);
 sensors.setResolution(OutThermo, 12);
 sensors.setResolution(DrainThermo, 12);
}

void loop(void)
{
 printDate();
 delay(1000);
 Serial.print("DATA,TIME,       ");
 flag = 0;
 //Get the sensor readings. There are THREE of them
 sensors.requestTemperatures();
 GetTemp(InThermo);
 InTemp=tempC;
 flag = 1;
 lcd.setCursor(54,0);
 lcd.print(InTemp);
 GetTemp(OutThermo);
 diff = tempC - InTemp;
 OutTemp=tempC;
 lcd.setCursor(54,1);
 lcd.print(OutTemp);
 Serial.print (diff);
 Serial.println(" ,  ");
 GetTemp(DrainThermo);
 DrainTemp=tempC;
 lcd.setCursor(54,2);
 lcd.print(DrainTemp);
 lcd.setCursor(54,3);
 lcd.print(diff);
 lcd.print("  ");
}

void GetTemp(DeviceAddress deviceAddress)
{
 tempC = sensors.getTempC(deviceAddress);
 if (tempC == -127.00) {
   Serial.print("Error getting temperature");
 }
 else {
   Serial.print(tempC);
   Serial.print(" ,  ");
 }
}

byte bcdToDec(byte val)  {
 // Convert binary coded decimal to normal decimal numbers
 return ( (val/16*10) + (val%16) );
}

void printDate(){

 // Reset the register pointer
 Wire.beginTransmission(DS1307_ADDRESS);

 byte zero = 0x00;
 Wire.write(zero);
 Wire.endTransmission();

 Wire.requestFrom(DS1307_ADDRESS, 7);

 int second = bcdToDec(Wire.read());
 int minute = bcdToDec(Wire.read());
 int hour = bcdToDec(Wire.read() & 0b111111); //24 hour time
 int weekDay = bcdToDec(Wire.read()); //0-6 -> sunday - Saturday
 int monthDay = bcdToDec(Wire.read());
 int month = bcdToDec(Wire.read());
 int year = bcdToDec(Wire.read());



 switch (weekDay)                      // Friendly printout the weekday
 {
 case 1:
   Serial.print("MON  ");
   break;
 case 2:
   Serial.print("TUE  ");
   break;
 case 3:
   Serial.print("WED  ");
   break;
 case 4:
   Serial.print("THU  ");
   break;
 case 5:
   Serial.print("FRI  ");
   break;
 case 6:
   Serial.print("SAT  ");
   break;
 case 7:
   Serial.print("SUN  ");
   break;
 }

 Serial.print(monthDay);
 Serial.print("/");
 Serial.print(month);
 Serial.print("/");
 Serial.print(year);
 Serial.print(" ");
 Serial.print(hour);
 Serial.print(":");
 Serial.print(minute);
 Serial.print(":");
 Serial.println(second);
 /*
 lcd.setCursor(0,4);
  lcd.print(monthDay);
  lcd.print("/");
  lcd.print(month);
  lcd.print("/");
  lcd.print(year);
 
  lcd.setCursor(0,5);
 
  if( second==0)
  {
  lcd.print("         ");
 
  lcd.setCursor(0,5);
  }
 
  lcd.print(hour);
  lcd.print(":");
  lcd.print(minute);
  lcd.print(":");
 
  lcd.print(second);  */
}



It has just occurred to me that you could have stuffed up the wiring. There is a bit of variation in the wiring of the 5110.  This would be negated if you have ever had anything readable, but I'm not sure you have.

Ok.

I did get the code to compile successfully this time. I've had it compile fine without the library before, but the 'LCDString' and my knowledge of the that sector only allowed a static display on the LCD. I could adjust the contrast all that jazz, but could not get the code to update the display.

This library does display changing data on the display, however, it's very light contrast, and only displaying the last line of instructions:
Code: [Select]

lcd.setCursor(0,2);
  lcd.print(ampHours);
  lcd.print(" Ah ");
  lcd.print(wattHours);
  lcd.print(" Wh ");


There are two sets of other instructions right above this line, that are not being shown on the LCD:
Code: [Select]

lcd.setCursor(0,0);
    lcd.print(batteryVoltage);
    lcd.print(" V ");
    lcd.print(amps);
    lcd.print(" A ");
 
  lcd.setCursor(0,1);
  lcd.print(watts);
  lcd.print(" W ");
  lcd.print(time/3600);
  lcd.print(" H ");


I'm looking in the header and .cpp file to see if I can adjust the contract either direct, or by command in the 'sketch' code.

well. It looks like I found two of the things I was looking for.

First, the lines of code that I wanted to do their thing, and display the resulting information on the screen.

In the 'void setup()' I had 'lcd.begin(12,6)'. Apparently to the PCD8544.cpp file, I saw this particular line wasn't correct for this particular application. In the 'PCD8544 begin' section, the initial setup, there was was no need to describe the amount of columns or lines/rows. So I removed the 12,6 and now just have 'lcd.begin()'.

Then in the code that pertains to the particular set of information that  needed to be displayed on a certain LCD line, I used the 'lcd.setCursor(x,x)'.

From the original bits of code I but together the delay was 10ms. That was too fast and the voltage and other stuff really changed too fast, so I set that to 1500ms.

to change the contrast, I thought from the non-library code that I originally posted, I could add the line 'this->send(PCD8544_CMD 0xB5)' under the 'begin' parameters. That didn't an apparent thing. I ended up changing a few hex codes to eventually end up where the bias is what changed the LCD contrast. That line was 'this->send(PCD8544_CMD 0x15)'.

And so it also seems to me, this crap is using hex to communicate with the screen and '0xba' is for a different command that '0xBa'.

Thanks for the assistance. I've learned a little about C and C++ from the mess. I understand how it works, for me it's just a matter of knowing syntax, and all the sub-processes/commands involved to do ONE thing. And that ONE thing could be one of many things to do another ONE process.

Nick_Pyner

On the contrast:

While I said I no longer have the problem now that I use the library, I suspect the real story is that the library just happens to have the settings OK with the information I now display.  I had three non-library programmes and the only one that worked was Stuart LIttle's. I played around with the hex stuff to no avail. I then made Little's commands common to all three. It helped the others but not enough. It appears that the quality of the display is partly determined by the nature of the information displayed.

I think I got some info on contrast from this magnum opus.
http://ianlangelectronic.webeden.co.uk/#/lcd-module-0/4569058582

Note also:

I understand these devices are surplus, so their price may reflect their compliance with specification.  In short, the contrast issue may be partly down to luck. I have two and they are both OK for my needs, but one has a blue backlight which is quite useless and better left off.

jumpjack


Coders:

I'm trying to figure out how to get the LCD display the Arduino calculated variables without using the PCD8544.h libraries. I've tried to use different ones from different sites, saved under different names  so I know which one I'm using, but none of them seem to work. So, I found some code that will make LCD display in bitmap, which is fine for what I want to use it for.

It works until I try to make the LCD display a variable using such code as:

Code: [Select]
LCDString("%i V\n",batteryVoltage);

The compiler generates output errors

The correct answer was a simple "you must pass a string to LCDString, not a string and a value, so you must create in advance a string containing the text and the values you want to be displayed".
There's nothing wrong in using the playground sample source for this display...

The actual issue is: HOW to create a string containing text AND values?
I'm trying with sprintf and it quite works:

Code: [Select]
    valore=analogRead(A0);
    Sprintf (buffer, "%d", analogRead(A0));
    gotoXY(1,1);
    LcdString(buffer);


This works fine, except that I can't figure out how to print always in the same position, text is being added after the already printed text!
Does it depends on Sprintf being concatenating, or in LcdString updating the print position?!?

Go Up