Display Nokia 3110 e temperatura

Salve a tutti, è la mia prima volta........ premetto che non ho competenze di programmazione ma basi di elettronica e molta manualità. Vi Chiedo se cortesemente mi potreste aiutare a far visualizzare la temperatura letta da un LM 335 (per adesso mi trovo solo questo) su un display Nokia3110. Mi spiego meglio, sono riuscito ad effettuare i collegamenti ed eseguire il classico esempio per visualizzare la scritta sul display "hello Word" ma non ho le basi per poter unire il sensore di temperatura in un unico sketch. Mi potreste aiutare magari partendo dagli sketch di esempio presenti nel Playground? Grazie

Ciao e benvenuto sul forum...

Non so se può tornarti utile questo progetto http://fritzing.org/projects/lm335-temperature-sensor/ sotto le immagini a destra trovi anche lo sketch per arduino

Al posto di spedire "Hallo Word" spedisci " temperatura" valore "gradi centigradi". Forse é necessario convertire il valore numerico della temperatura in un String.

Quale libreria o funzioni usi per pilotare il display Nokia3110 ?

Ciao Uwe

Ciao, grazie per la disponibilità.

Ho usato questi esempi http://www.arduino.cc/playground/Code/PCD8544. Più tardi verifico il tuo link.

Capisco che per chi ha studiato programmazione unire due sketch non deve essere una cosa difficile, ma per chi come me che vorrebbe fare ma non ha le basi diventa una cosa frustrante. Ci vorrebbe una guida iniziale, poi capiti i meccanismi si prova da soli. Ciao, grazie.

per leggere il valore della temperatura: int valore = analogRead(PIN_INGRESSO);

per convertire il valore in stringa: boh?

per stampare a video i valori: LcdString(ValoreStringa);

Con le stringhe in C++ ancora ci capisco poco, chi ci puo' aiutare? Devo realizzare anch'io lo stesso identico progetto appena ho due minuti liberi...

Non basta leggere il pin: la tensione letta, che è proporzionale alla temperatura misurata, va poi convertita in °C. Non mi ricordo la formuletta, ma va fatta la conversione, altrimenti vedi solo un valore che va da 0 a 1023... :D

Ora non sono a casa, stasera vi posto il codice del mio sketch.

#include "nokia_3310_lcd.h"
#include <Wire.h>
#include "RTClib.h"
#include <stdlib.h>

RTC_DS1307 RTC;

//keypad debounce parameter
#define DEBOUNCE_MAX 15
#define DEBOUNCE_ON  10
#define DEBOUNCE_OFF 3 

#define NUM_KEYS 5

// joystick number
#define UP_KEY 3
#define LEFT_KEY 0
#define CENTER_KEY 1
#define DOWN_KEY 2
#define RIGHT_KEY 4

Nokia_3310_lcd lcd=Nokia_3310_lcd();

// adc preset value, represent top value,incl. noise & margin,that the adc reads, when a key is pressed
// set noise & margin = 30 (0.15V@5V)
int  adc_key_val[5] ={30, 150, 360, 535, 760 };

// debounce counters
byte button_count[NUM_KEYS];
// button status - pressed/released
byte button_status[NUM_KEYS];
// button on flags for user program 
byte button_flag[NUM_KEYS];

unsigned long time_next_blink;
boolean flag;
int count;

void setup() {
    byte i,j,k; 
    DateTime now = RTC.now();
    // setup interrupt-driven keypad arrays  
    // reset button arrays
    for(byte i=0; i<NUM_KEYS; i++){
        button_count[i]=0;
        button_status[i]=0;
        button_flag[i]=0;
    }

    // Setup timer2 -- Prescaler/256
    TCCR2A &= ~((1<<WGM21) | (1<<WGM20));
    TCCR2B &= ~(1<<WGM22);
    TCCR2B = (1<<CS22)|(1<<CS21);      
    ASSR |=(0<<AS2);

    // Use normal mode  
    TCCR2A =0;    
    //Timer2 Overflow Interrupt Enable  
    TIMSK2 |= (0<<OCIE2A);
    TCNT2=0x6;  // counting starts from 6;  
    TIMSK2 = (1<<TOIE2);                    
 
    SREG|=1<<SREG_I;
    lcd.LCD_3310_init();
    //lcd.LCD_3310_light(LIGHT_OFF);

    time_next_blink=millis()+1000;
    flag=true;
    count=0;
    // check the status of the RTC
    Wire.begin();
    RTC.begin();
    if (! RTC.isrunning()) {
        lcd.LCD_3310_write_string(6,0,"THE INTERNAL",MENU_NORMAL);
        lcd.LCD_3310_write_string(6,1,"CLOCK IS NOT",MENU_NORMAL);
        lcd.LCD_3310_write_string(6,2,"RUNNING!!!!!",MENU_NORMAL);
        lcd.LCD_3310_write_string(6,3,"TIME RESET!!",MENU_NORMAL);
        RTC.adjust(DateTime(__DATE__,__TIME__));
        delay(5000);
        lcd.LCD_3310_clear();
    }

    show_time();
    show_temperature();
    time_next_blink=millis()+1000;
}


void loop(){

    if (millis()>time_next_blink) {
        show_time();
        show_temperature();
        time_next_blink=millis()+1000;
    }
    
}


void show_temperature() {
float i,  x;
int ii;
char temperature[10];

    DateTime now = RTC.now();
    x = analogRead(3);
    i =  (((x / 1023.0) * 5.00) - 2.7315) * 100.0;
    dtostrf(i, 5, 1, temperature);
    lcd.LCD_3310_write_string(6,5,"Temp: ",MENU_NORMAL);
    lcd.LCD_3310_write_string(36,5,temperature, MENU_NORMAL);
    
}

void show_time() {
char temp[2];
char ora[5];
char *temporaneo;
char *separator;

    DateTime now = RTC.now();
    sprintf(temp, "%02d", now.hour());
    
    // scrive l'ora
    lcd.LCD_3310_write_string_big(12,0,temp,MENU_NORMAL);
    if (int(now.second()) % 2 == 0) {
        separator = ".";
    } else {
        separator = " ";
    }        
    sprintf(temp, "%02d", now.minute());
    lcd.LCD_3310_write_string_big(36,0,separator,MENU_NORMAL);
    lcd.LCD_3310_write_string_big(42,0,temp,MENU_NORMAL);
    
    // scrive la data
    sprintf(temp,"%02d", now.day());
    lcd.LCD_3310_write_string(24,3,temp,MENU_NORMAL);
    lcd.LCD_3310_write_string(36,3,"/",MENU_NORMAL);
    sprintf(temp,"%02d", now.month());
    lcd.LCD_3310_write_string(42,3,temp,MENU_NORMAL);
    lcd.LCD_3310_write_string(54,3,"/",MENU_NORMAL);
    sprintf(temp,"%d", now.year()+1);
    lcd.LCD_3310_write_string(60,3,temp,MENU_NORMAL);
    
    
    switch(int(now.dayOfWeek())) {
        case 0:
            temporaneo="Lun";
        case 1:
            temporaneo="Mar";
        case 2:
            temporaneo="Mer";
        case 3:
            temporaneo="Gio";
        case 4:
            temporaneo="Ven";
        case 5:
            temporaneo="Sab";
        case 6:
            temporaneo="Dom";
    }
    lcd.LCD_3310_write_string(0,3,temporaneo,MENU_NORMAL);
    
}


/* menu functions */

// waiting for center key press
void waitfor_OKkey(){
    byte i;
    byte key = 0xFF;

    while (key!= CENTER_KEY){
        for(i=0; i<NUM_KEYS; i++){
            if(button_flag[i] !=0){
                button_flag[i]=0;  // reset button flag
                if(i== CENTER_KEY) key=CENTER_KEY;
            }
        }
    }		
}

//stampa un carattere alle coordinate X,Y
void printat(char x, char y, char character) {
    lcd.LCD_3310_set_XY(x*6,y);
    lcd.LCD_3310_write_char(character, MENU_NORMAL);
}





// The followinging are interrupt-driven keypad reading functions
//  which includes DEBOUNCE ON/OFF mechanism, and continuous pressing detection


// Convert ADC value to key number
char get_key(unsigned int input)
{
	char k;
    
	for (k = 0; k < NUM_KEYS; k++)
	{
		if (input < adc_key_val[k])
		{
           
    return k;
        }
	}
    
    if (k >= NUM_KEYS)
        k = -1;     // No valid key pressed
    
    return k;
}

void update_adc_key(){
  int adc_key_in;
  char key_in;
  byte i;
  
  adc_key_in = analogRead(0);
  key_in = get_key(adc_key_in);
  for(i=0; i<NUM_KEYS; i++)
  {
    if(key_in==i)  //one key is pressed 
    { 
      if(button_count[i]<DEBOUNCE_MAX)
      {
        button_count[i]++;
        if(button_count[i]>DEBOUNCE_ON)
        {
          if(button_status[i] == 0)
          {
            button_flag[i] = 1;
            button_status[i] = 1; //button debounced to 'pressed' status
          }
		  
        }
      }
	
    }
    else // no button pressed
    {
      if (button_count[i] >0)
      {  
		button_flag[i] = 0;	
		button_count[i]--;
        if(button_count[i]<DEBOUNCE_OFF){
          button_status[i]=0;   //button debounced to 'released' status
        }
      }
    }
    
  }
}

// Timer2 interrupt routine -
// 1/(160000000/256/(256-6)) = 4ms interval

ISR(TIMER2_OVF_vect) {  
  TCNT2  = 6;
  update_adc_key();
}

Tieni conto che:

  1. lo sketch funziona, come ti ho detto, con uno shield autocostruito con un RTC ed un sensore LM335Z. Il display l’ho su shield della NUelectronics per cui ho la libreria di gestione già precostituita.
    Lo sketch fa visualizzare l’ora grande, e sotto la data e la temperatura. Spero ti possa essere d’aiuto.

Grazie, ma personalmente non ho trovato spunti. Non ho uno shield e mi risulta difficile modificare lo sketch per il mio utilizzo. Io ho saldato i fili dietro un Display e collegato ad Arduino 2009 come segue:

Pin 1 - Vdd -------------------------------> +5v
Pin 2 - SCLK -------------------------------> pin 3
Pin 3 - SDIN ---------------------------------> pin 4
Pin 4 - D/C ------------------------------------> pin 5
Pin 5 - SCE ----------------------------------------> pin 7
Pin 6 - GND ------------------------------------> 0v / GND
Pin 7 - VOUT ------------------------------------> GND IMPORTANT: you have to put 10uF cap. between VOUT (pin 7) and Arduino GND
Pin 8 - RES - RESET ---------------------------------> pin 6

Ho effettuato delle prove con degli sketch, uno dei quali è sottoriportato.Tutto funziona mi visualizza la scritta che voglio. Ma risulta veramente difficile far scrivere la temperatura letta da un sensore (LM335) collegato al pin “0”. Aiutatemi a capire …grazie (o magari qualche anima pia posti direttamente lo schetch modificato).

:

#define PIN_SCE   7
#define PIN_RESET 6
#define PIN_DC    5
#define PIN_SDIN  4
#define PIN_SCLK  3

#define LCD_C     LOW
#define LCD_D     HIGH

#define LCD_X     84
#define LCD_Y     48

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 ?
,{0x78, 0x46, 0x41, 0x46, 0x78} // 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_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);
}

void setup(void)
{
  LcdInitialise();
  LcdClear();
  LcdString("Samantha    Simoncino");
}

void loop(void)
{
}

V

Nel mio codice c'è la formuletta per trasformare ciò che leggi sul pin analogico in °C