Svenska ElektronikForumet

#include <Adafruit_GFX.h>
#include <Adafruit_PCD8544.h>
#include <OneWire.h>
#include <DallasTemperature.h>

Adafruit_PCD8544 display = Adafruit_PCD8544(7, 6, 5, 4, 3);

#define ONE_WIRE_BUS 2


OneWire oneWire(ONE_WIRE_BUS);


DallasTemperature sensors(&oneWire);

int rela = 8;


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

  display.begin();
 

 
  display.setContrast(40);

  display.display(); 
 
  display.clearDisplay();  
  sensors.begin();
  pinMode(rela, OUTPUT); 

  
}


void loop()
{
  
  sensors.requestTemperatures(); 
  float temp = sensors.getTempCByIndex(0);
  
  display.setTextSize(1);
  display.setTextColor(WHITE, BLACK);
  display.setCursor(4,0);
  display.print(" Beer Brewer ");
  display.setTextSize(2);
  display.setTextColor(BLACK);
  
  display.print("%0.2f C", temp);  // <--- Här är felet! 
  
  display.display();
  display.clearDisplay();
  
  
  
  
  if (temp < 21.69)
  {
    digitalWrite(rela, HIGH); 
    
  }
  else
  {
    digitalWrite(rela, LOW); 
  }

}

_ltermostat.ino: In function ‘void loop()’:
_ltermostat:75: error: call of overloaded ‘print(const char ∞, float&)’ is ambiguous
/home/acer/Program/arduino-1.0.4/hardware/arduino/cores/arduino/Print.h:59: note: candidates are: size_t Print::print(unsigned char, int) <near match>
/home/acer/Program/arduino-1.0.4/hardware/arduino/cores/arduino/Print.h:60: note: size_t Print::print(int, int) <near match>
/home/acer/Program/arduino-1.0.4/hardware/arduino/cores/arduino/Print.h:61: note: size_t Print::print(unsigned int, int) <near match>
/home/acer/Program/arduino-1.0.4/hardware/arduino/cores/arduino/Print.h:62: note: size_t Print::print(long int, int) <near match>
/home/acer/Program/arduino-1.0.4/hardware/arduino/cores/arduino/Print.h:63: note: size_t Print::print(long unsigned int, int) <near match>

display.print("%0.2f C", temp);

display.print(temp);

display.print("temp");

/*
Print.cpp - Base class that provides print() and println()
Copyright (c) 2008 David A. Mellis. All right reserved.

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library 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
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Modified 23 November 2006 by David A. Mellis
*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "Arduino.h"

#include "Print.h"

// Public Methods //////////////////////////////////////////////////////////////

/* default implementation: may be overridden */
size_t Print::write(const uint8_t *buffer, size_t size)
{
size_t n = 0;
while (size--) {
n += write(*buffer++);
}
return n;
}

size_t Print::print(const __FlashStringHelper *ifsh)
{
const char PROGMEM *p = (const char PROGMEM *)ifsh;
size_t n = 0;
while (1) {
unsigned char c = pgm_read_byte(p++);
if (c == 0) break;
n += write(c);
}
return n;
}

size_t Print::print(const String &s)
{
size_t n = 0;
for (uint16_t i = 0; i < s.length(); i++) {
n += write(s);
}
return n;
}

size_t Print::print(const char str[])
{
return write(str);
}

size_t Print::print(char c)
{
return write(c);
}

size_t Print::print(unsigned char b, int base)
{
return print((unsigned long) b, base);
}

size_t Print::print(int n, int base)
{
return print((long) n, base);
}

size_t Print::print(unsigned int n, int base)
{
return print((unsigned long) n, base);
}

size_t Print::print(long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printNumber(n, 10) + t;
}
return printNumber(n, 10);
} else {
return printNumber(n, base);
}
}

size_t Print::print(unsigned long n, int base)
{
if (base == 0) return write(n);
else return printNumber(n, base);
}

size_t Print::print(double n, int digits)
{
return printFloat(n, digits);
}

size_t Print::println(const __FlashStringHelper *ifsh)
{
size_t n = print(ifsh);
n += println();
return n;
}

size_t Print::print(const Printable& x)
{
return x.printTo(*this);
}

size_t Print::println(void)
{
size_t n = print('\r');
n += print('\n');
return n;
}

size_t Print::println(const String &s)
{
size_t n = print(s);
n += println();
return n;
}

size_t Print::println(const char c[])
{
size_t n = print(c);
n += println();
return n;
}

size_t Print::println(char c)
{
size_t n = print(c);
n += println();
return n;
}

size_t Print::println(unsigned char b, int base)
{
size_t n = print(b, base);
n += println();
return n;
}

size_t Print::println(int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}

size_t Print::println(unsigned int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}

size_t Print::println(long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}

size_t Print::println(unsigned long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}

size_t Print::println(double num, int digits)
{
size_t n = print(num, digits);
n += println();
return n;
}

size_t Print::println(const Printable& x)
{
size_t n = print(x);
n += println();
return n;
}

// Private Methods /////////////////////////////////////////////////////////////

size_t Print::printNumber(unsigned long n, uint8_t base) {
char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
char *str = &buf[sizeof(buf) - 1];

*str = '\0';

// prevent crash if called with base == 1
if (base < 2) base = 10;

do {
unsigned long m = n;
n /= base;
char c = m - base * n;
*--str = c < 10 ? c + '0' : c + 'A' - 10;
} while(n);

return write(str);
}

size_t Print::printFloat(double number, uint8_t digits)
{
size_t n = 0;

if (isnan(number)) return print("nan");
if (isinf(number)) return print("inf");
if (number > 4294967040.0) return print ("ovf"); // constant determined empirically
if (number <-4294967040.0) return print ("ovf"); // constant determined empirically

// Handle negative numbers
if (number < 0.0)
{
n += print('-');
number = -number;
}

// Round correctly so that print(1.999, 2) prints as "2.00"
double rounding = 0.5;
for (uint8_t i=0; i<digits; ++i)
rounding /= 10.0;

number += rounding;

// Extract the integer part of the number and print it
unsigned long int_part = (unsigned long)number;
double remainder = number - (double)int_part;
n += print(int_part);

// Print the decimal point, but only if there are digits beyond
if (digits > 0) {
n += print(".");
}

// Extract digits from the remainder one at a time
while (digits-- > 0)
{
remainder *= 10.0;
int toPrint = int(remainder);
n += print(toPrint);
remainder -= toPrint;
}

return n;
}

Andax skrev:Du har antagit att display-klassens print tar samma argument som printf som definieras av stdio i C/C++. printf tar en sträng som första argument ochsedan ett antal argument beroende på vad strängen innehåller för formatteringskoder.
I det här fallet finns inte motsvarande metod definierad för display-klassen (i det här fallet Adafruit_PCD8544). Däremot finns det ett antal special-print metoder som tar olika inputs och skriver ut dessa. Du har ju själv fetmarkerat dessa. om du inte använder println så kan du ju alltid dela upp utskriften i delar och skriva ut varje typ var för sig och få samma utformning som om du använt printf.

olof_n skrev:Enklast lösningen är att du först skriva ut flyttalet och sedan texten, då behöver du inte göra någonting.

Om du prompt vill slå ihop flyttalet och en sträng kan du göra följande:
Konvertera flytalet fTal till en sträng sTemp: dtostrf(fTal, 0, 1, sTemp);

Mer om AVR-funktionen dtostrf: http://www.nongnu.org/avr-libc/user-man ... 3ce8771d42

Sedan kan du slå ihop 2 strängar med standard C: strncat(sRad,sTemp,<längd>);
Mer om funktionen: http://www.cplusplus.com/reference/cstring/strncat/