Jelszámláló

[Bagameri]

Szeretnék az alábbi számlálóból olyan számlálót ami nem a bekapcsolásokat számolja ,hanem egy jelet számoljon .
És még egy meddig számol mikor vált nullára , esetleg hogyan lehet nullázni.

Kód: Egész kijelölése

#include "LiquidCrystal.h"
#include "EEPROM.h"
LiquidCrystal lcd( 4, 5, 6, 7, 8 ,9); // RS, E, D4, D5, D6, D7

 unsigned long start_time;                        
int tmp;
int tmp2;
unsigned char ch; // ezt arduinoul byte-nak hivjak
unsigned char ch2;

#define EEPROM_START 500
#define BEKAPCSOLASSZAMLALO_L (EEPROM_START+1)
#define BEKAPCSOLASSZAMLALO_H (BEKAPCSOLASSZAMLALO_L +1)
 
void setup() {
       pinMode(13, OUTPUT);  digitalWrite(13, HIGH);  lcd.begin(16, 2);
 
  ch=EEPROM.read(BEKAPCSOLASSZAMLALO_L);
  ch2=EEPROM.read(BEKAPCSOLASSZAMLALO_H);
  // 8 bittel eltoljuk balra, azaz felso bajt lesz, es hozzatesszuk az alsot
  tmp = ch2<<8|ch;  // eddigi bekapcsolasok szama
  
  EEPROM.write(BEKAPCSOLASSZAMLALO_L, ++ch); // megnovelt erteket visszairjuk
  if(!ch) // ch == 0 csak programozoul irva :-)
  {        // akkor lesz tmp 0 ha a kisebbik helyiertek tulcsordul a szamlalo novelesekor
    EEPROM.write(BEKAPCSOLASSZAMLALO_H, ++ch2); // es ekkor kell a nagyobbik helyierteket novelni es visszairni
  }  
  tmp2 = ch2<<8 | ch;    
  lcd.setCursor(0,0); 
  lcd.print("Bekapcs.# ");
  lcd.print(tmp2);
  lcd.print(" "); // esetleg ott maradt kiiras letorlese
     }
void loop() {}
 void lcdprint2(char cc) // ket szamjeggyel irja ki a megadott szamot
 {return;
 }[code]

[csegebiga]

Szeretnék az alábbi számlálóból olyan számlálót ami nem a bekapcsolásokat számolja ,hanem egy jelet számoljon .
És még egy meddig számol mikor vált nullára , esetleg hogyan lehet nullázni.

jó, részemről ok, mi a gond, hol akadtál el?

Kód: Egész kijelölése

setup()
{csinálsz egy  bemenetet, }
loop()
{
    vársz addig, míg  aktív nem lesz a(prellmentesített!) bemenet
    {
       inkrementálod az eepromos számlálódat //ez már kész
       kiíratod a számláló értékét az lcdre  // ez is
            és vársz, amíg nem lesz inaktív a bemeneted {}
    } 
} //ennyi

a másik kérdésedre:

2 byte-on számolsz (ch, ch2), akkor ez
2^8 (1, byte)*2^8(2.byte) vagyis
256*256 =
2^16=65536 különböző érték tehát 0-65535ig számol
hexadecimálisan : FFFF Hex
ha ehhez hozzáadsz 1et, akkor 65536=01 00 00Hex lesz ami az (alsó) két byte-n 00 00, tehát átfordul 0ra
ha a 65535 kevés lenne,
+1 byte bővítéssel 256*65536= FF FFFF= 16777216(2^24)
+2 byte bővítéssel 65536*65536= FFFF FFFF= 4294967296 (2^32)
értékig tudsz elszámolni
ez utóbbi másodpercenkénti számlálásnál 49710 nap után fordulna át (136 év!)
de ez már bőven túl van az eeprom tervezett írási élettartamán

[cree]

sziasztok!

Szeretnék eepromba írni / kiolvasni letárolt byte adatokat. De van ebben a kóban egy rész, ami nem akar működni - vagyis a kiolvasás if függvény alatt!

Kód: Egész kijelölése

#include <EEPROM.h>

/*
Turns on and off and Dim a light emitting diode(LED) connected to digital
pin 9, when pressing a pushbutton attached to pin 2.

The circuit:
* LED attached from pin 13 to ground
* pushbutton attached to pin 2 from +5V
* 10K resistor attached to pin 2 from ground
*/


// set pin numbers:
const int buttonPin = 2; // the number of the pushbutton pin
const int ledPin = 9; // the number of the LED pin

// variables will change:
int buttonState = 0; // variable for reading the pushbutton status
boolean dir = 0; // The current dir state (UP/DOWN)
int value = 0; // The current value


void setup() {

pinMode(ledPin, OUTPUT); // initialize the LED pin as an output:
pinMode(buttonPin, INPUT); // initialize the pushbutton pin as an input:


}

void loop() {


// check if the pushbutton is pressed. if it is, the buttonState is HIGH:

if (digitalRead(buttonPin) == HIGH) { // read the state of the pushbutton value:
dir =! dir; // Invert direction

for (int i=0; i <= 300; i++){ // wait 300ms before count -> loop short press
delay(1);
if ((digitalRead(buttonPin) == LOW)& value !=0) {value = 0; dir = 0; break; }
if ((digitalRead(buttonPin) == LOW)& value ==0) {value = EEPROM.read(1); dir = 1; break;}
}
analogWrite(ledPin, value); // Write value to led

while (digitalRead(buttonPin) == HIGH){ // If the button is still High then count -> long press
if (dir == 1 & value <255){value++;} // count up until 255
if (dir == 0 & value >20) {value--;} // count down to min value (20)
analogWrite(ledPin, value); // Write value to led
delay(1);
EEPROM.write(1,value); // write last value in EEPROM
}

}
} 

A problémát ennél a sornál sejtem, mert nincs kiolvasás és összehasonlítás, mert 328 reset után feláll ledPin 20 visszaáll, holott eepromba pl. 200-as érték van!

Kód: Egész kijelölése

if ((digitalRead(buttonPin) == LOW)& value ==0) {value = EEPROM.read(1); dir = 1; break;}

[Robert]

Admin: A helyesírás-ellenőrzőt kérem használni! Firefox alatt beépítve működik.

[cree]

Admin: A helyesírás-ellenőrzőt kérem használni! Firefox alatt beépítve működik.

како сте пријатељи?

2 nyelvünk csak a magyar sajnos elég beszélnünk!
helyes irásolni?

[SzLacus]

Szia Bagameri.
Úgy gondolom, hogy feleslegesen küzdesz, az átcsordulást megoldja helyetted a környezet, ha használod a szolgáltatását. Hogy érthető legyen mire gondolok, elmondom, hogy én mit látok a programodban, és hogyan gondolom.
Definiálsz két egymást követő címet az eepromban, ahol majd L,H sorrendben tárolod a számolandó értéket. Ez 1-1 bájt.
Aztán létrehozol méret megnevezés nélkül egy változót (ch), amibe beolvasod az L majd egy másikat (ch2) amibe beolvasod a H címhez tartozó értéket. Rábíztad a fejlesztő környezetre, hogy mekkora legyen a változód mérete. Ez azt eredményezi, hogy az alapértelmezett változó típust (int) fogja használni a környezet, ami előjeles. Nem tudom, hogy ez szándékos vagy egyszerű figyelmetlenség.
Aztán lérehozol megint típus megnevezés nélkül egy harmadik (tmp) változót, amiben létrehozod a számlált értéket, immáron két bájton ábrázolva, de előjelesen értelmezve. Aztán jön a növelés, meg átvitel figyelése, mindez előjeles ábrázolású mennyiségekkel, ami gondot fog okozni amint eljut az ábrázolt mennyiség az előjel bitig. De nálad már akkor is gond lesz, amikor az alsó felet ábrázoló ch 255-ről 256-ra növekszik. Azért, mert az int-ben ez ábrázolható szám, te pedig azt nézed, hogy a növelés után nulla lett-e. Nem lesz nulla, így nem lesz átviteled.
Nem ragozom, hogy hogyan kéne ebben a környezetben csinálni, hogy működjön az átviteled, mert felesleges. Ahogy felesleges lenne bájtként definiálnod ch és ch2 változódat is az átfordulás megjelenéséhez.
Használj (erre szerintem előjel nélküli) 2 bájtos ábrázolást, ha abba belefér az ábrázolandó mennyiség, és amikor létrehozod a változót, akkor ezt közöld a környezettel.
Aztán olvasd bele a H címről az értéket, csúsztasd felülre, és add hozzá az L helyen tárolt értéket. Ezzel kész a számolt mennyiséged, növelheted, ahogy akarod, a környezet megoldja helyetted a bájt határon átcsordulás azért, mert a definiálásnál közölted vele, hogy ez az ő feladata.
Amikor az eepromba vissza írod akkor bájt méretre kell szorítanod, ellenkező esetben a felső bájtfél tartalma elveszik, mert az eeprom bájt méretet tárol. Tehát amikor először kiírod a két bájton ábrázolt értékedet az eepromba, akkor valójában csak az alsó felét írtad ki, (ezt az L helyre kell tenned) utána a felső felét le kell csúsztatnod alulra, és az így keletkezett értéket írni a H helyre. A memóriában a változók definiálásakor megadott hosszt kezeli helyettünk a fejlesztő környezet, ott nem kell nekünk foglalkozni a bájt határral.