Resolutie Temperatuur op Nokia display

Op 4 juli 2016 22:08:45 schreef blackdog:
Dit wordt nergens in de code geaccepteerd: float druk = 0,0;
Dit stukje code heb ik op verschillende plekken geprobeerd te plaatsen, endat geeft dan de eerste error bij het compilen.

error: expected unqualified-id before numeric constant

Je mag geen komma gebruiken.

Kun je eens de code proberen zoals ik hem hierboven voor je heb gemaakt?
... misschien heb je niet in de gaten gehad dat die lap die ik heb gepost een AANGEPASTE versie is?

Gewoon even letterlijk copy-paste doen, kan ik aanraden.

Hi,

Net werkend gekregen!
Nog een stukje code ergens anders vandaan gevist en daar in gekeken hoe de data uit de BMP180 wordt gehaald.
In deze code stond nog een extra commando, en deze het ik toegevoegd en het werkt nu.
Zie plaatje hieronder, de extra code is: bmp.getEvent(&event);

Roland,
Ik heb jouw stukje code gebruikt voor het uitlezen van de analoge ingang en dat werkt ook.

Morgen misschien verder er mee en het beter proberen te begrijpen

Gegroet en bedankt allemaal,
Bram

Officieel gezien in C mag "float xxx = 0.0;" niet. Nu is de omgeving waar jij in werkt wat meer vergevend wat betreft syntax.

float x = 0;    \\ hier maak je van een integer een float zonder cast.
float x = 0,0;  \\ C werkt met . en niet met ,
float x = 0.0;  \\ Hier maak je van een double een float zonder cast.
float x = 0.0f; \\ Dit is de juiste manier om een float een waarde te geven

Ik heb eventueel nog wel een PDF liggen over C. Daar staan al dat soort dingen in beschreven. Helaas, ik kan hem niet meer vinden. Mocht hij opduiken dan ben je de eerste. Of je kunt het even googelen natuurlijk "c float initialization" geeft bij mij meteen al een goed antwoord.

De ontwikkel omgeving die je nu gebruikt is door de arduino mensen gemaakt om het gemakkelijk te maken voor mensen die willen beginnen met het leren van programmeren. Het is zo makkelijk omdat je voor bijna alles wat je doet een library gebruikt. Je hoeft je nu niet te verdiepen in het aansturen van registers en hoe dat alles werkt.

Mocht je wat serieuzer gaan bezig houden met de programmeren dan raad ik je aan om Atmel Studio te gaan gebruiken. Dit in combinatie met de datasheet van de atmega328p. Het is in het begin even een pil om doorheen te bijten, maar als je het eenmaal onder de knie hebt kun je je code precies maken zoals jij dat wil en echt alle preformance gebruiken die zoon chippie te bieden heeft.

en ik heb al code geschreven waar ik een float definieer als

float spanningdeler = 15

en bij een deling was alles in ints gecast en was de berekening fout

maak ik bovenaan
float spanningsdeler = 15.0;
dan was het juist.

de arduino compiler rekent met int's als die 2 ints gaat delen en rekent met floats als er minstens 1 float in zit.

straks op het werk post ik het stuk code, ik heb UREN gezocht waarom mijn berekening fout liep. het was een tijdsberekening die uiteidenlijk de snelheid als uitkomst gaf. en ik zat er een heel pak naast telkens (een groot deel van de tussenuitkomsten waren allemaal naar ints gegaan.

@ blackdog, die 0,0 van die float moet 0.0 zijn, maar je mag er evengoed 0 van maken, je steekt er toch een waarde in. ik heb die fout hier boven beschreven 1x gemaakt en sindsdien definieer ik floats ALTIJD met een getal, een puntje en nog een getal.

voor een variabele globaal te maken, definieer je ze bovenaan, in GEENENKELE functie.
vlak onder uw includes definieer je nu al je scherm en die bmp. die zijn globaal.
binnenkort speel je daar mee.

best eens een boek lezen over arduino en C code,

ik heb deze 2 boeken afgedrukt (kan je gratis digitaal afhalen)

en

[Bericht gewijzigd door fcapri op dinsdag 5 juli 2016 06:22:09 (14%)]

Op 4 juli 2016 23:41:36 schreef blackdog:
Net werkend gekregen!
Nog een stukje code ergens anders vandaan gevist en daar in gekeken hoe de data uit de BMP180 wordt gehaald.
In deze code stond nog een extra commando, en deze het ik toegevoegd en het werkt nu.
Zie plaatje hieronder, de extra code is: bmp.getEvent(&event);

Sorry Bram, maar ik neem eerst de moeite om te gaan foutzoeken in je stuk code, vervolgens lijk je daar niks mee te doen, daarna zeg ik in een vervolgpost nogmaals tegen je dat je mijn code eens letterlijk moet copy-pasten, en dan uiteindelijk heb je de fout nu "zelf gevonden" door op internet te kijken??

Dit staat in de code die ik je gaf:

    sensors_event_t event;
    bmp.getEvent(&event);
    druk = event.pressure; 

Blader maar eens naar boven naar mijn eerste antwoord, staat LETTERLIJK in die lap code.

Dat is toch precies hoe jij het nu "werkend hebt gekregen"?

Jij kunt zelf nogal gepikeerd zijn als je iets duidelijk uitlegt en mensen dan toch niet luisteren....

Hi Jochem,

Waarom denk je dat ik je input niet waardeer?

Ik heb gisteren avond zeer veel getest, gespeeld met variabelen op de plek waar de druk moet komen.
Dit zowel met: u8g.print(druk); en u8g.drawStr(43, 47, "P1023,23");
En dan tekst getallen 12345 en 4,235 om te zien wat mogelijk was.

Verder heb ik veel opmerkingen van jullie getest, ook het kaal getrokken stukje code dat output geeft naar de terminal.
Het stukje waar jij aan refereerd, heb ik na goed kijken pas gezien/opgevallen, en zag toen pas wat je bedoelde...
En ja je hebt gelijk

Jij omschrijft het zo in een post het zo: nu moet ik me op droge code een ongeluk staren
Dit geld voor mij nog meer, door de dislexie en de matige kennis van deze materie.
Wat denk je, zou het voor mij ook niet beter zijn geweest als ik jouw opmerking eerder goed had kunnen toepassen?
Dit is mijn abberatie en ik leef er aal een tijdje mee

Mijn manier van leren is een soort meanderen in de kennis die voor handen is (Google, Internet)
en het gene waar jullie CO érs mij mee helpen.

Dank voor je hulp en gegroet,
Bram

Allereerst sorry voor de toon van mijn post, ik zat vanochtend slecht in m'n vel geloof ik.

Feit blijft dat ik denk (kon het niet testen) dat die lap code die ik je gaf gelijk had gewerkt. Om dat te testen had je het in z'n geheel letterlijk kunnen copy-pasten.

Ik begrijp dat je dyslexie en matige kennis je in de weg zitten, en daarom zei ik in die eerdere post ook "ik vind het wel knap dat je het zo snel oppikt".
Maar iets letterlijk hier uit het code-venster selecteren en in je Arduino IDE-plakken daar zit geen dyslexie of gebrek aan begrip bij in de weg lijkt me, vandaar dat ik wat knorrig reageerde en de indruk kreeg dat je m'n post niet eens gelezen had.

Maar inderdaad, dat zul je niet met opzet gedaan hebben, want het zou jou ook geholpen hebben als je dat meteen overgenomen had.

Het ding met programmeren is dat je een bepaalde manier van denken moet ontwikkelen, en dat kost tijd. De enige manier om dat te leren is om het vaak te doen. Ik merk vaker op dit forum dat leden er "bang" voor zijn om er mee te beginnen. Zelf denk ik dat dit onterecht is. Er zijn in de laatste jaren veel mogelijkheden bij gekomen om de stap kleiner te maken. Voorbeelden hiervan zijn de raspberry pi en de arduino. De bedrijven hierachter hebben deze dingen gemaakt om de stap naar het programmeren kleiner te maken.

Hoe dan ook,
Wil je leren programmeren dan moet je het veel doen. Op dat gebied is het net wiskunde.
Maak eens wat simpele programma's. Begin met een knipper led en daarna het multiplexen van een paar 7 segment display's. Probeer de timers van de chips te gebruiken en misschien de ADC, en leer met interrupts werken. Gebruik dan ook meteen Atmel studio, en niet die gare java sketch van arduino. Leer hoe je de hardware moet aansturen aan de hand van de datasheets. Oke, het is misschien niet de snelste weg naar de oplossing op dit moment, maar als je het eenmaal kunt gaat er een wereld voor je open.

Ik heb zelf ook dyslexie, maar tijdens het programmeren zit het me niet in de weg. Maar dat kan per persoon verschillen natuurlijk.

Groeten,
Bas

Hi,

Mijn eisen wat betreft de toepassingen van zeg een Arduino zijn niet echt hoog.
Wat ik wel prettig zou vinden is dat de documentatie van library's veel meer aandacht zou krijgen.

Ik heb hier wat documenten/boeken als pdf over "c" maar ik kan jullie vertellen dat ik daar geen studie van ga maken.
Ik ga ook niet in echt "c" programmeren, er is gewoon de tijd niet voor om dit te leren...
Ik ben mij ten zeerste bewust, dat als ik simpele schakelingen met de Aurduino ga maken, ik toch vrij veel zal moeten leren.
Ook zal ik regelmatig toch tegen echte "c" code aan gaan lopen, maar dat is niet erg.

Ik ben aan het leren hoe de opbouw van de sketch moet worden gedaan, en weet nu grotendeels het verschil tussen int, long, float byte enz.
Ik zie echt regelmatig niet waar het begin { en de eind } staat, het zij zo

Tot nog toe ben ik tevreden met wat ik bereikt heb, ook met julie hulp.
Ik heb de code nog wat aangepast en ben bezig er zinnig commentaar bij te zetten, zouden jullie eens naar dit commentaar kunnen kijken en je mening geven?
Het is nog niet compleet en met de code wil ik ook nog wat stoeien, maar het geheel staat als dagen goed te draaien hier op de bank en denk ook dat het wel stabiel is.
Het past makkelijk in de Arduino Nano en er zijn nu geen extra functies meer nodig,
dus ik vraag mij af of het zinning is voor dit projectje, om er nog veel tijd aan te besteden...

Ik heb de variabelen een zinnige naam gegeven en pas bij het wegschrijven van de tekst naar het display krijgt deze tekst
de naam die ik op het display wil zien.

De laatste versie met de eerste versie van het commentaar bij de code.

// NoiseAmp Nokia 5110 mini weather station

/*-----( Library's )-----*/
#include "U8glib.h"
#include <OneWire.h>
#include <Wire.h>
#include <DallasTemperature.h>
#include "DHT.h"
#include <Adafruit_Sensor.h>
#include <Adafruit_BMP085_U.h>
/*-----( Library's )-----*/

U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8);	// Connection SPI Nokia 5110 Display: CLK = 13, DIN = 11, CE = 10, DC = 9, RST = 8

Adafruit_BMP085_Unified bmp = Adafruit_BMP085_Unified(10085); // Give the sensor a unique ID, here 10085

#define ONE_WIRE_BUS 2    // Data wire is plugged into pin 2 on the Arduino
#define T_PRECISION 12    // Set variable T_PRECISION to 12 (12 bit resolution on the 18D20)
#define DHTPIN 3          // Set pin DHT sensor to 3 on the Arduino
#define DHTTYPE DHT22     // Set Humidity sensor type to DHT22

DHT dht(DHTPIN, DHTTYPE, 6);

OneWire oneWire(ONE_WIRE_BUS);

DallasTemperature sensors(&oneWire);

DeviceAddress SenseAdrA = { 0x10, 0x99, 0x3E, 0xB5, 0x02, 0x08, 0x00, 0xD3 }; //Adres van de eerste 18D20 sensor
DeviceAddress SenseAdrB = { 0x28, 0x75, 0x2A, 0x3B, 0x06, 0x00, 0x00, 0x25 }; //Adres van de tweede 18D20 sensor
DeviceAddress SenseAdrC = { 0x28, 0x95, 0x52, 0x3B, 0x06, 0x00, 0x00, 0x5F }; //Adres van de derde 18D20 sensor
DeviceAddress SenseAdrD = { 0x28, 0x9A, 0x92, 0x3B, 0x06, 0x00, 0x00, 0x59 }; //Adres van de vierde 18D20 sensor


float SENSa; //hier wordt bepaald dat de variabele "SENSa" een float is.
float SENSb; //hier wordt bepaald dat de variabele "SENSb" een float is.
float SENSc; //hier wordt bepaald dat de variabele "SENSc" een float is.
float SENSd; //hier wordt bepaald dat de variabele "SENSd" een float is.
float druk = 0.0; //hier wordt bepaald dat de variabele "druk" een float is en deze wordt gevult met 0.0.



int value = 0;        //hier wordt bepaald dat de variabele "value" een int is en deze wordt gevult met 0.
int analogInput = 0;  //hier wordt bepaald dat de variabele "analogInput" een int is en deze wordt gevult met 0.
float vout = 0.0;     //hier wordt bepaald dat de variabele "vout" een float is en deze wordt gevult met 0.0
float vin = 0.0;      //hier wordt bepaald dat de variabele "vin" een float is en deze wordt gevult met 0.0
const float deler = (10000.0/(9300.0+10000.0)); //hier wordt de calibratie bepaald van de analoge ingang er wordt uitgegaan van een 10K en een 9,3K weerstand


void draw(void)
{
  u8g.setContrast(128); // Steld het xontrast invan het gebruikte Nokia 5110 Display
}

void setup()
{
  !bmp.begin();
  sensors.begin();

  pinMode(analogInput, INPUT);
  
  sensors.setResolution(SenseAdrA, T_PRECISION); // laat de waarde van de gewensde 18D20 resolutie (12bit) in de "SenseAdrA"
  sensors.setResolution(SenseAdrB, T_PRECISION); // laat de waarde van de gewensde 18D20 resolutie (12bit) in de "SenseAdrB"
  sensors.setResolution(SenseAdrC, T_PRECISION); // laat de waarde van de gewensde 18D20 resolutie (12bit) in de "SenseAdrC"
  sensors.setResolution(SenseAdrD, T_PRECISION); // laat de waarde van de gewensde 18D20 resolutie (12bit) in de "SenseAdrD"
}

void loop()
{
  sensors_event_t event;
  bmp.getEvent(&event);
  druk = event.pressure; //plaatst de inhoud van event.pressure in de variabel "druk" die gebruikt wordt voor het weergeven op het display

  float hum = dht.readHumidity(); //plaatst de inhoud van dht.readHumidity in de float variabel "hum" die gebruikt wordt voor het weergeven op het display
  
  sensors.requestTemperaturesByAddress(SenseAdrA);  // vraagt de temperatuur op van "SenseAdrA"
  sensors.requestTemperaturesByAddress(SenseAdrB);  // vraagt de temperatuur op van "SenseAdrB"
  sensors.requestTemperaturesByAddress(SenseAdrC);  // vraagt de temperatuur op van "SenseAdrC"
  sensors.requestTemperaturesByAddress(SenseAdrD);  // vraagt de temperatuur op van "SenseAdrD"
  
  SENSa = sensors.getTempC(SenseAdrA);  //plaatst de opgehaalde temperatuur van sensor A in de variabel "SENSa" die gebruikt wordt voor het weergeven op het display
  SENSb = sensors.getTempC(SenseAdrB);  //plaatst de opgehaalde temperatuur van sensor B in de variabel "SENSb" die gebruikt wordt voor het weergeven op het display
  SENSc = sensors.getTempC(SenseAdrC);  //plaatst de opgehaalde temperatuur van sensor C in de variabel "SENSc" die gebruikt wordt voor het weergeven op het display
  SENSd = sensors.getTempC(SenseAdrD);  //plaatst de opgehaalde temperatuur van sensor D in de variabel "SENSd" die gebruikt wordt voor het weergeven op het display
   
  value = analogRead(analogInput);  // Leest de waarde van de analoge ingang en plaatst deze in de variabele "value"
  vout = (value * 5.0) / 1024.0;    // Hier wordt de variabel "vout" berekend aan de hand van de referentie spanning van 5V en de 10 bits resolutie van de AD converter
  vin = vout / deler;               // Berekend de "vin" variabel aan de hand van de uitkomst van de variabele "deler"
  if (vin<0.09) {
  vin=0.0; //statement to quash undesired reading !
}

 //  picture loop
    u8g.firstPage();  
    do {
    u8g.setContrast(128);           // Steld het contrast in van het gebruikte Nokia 5110 display
     
    u8g.setFont(u8g_font_5x7);                  // Bpaald het font type dat van de tekst op het display gebruikt gaat worden
    u8g.drawStr(4, 7, "TEK-1 =      \260C");    // Plaatst tekst op het Display 4 pixels vanaf de rechter zijde en onderzijde font 7 pixels vanaf de boven zijde, de tekst moet tussne haakjes staan
    u8g.setPrintPos(41, 7);                     // Set de coordinaten (41, 7) voor het plaatsen van de waarde van de "SENSaA"
    u8g.print(SENSa);                           // Plaast de inhoud van de variabel "SENSa" op de hierboven genoemde coordinaten
   
    u8g.setFont(u8g_font_5x7);
    u8g.drawStr(4, 15, "TEK-2 =      \260C");
    u8g.setPrintPos(41, 15); 
    u8g.print(SENSb);
  
    u8g.setFont(u8g_font_5x7);
    u8g.drawStr(4, 23, "KES-1 =      \260C");
    u8g.setPrintPos(41, 23); 
    u8g.print(SENSc);
   
    u8g.setFont(u8g_font_5x7);
    u8g.drawStr(4, 31, "KES-2 =      \260C");
    u8g.setPrintPos(41, 31); 
    u8g.print(SENSd);
  
    u8g.setFont(u8g_font_5x7);
    u8g.drawStr(4, 39, "Accu  =      V");
    u8g.setPrintPos(46, 39); 
    u8g.print(vin);
  
    u8g.setFont(u8g_font_5x7);
    u8g.drawStr(0, 47, "H      %");
    u8g.setPrintPos(7, 47); 
    u8g.print(hum);

    u8g.setFont(u8g_font_5x7);
    u8g.drawStr(43, 47, "P");
    u8g.setPrintPos(50, 47); 
    u8g.print(druk); 
    
 } while( u8g.nextPage() );


  delay(1000);
}

Dan nog dit, ik wil graag een zuinig display hebben met wat meer ruimte en bij mijn zoektocht kwam ik de typen tegen van het Duitse "DOG"
Hebben jullie hier wel eens mee gewerkt, kunnen jullie er mij iets over vertellen?
Ze zijn ondermeer te koop bij Reicheld.
https://www.reichelt.com/DOG-LCD-Modules/2/index.html?&ACTION=2&LA=2&G…

Bedankt vast en gegroet.
Bram

Hi,

Ik loop weer vast met iets, en nu gaat het om de tijd netjes in beeld te brengen ook al zijn er "0" karakters in de waarden of als deze missen.

Dit wil ik met een if / els doen, maar krijg dit niet werkend...

Dit is de code, alle zaken die nu niet nodig zijn heb ik uit deze code gesloopt.
Ik wil alleen testen de tijd goed in beeld te brengen.

#include <U8glib.h>
#include <TimeLib.h>
#include <DS1307RTC.h>
#include <Wire.h>
#include <OneWire.h>

U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8);  // Connection SPI Nokia 5110 Display: CLK = 13, DIN = 11, CE = 10, DC = 9, RST = 8

#define ONE_WIRE_BUS 2                 // Data wire is plugged into pin 2 on the Arduino

OneWire oneWire(ONE_WIRE_BUS);         // Setup een oneWire voorbeeld om te communiceren met OneWire sensoren

byte uur = 0;                       // maakt de variabel "uur" aan en maakt deze "0"
byte minuut = 0;                    // maakt de variabel "minuut" aan en maakt deze "0"
byte seconde = 0;                   // maakt de variabel "seconde" aan en maakt deze "0"

void setup()
{
  Wire.begin();                         // maakt de I2C bus wakker
}


void loop()
{  
  u8g.setContrast(130);                 // Steld het contrast in van het gebruikte Nokia 5110 display

  tmElements_t tm;                      // Hallo klok, wordt wakker :-)
  RTC.read(tm);                         // Haald de gegevens uit de klok op en plaatst deze in "tm"
  
  uur = tm.Hour;                        // Haald de uur waarde uit tm en plaatst deze in de variabele "uur"
  minuut = tm.Minute;                   // Haald de minuut waarde uit tm en plaatst deze in de variabele "minuut"
  seconde = tm.Second;                  // Haald de seconde waarde uit tm en plaatst deze in de variabele "seconde"


 //  picture loop
    u8g.firstPage();  
   
    
    
    do {

    u8g.setFont(u8g_font_5x7);           // Bepaald het font type dat van de tekst op het display gebruikt gaat worden
   
    u8g.setPrintPos(10, 40); 

    if (uur>22)
    {
      uur = "0"+uur;
    }else{
      u8g.print(uur);
    }
   
  }  while( u8g.nextPage() );

    delay(1000);
}
}

Ik krijg de volgende foutmelding:

Klok-Formattering-01:48: error: invalid operands of types 'const char [2]' and 'float' to binary 'operator+'

uur = "0"+uur;

^

exit status 1
invalid operands of types 'const char [2]' and 'float' to binary 'operator+'

Het lijkt er op dat hij het cijfer "0" niet als tekst voor de variabele "uur" kan plaatsen.
Weet iemand wat ik hier fout doe?

Gegroet en bedankt,
Bram

Begin met dat ik het vreemd vind dat uur, minuut en seconde als float zijn gedeclareerd. Ik denk dat dit gewoon integers zijn.
Als ik de tijd zou moeten weergeven zou ik de sprintf functie gebruiken. Heeft wat meer code overhead maar denk niet dat het een probleem is.
Je zou dan de tijd kunnen weergeven door

  char buffer[30];                         // tijdelijke ruimte om string op te bouwen
  sprintf(buffer,"%02d:%02d",uur,minuut);  // geeft output 23:39 0f 09:03
  u8g.drawStr(10, 40, buffer);             // positie zelf bepalen 

met %02d geef je aan dat je een integer wilt weergeven in 2 velden(karakters) en wordt bepaald door de 2 en door er een 0 voor te zetten geef je aan dat als het getal korter is dan het aantal plaatsen dat je hiervoor gereserveerd hebt dit voorafgegaan moet worden door 1 of meerdere 0 -en.

Waarschijnlijk wordt dit nog ergens duidelijker omschreven als eens zoekt op "string formatting in C "

Hi driessens_nl,

Wat betreft de variabel die als float staan, dat klopt, dit is vreemd
Vlak voor ik gisterenavond het stukje typte heb ik nog geexperimenteerd met verschillende variabelen.
Ik was vergeten dit terug te zetten naar "byte" toen ik de code copieerde, vandaar, ik heb de code aangepast hierboven.
Er ligt al een paar dagen een afdruk onder mijn toetsenbord met daarop de eigenschappen van de verschillende variabelen.
Zoals dus de maximale getal grote, wel of niet een negatieve waarde mogelijk, ruimte in het RAM geheugen enz.
Dat leert goed bij mij.

Maar goed, jouw oplossing is een stuk inteligenter dan mijn geprobeerde oplossing
Ik ken de sprintf opdracht helemaal niet, wat niet vreemd is, ben net drie weken echt bezich met de Arduino.
De boeken van C en Aurduino die fcapri voorstelde zijn binnen en lees er regelmatig in.

Maar goed genoeg geneuzel, even laten zien dat je hulp niet voor niets is geweest Marco...

Bedankt en gegroet,
Bram

met deze code

 uur = "0"+uur;

zegt je dat je een string ("0") koppeld aan een byte van uur.

een byte kan geen string en andere bytes bevatten, daar zit de fout.
staat ook zo in de foutmelding dat je geen string, hier dus een char en een float binair kunt optellen('const char [2]' and 'float' to binary 'operator+').

het zou volgens mij wel werken zou je iets maken als

if uur < 10 {
char[2] uurStr = "0" (string)uur;
}
... zelfde voor minuut en seconden...
en als laatste
char[8] tijd = "uurStr" ":" "minuteStr" ":" "secondeStr";

wat ik meestal maak, is een kleine procedure waar ik een getal ingooi, en die me een 2delig getal als string terug geeft.
dan roep ik die op als
String tijd = zetOm(uur) + ":" + zetOm(minute) + ":" zetOm(seconde)

waarbij die zetOm dan een integer aanvaard en een string van 2 karakters teruggeeft.
je kijkt dan simpel hoelang (hoeveel getallen) die integer heeft (0-9 is 1cijfer, 10-99 is 2 cijfers,...) en voegt een 0 toe als die maar 1 cijfer bevat.

de oplossing in C is wel eenvoudiger zoals driessens weergeeft, maar niet alle code ondersteund zoiets (perl heeft dat niet)

Hi fcapri,

Je begrijpt naturlijk wel dat ik je niet begrijp *grin*

Mijn aannamen...
De "0" omdat deze tussen haakjes staat is volgens mij een een stukje tekst, en geen waarde/cijfer "0" klopt dit?
Is dit wat jij bedoeld met "string"
Ik dacht dat het stukje waar het mis gaat een "string" voort de waarde van de inhoud van de byte "uur" plaatst.
Dat werkt dus niet, dat is duidelijk.
Ik heb gisterenavond ook nog gestest met "gewone" cijfers, en dit werkte.
Ik kon een getalwaarde optellen of aftreken van de "uur" waarde.

Maar is er een mogelijkheid om het te doen, zoals ik probeerde?
Ik heb het nu mooi werkend met het sukje code van driessens_nl, maar ik wil goed begrijpen waarom het mis ging.

Gegroet,
Blackdog

je kan idd uur = uur + 1 doen.
maar uur = "0" + uur kan niet
ik zou evengoed aan u kunnen vragen:
hoeveel is 1 + 2 ?
en daarna
hoeveel is 5 + e ?

voor de computer is het nog erger.
1 + 2 kan die wel uitrekenen en zal die 3 geven
"1" + "2" zijn voor hem karakters en zal die "12" geven (12 als tekst en niet als getal).

je kan dan wel casten (=omzetten).
(String)2;
zal voor de computer dan tekst "2" worden en daar kan je dan wel een "0" voor zetten als tekst.
dat casten is bv handig.
stel je hebt een float getal=25,12 en je wil dit weergeven op het scherm als integer
(int)getal zal de pc dan 25 geven (die ,12 is weg)

nog een leuke

float getal =25,13;
int cijfer;
int komma;
cijfer = getal / 1; 
komma = (getal % 1)*100;

bij het eerste deel je door 1, de uitkomst is 25
bij het 2de vraag je de rest na deling door 1 of die geeft 0,13. dat x100 geeft integer 13.

dat gebruik ik vaak wel eens om te 'foefelen' met getallen.
stel dat ik 25,13 op het scherm wil, maar die ondersteund geen floats. enkel integers en tekst.

print(cijfer)
print(",")
print(komma)
[/code]

Hi fcapri,

Dank voor je uitgebreide uitleg!
Langzaam daald het hier in...

Ik begin nu ook te begrijpen waarom ik bepaalde waarden niet op het beeld kreeg, als ik de volgende u8glib opdrachten gebruikte zoals: u8g.print(uur); en u8g.drawStr(5, 31, "Blah die Blah");

Verder zal ik later vandaag eens spelen met jouw voorbeeld code en laten weten of ik het nu goed begrijp.

Bedankt en gegroet,
Bram

yep, het hangt er vanaf hoe ze de code hebben geschreven van die u8g.print functie.
als die gebouwd is om ENKEL getallen te aanvaarden, dan lukt een
u8g.print("hallo");
gewoon niet.

als ze slim zijn, dan maken ze die functie uitgebreid naar alle mogelijke dataformen.
dus een
-void print(int getal)
-void print(float getal)
-void print(String tekst)
-void print(Byte iets)
-void print(long getal)
...

het probleem met vele van die libraries die je online vind, is dat ze enkel geschreven hebben wat ze nodig hebben.
1 functie print die integers kan afprinten
en 1 functie printString die tekst kan printen.

wil je daarmee een float afprinten, moet je zelf code schrijven, of neem je een omweg door je float op te splitsen in 2 integers (deel voor de komma en deel na de komma) en dan print je de eerste integer, daarna print je een komma met tekst, en daarna de laatste integer.
of je gaat de library uitbreiden.

daarom ben ik nog al snel kritisch met bepaalde libraries.
doet die u8g code niet wat ik allemaal wil, vlieft die er zonder poespas uit. ik wil op zen minst tekst, getallen en floats kunnen printen.
sommige libraries willen zelf geen °C icoon afprinten en dan krijg je een vierkantje ofzo.

de libraries die je bij adafruit vind zijn meestal wel goed, alleen nemen ze vaak enorm veel geheugen in beslag

[Bericht gewijzigd door fcapri op donderdag 14 juli 2016 14:19:30 (18%)]

Het is alles bij elkaar nog niet zo eenvoudig.

De ARDUINO werkt met C++, aangevuld met een preprocessor die dingen mogelijk maakt die normaal in C en C++ niet kunnen.
Bijvoorbeeld een funktie aanroepen die pas later gedefinieerd is. Kan niet in C of C++, kan wel in Arduino.

Enkele aanhalingstekens worden gebruikt voor een enkele letter.
Dus '0' is de ASCII code voor het cijfer 0. (Decimale waarde 48, hex 0x30).

Een char is een 8-bit getal.
Dus je kunt bijvoorbeeld

char x = 48;    // x wordt nu 48
char y = 'A';   // y wordt nu 101 (Ascii code voor de letter A.)  

Een string is een reeks characters.

char Naam[10];  // Definieert een rij van 10 chars.

Naam[0] = 'A';  // Eerste char in de array wordt nu 'A'
Naam[1] = 48;   // Tweede char wordt nu '0' want 48 is ascii code voor '0';
Naam[2] = 0;    // Wordt vaak gebruikt om einde van de string te markeren.

floats (en doubles) zijn getallen met drijvende komma. Die hebben een precisie van ongeveer 10 cijfers (mantisse) en een bereik van 10 tot de macht +/- 38; Maar in de code moet je de 'komma' altijd als punt gebruiken.

float x = 12.7;   // Ok
float y = 15,8;   // Fout: 15,8 zijn 2 aparte getallen, kunnen niet in 1 variabele.

Tekst tussen dubbele aanhalingstekens is altijd een string.
"0" is dus een string van 2 characters, de eerste is de ascii code voor een null, gevolgd door een null terminator. Dus eerste byte = 48, tweede byte = 0.

Strings manipuleren kan alleen door funkties te gebruiken.
Bijvoorbeeld:

char Naam[10];   // Ruimte voor 10 letters.

memcpy(Naam, "Pietje", 7); // Ja, 7 lang inclusief de onzichtbare terminator. 

strcpy(Naam, "Jantje");    // Deze funktie stopt bij de terminator. 

Naam = "Karel";   // Error. String assignments kunnen niet in C++

char Woonplaats[20] = "Amsterdam"; // Hier kan het wel, Bij de definitie van een nieuwe string kun je een waarde meegeven.   

String funkties zijn gevaarlijk. Je moet zelf opletten dat je genoeg ruimte reserveert.
Bijvoorbeeld:

char Achternaam[10]; // Reserveert 10 bytes
int x;
int y;
strcpy(Achternaam, "VanDerMolenTotDeBoerderij");

Wordt door de compiler gewoon geaccepteerd zonder foutmelding. Tijdens uitvoering van het programma worden alle 26 letters van de string gecopieerd. De eerste 10 passen nog in je string, maar de rest overschrijft de variabelen x en y en nog een stel andere.

Strings en getallen kun je normaal niet door elkaar gebruiken, behalve als je speciale funkties gebruikt. Zoals sprintf() bijvoorbeeld.

Integers en floats kun je wel mixen. De compiler gaat dan automatisch omrekenen.

Een display werkt vrijwel altijd met ascii codes. Dus als je getallen wilt tonen dan moeten die eerst omgerekend worden. Meestal levert de display library de benodigde conversie funkties. Maar bij u8glib kun je weinig sturen. Je kunt wel getallen printen maar dan kun je geen voorloopnullen kiezen. Dus dan moet je eerst je gatallen converteren naar een string en vervolgens die string naar het display schrijven.

Bijvoorbeeld:

int uren     = 12;
int minuten  = 30;
int seconden = 45;
char tijd[10];
sprintf(tijd, "%02d:%02d:%02d", uren, minuten, seconden);

- sprintf is de funktie die de conversie doet.
- tijd is de buffer waar het resultaat in wordt afgeleverd.
- "%02d:%02d:%02d" is een format string.
- %d staat voor een getal
- %2d staat ook voor en getal maar nu wordt minimaal 2 cijfers
- %02d Ook een getal met minimaal 2 cijfers, maar nu met voorloop nullen.
- de ':' zijn gewoon letters die letterlijk worden tussengevoegd.
- uren, minuten, seconden zijn de drie variabelen die hier worden geconverteerd.
- het resultaat is dan een string van 9 letters "12:30:45" en die string kun je naar het display sturen.

Ik ken de sprintf opdracht helemaal niet, wat niet vreemd is, ben net drie weken echt bezich met de Arduino.

sprintf is een hork van een ding. Er is (uiteraard) geen enkele controle op de lengte van je 'destination'. Als je er net niet lang genoeg over nagedacht hebt, schrijf je buiten je memory. Leuk, stuk stack plat schrijven. Het zal voor die Arduino wel loslopen, maar dat is dus wel de manier waarom bijvoorbeeld een virus in de PC aan de gang zou kunnen gaan. Ofwel: een van de meest klassieke blunders.

Dus om Bram meteen een beetje op te voeden in 'safe programming': als je met alle geweld sprintf wilt gebruiken, werk dan met snprintf (idem met strcpy etc.).

Verder moet je je realiseren dat sprintf een functie is met een heel breed gebruik. Dat betekent dus dat er veel 'runtime' opgelost moet worden, en dat is 'duur' in de zin van performance. Voor jouw meetopstelling zal het allemaal wel.

char y = 'A'; // y wordt nu 101 (Ascii code voor de letter A.)

In mijn ASCII tabel is A 65. Terwijl a 97 is (beiden decimaal).

Hi fcapri, deKees en EricP

Dank voor alle zinnige informatie!
Komende week heb ik weer wat meer tijd om me met jullie info bezig te gaan houden en er mee te experimenteren.

Uhm....
Dus om Bram meteen een beetje op te voeden in 'safe programming'
Opvoeden... daar is deze aap toch te oud voor *grin*
Blijf vooral doorgaan met deze info, tot nog toe leer im meer van jullie dan van wat ik met Google vind

off topic
Wat ik al zij, jammer genoeg weinig tijd gehad om met jullie info te spelen omdat ik veel tijd heb besteed bij een klant met onwillige Firewalls en rammelende modems Pffff, en nog niet helemaal opgelost.
Daarna mijn eigen Firewall gereset en opnieuw geprogrameerd en daar zit ook dikke bugs in!
Bij het kiezen van de dual WAN functie met alleen de tweede lijn als back-up als de hoofdverbinding uitvalt,
is er geen trafic mogelijk naar buiten toe, op een aangemaakte VLAN die er is voor als ik computers die besmet zijn
van Internet wil voorzien.
Trek ik nu de back-up lijn uit uit WAN2 poort, dan werk de VLAN wel!!!
Het overschakelen van de hoofdverbinding naar de back-up verbinding op het normale segment werkt goed.
Het geheel is ingesteld met de Wizzard van de Firewall en daar is zeer simpel mee om dit zo in te stellen zoals ik het wil.
Geen moeilijke dingen extra routes enz, enz, recht toe recht aan en zelfs dat is te moeilijk voor de prutsers die dit gecodeerd hebben.
Ik kan nog wel even door gaan over b.v. de Firewall van mijn klant (ander merk) waarbij ik vind dat het gedrag hiervan "mental" is.
Veel van de problemen die ik tegenkom in mij werk komt door halfbakken geschreven sofware waar EricP mij voor waarschuuwd,
om niet ook zo'n programmeur te worden!
On topic

Ik heb een aantal toepassingen in mijn hoofd waar ik de Arduino voor wil gebruiken.
Datalogging had ik al aangegeven voor een spannings referentie oven had ik al aangegeven.
Verder komen langzaam onderdelen binnen zoals AD en DA converters met een hogere resolutie dan die van de Arduino producten.
Dit samen met i2c isolatoren om b.v. en voeding digitaal bestuurbaar te maken op een goede manier en niet de gammele PWM manieren die als virus over het internet trekken.

Om nu die AD en DA aan te sturen wil ik een soort shuttle knop maken, eigenlijk wil ik het op twee manieren gaan doen.
1e
Een potmeter waarvan de loper aan een analoge ingang hangt en deze potmeter staat verder over deArduino voeding.
In de midden stand, staat dus ongeveer de halve voeding op de loper en de spanning bevind zicht dan in de "dead zone"
Er gebeurd niets met deze waarde, maar als je dan naar links links of naar rechts draaid, kom je in andere zone's terrecht (4 of 5 per kant)
En gaat de Arduino steeds sneller de waarde van de DA converter verhogen.
Op proffesionele Tape recorders van ondermeer studers kon je zo heel snel een bepaald punt op de band vinden.
Je kan je voeding zo ook langzaam of snel laten op of af lopen enz.
2e
Een andere manier is een variatie met een Joystick, maar daar moet ik nog over nadenken.
Het gaat er om een analoog gevoel te blijven houden bij het instellen.

Mijn Rigol DP832 heeft zowel de draaiknop als de nummerieke toetsen, maar ik vind die interface niet intuitief.
Ik blijf knoppen drukken tijdens het experimenteren...
Dus ik ga een poging doen een tussenweg te maken zodat ik een digitaal instelbare voeding heb met een analoog gevoel.

Hoever ik kom, tja... het moet in de overgebleven tijd en mijn meetversterker wil ik deze zomer ook af hebben.
Dus nogmaals alle hulp is welkom.

Gegroet,
Bram

Die eerste manier die je beschrijft is eigenlijk een soort regelaar, die waarschijnlijk nooit echt lekker gaat werken. (toepassing afhankelijk)

Welnu,
Als je met een arduino een proces wilt regelen zou ik je aanraden om je te gaan verdiepen in een zogenaamde takahashi regelaar. Hier is een link naar een website van een leraar van mij. Hij heeft zoon regelaartje gemaakt, en daar een mooie uitleg bij gegeven.
http://www.vandelogt.nl/uk_regelen_pid.php

Zelf vind ik dit ook zeer interessante techniek.

Hi Hardbass,

Ik begrijp je niet helemaal en jij misschien mij niet...

Maar de eerste optie voor de DA converter is om de uitgansspanning van de DA afhankelijk te laten zijn van de instelknop.
Je draaid naar rechts om de uitgansspanning te verhogen.
Je staat op zeg 12V en je wilt naar 23V, hoe meer je nu naar rechts draaid hoe sneller je naar 23V toe gaat.
Als je er bijna bent, dan draai je de knop weer richting middenstand.
Sta je in de middenstand dat is de uitgansspanning vast.

Ik heb zoiets al eens gemaakt met een potmeter en een spanningsgestuurde oscilator en een hand vol IC's om hiermee 14 en 16 bit DA aan te sturen, 30 jaar geleden of zoiets.
D.m.v. wat comperatoren werd de up/down richting ingesteld en het klokken van de counters ging dus met de spannings gestuurde oscilator.
Hiermee kon je dan vrijsnel door het hele 14 a 16 bit bereik van de Da converter gaan.
Als ik het goed heb ging de oscilator van "0" Hz tot een paar Khz in de maximale stand.

Misschien is het zelfs handiger het analoge deel te behouden en alleen de up/down en de frequentie naar een arduino te sturen.
Het is nog helemaal niet uit ontwikkeld in mijn hoofd en mis natuurlijk veel kennis over programmeren.

Dus, ik zie nog niet in hoe ik een P.I.D. of een Takahashi controler zou kunnen gebruiken als ik alleen een waarde naar een DA gestuurd wil hebben.
Er is geen loop aanwezig, uiteindelijk komt het er op neer, dat ik tegen de DA zeg: "ga op de aangeleverde waarde staan"
De spanningsmeter aan de uitgang gaat dan bevestigen dat ik het goed heb ingesteld op zeg 23.682V

Bedoel je iets anders, dan hoor ik het graag.

Gegroet,
Blackdog

Ik ben wel een fan van Blackdog, dus graag gedaan.

In mijn ASCII tabel is A 65.

Dan heb je een ascii tabel die hex getallen afdrukt alsof het decimale getallen zijn. 'A' is hex 0x65 of 101 decimaal.

[edit]
-- Oeps foutje, een keer teveel geconverteerd.
Ascii 'A' is natuurlijk 0x41, decimaal 65.
[/edit]

Inderdaad sprintf() is duur en gevaarlijk, en snprintf() is veiliger.
Ik heb nog even gezocht in de arduino references maar daar vind ik zo snel geen beter alternatief. Wel jammer eigenlijk. Formatteren van getallen is toch tamelijk belangrijk.

snprintf() is een standard library funktie die door een flink aantal C / C++ compilers wordt ondersteund. En ook door de AVR-GCC compiler die in de Arduion IDE is ingebouwd. Arduino probeert alles eenvoudig te houden en laat veel informatie weg. De compiler kan dus veel meer dan wat er in de arduino references staat. Zie http://www.nongnu.org/avr-libc/user-manual/modules.html voor meer info.

Ik vind het idee van de potmeter wel interessant. Zelf heb ik al geprobeerd met een rotary encoder, maar dan heb je al snel erg veel stapjes, of je hebt weinig resolutie. Dan kun je wel trucs inbouwen (cijfer voor cijfer instellen bijv) maar dat werkt ook niet echt lekker. Met zo een potmeter kun je zelf sturen hoe snel je door de range loopt.

Ik heb de co voeding nu ook met een arduino aangestuurd. Met een rotary encoder. Maar inderdaad ik moet wel erg veel draaien voor grotere stappen.
Dat idee van Blackdog , zie je ook wel bij autoradio's, lijkt me een gebruiksvriendelijkerder oplossing en zal ik met veel interesse volgen en ook eens induiken.

Hi heren, BenI2C, deKees,

Ik zou het leuk vinden om iets gezamelijk te doen als jullie dit ook intressant vinden?

Ik zal het schema binnenkort een opduiken en het hier laten zien hoe ik het gebruikte.

Nu weer verder facturen maken, je moet toch wat met je leven *grin*

Gegroet,
Bram