Bedrijfs urenteller voor CNC machine

[Creator Profiel Privébericht]

Top,
De code werkt en ik denk dat ik het meeste er wel van begrijp, alleen de DEBUG regels zijn (nog) abacadabra voor mij. dus dat wordt weer de boeken in .
Alleen ondervind ik nog problemen op mijn breadboard met de schakelfunctie. Deze reageert vaker niet dan wel en ik heb de schakelaar zowel met een pull-up als pull-down weerstand geprobeerd (R=10k). Ligt dit voornamelijk aan losse verbindingen of aan mij?
ik zal de tekening bijsluiten.

[nicoverduin Profiel PrivéberichtWebsite]

Pak deze maar. De rest is nog een brug te ver.
Je moet de weerstand naar GND verbinden en schakelen naar de 5V

cpp code

// initialiseer bibliotheken
#include <Arduino.h>
#include <EEPROM.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

#define AAN HIGH			// de knop is "Aan"  als HIGH is. Maak hiervan LOW als het omgekeerd is

// setup variabelen:
const int buttonPin = 7;    //stop tellen en save laatste waarden op eeprom
//
// EEPROM adressen
//
const uint16_t EEPROM_UREN 		= 0;	// Uren op adres 0+1
const uint16_t EEPROM_MINUTEN 	= 2;	// Uren op adres 2
// setup tijd teller:
uint32_t timer;          	// 32 bits seconden timer
uint16_t hour 	= 0;    	// als test op 10 uur
uint8_t minute 	= 0;    	// als test op 59 minuten
uint8_t second 	= 0;   	// als test op 45 seconden

void setup() {

	pinMode(buttonPin, INPUT);  			// stop drukknop

	//
	// als je het eeprom wil wissen kun je de stop button gebruiken door deze 3 seconden
	// ingedrukt te houden gedurende 3 seconden bij het opstarten
	//
	timer = millis();						// we gebruiken gewoon ff de timer
	uint8_t wissen = false;
	while (digitalRead(buttonPin) == AAN) {
		delay(250);							// elke 250ms ff kijken
		if (millis() - timer > 3000) {
			wissen = true;					// we moeten dus wissen
			break;
		}
	}
	if (wissen == true) {
		//
		// we gaan het eeprom ff wissen
		//
		EEPROM.write(EEPROM_UREN	, 0xFF);	// high byte
		EEPROM.write(EEPROM_UREN+1	, 0xFF);	// low byte
		EEPROM.write(EEPROM_MINUTEN	, 0xFF);
		//
		// en ook nog eens wachten tot de knop is losgelaten
		//
		while (digitalRead(buttonPin) == AAN) {}
	}
	//
	// ophalen uren en minuten uit EEPROM
	//
	hour 	= (EEPROM.read(EEPROM_UREN) * 256) + EEPROM.read(EEPROM_UREN+1);
	minute 	= EEPROM.read(EEPROM_MINUTEN);
	//
	// als minuten en uren nog op 0xFF staan betekent dit dat het eeprom nog gewist is.
	// dus gaan we alsnog de teller op 0 zetten. Als minute op 255 (0xFF) staat weten we voldoende
	// daar deze beweegt tussen de 0 en 59.
	//
	if (minute == 0xFF) {
		//
		// eeprom was nog gewist
		//
		hour 	= 0;			// uren en minuten op 0 zetten
		minute 	= 0;
	}
	lcd.begin(16, 2);         	// the LCD has 16 columns and 2 rows
	timer = 1;         			// start de timer. Deze mag nooit 0 zijn omdat we die waarde voor iets anders gebruiken
}

void loop() {
	//
	// check de timer
	//
	if (timer != 0) {
		//
		// de timer loopt
		//
		if (millis() - timer > 1000) {
			timer = millis();       // start de timer alvast voor de volgende keer
			if (timer == 0) {
				timer = 1;			// theoretisch 1 x per 49 dagen voorkomen
			}
			second++;              	// seconde verlopen
			if (second == 60) {
				minute++;           // minuut verlopen?
				second = 0;
			}
			if (minute == 60) {
				hour++;             // uur verlopen?
				minute = 0;
			}
			// display resultaat
			char theTime[10];     	// formaat 000:00:00 = 9 bytes + '\0' op het einde
			sprintf(theTime, "%03d:%02d:%02d", hour, minute, second); // alternatief met sec. display
			//   sprintf(theTime, "%03d:%02d   ", hour, minute); // uiteindelijke versie
			lcd.clear();
			lcd.setCursor(0, 0);
			lcd.print("Counter H  M  S ");
			lcd.setCursor(7, 1);
			lcd.println(theTime);
		}
	}
	//
	// lees de drukknop pin uit. debounce is verder niet nodig omdat je als je eenmaal bent gestart dit niet meer
	// te stoppen is
	//
	if (digitalRead(buttonPin) == AAN){
		//
		// de knop is ingedrukt dus eerst de EEPROM waardes wegschrijven
		//
		EEPROM.write(EEPROM_UREN	, hour / 256);	// high byte
		EEPROM.write(EEPROM_UREN+1	, hour % 256);	// low byte
		EEPROM.write(EEPROM_MINUTEN	, minute);
		//
		// meer hoeven we niet te doen
		//
		while(1) {}
	}
}

[Creator Profiel Privébericht]

bedankt voor de code, deze begrijp ik
Alleen het wil maar niet met de druktoets, aangesloten op jouw manier en op de mijne bij beide reageert de teller niet.
Als ik tijdens het lopen van de tijd de knop +/- 6 sec ingedrukt hou stopt de tijd en is daarna het geheugen teruggezet op 0.
Soms, ik denk door storingsignaal stopt de timer en als die dan opnieuw onder stroom komt is de tijd wel weggeschreven dus dat klopt als een bus.
Het venijn zit h'm dus in de hardware, denk ik. suggesties?

[nicoverduin Profiel PrivéberichtWebsite]

Als je de spanning erop zet en je houd hem minimaal 3 seconden ingedrukt dan reset hij de timer.
Als je knop het gewoon niet doet dan moet je het zoeken in dat knopje van je. Bij mij merkt het als een tierelier.

[Creator Profiel Privébericht]

Nou ik heb het helle zooitje van het breadboard gehaald en er alles opnieuw opgezet en ik denk dat Murphy weer naar huis is want het werkt!!

Dit is nu de telling voor de ODO oftewel de totale bedrijfstijd in uren en minuten.
En als er een deel werkt wil je graag verder experimenteren.

Zou ik nu een deel van de code kunnen gebruiken om een projecttijd aan te geven? Deze hoeft niet bewaard te worden en kan bij iedere start op 0 beginnen, stopt gelijktijdig met de stopkop.

Beide tijden heb ik al op de LCD cf. voorbeeld:
Project 00:00 // display resultaat nu met char projectTime[10] en verder doorgevoerd.
Totaal 0000:00 (code sprinf(theTime, %04d: aangepast)

[nicoverduin Profiel PrivéberichtWebsite]

gewoon een 2e set tellers voor uren/minuten en seconden maken. Verhoog je de ene verhoog je ook de ander enz.

[Creator Profiel Privébericht]

Top,

ik heb het werkend
beide tijden project of sessie tijd begint op 0:00 en ODO tijd loopt door. Na stop wordt de ODO tijd opgeslagen en de project tijd na (re)start op 0 gezet.

nog twee uitdagingen te gaan.
1. kan ik er een alarm in programmeren welke instelbaar of vast is ingesteld op 10 uur (optellend of aflopend is om het even) en dat deze een LED laat branden en pas na een drukknop actie uit gaat. Hierna moet het alarm opnieuw geactiveerd worden. (dit is voor onderhoud aan de machine elke 10 draaiuren).

2. de laatste uitdaging die volgt is om dit alles los van de Arduino te laten werken zodat het als stand-alone ingebouwd kan worden.
nog suggestie wat voor IC daar voor te gebruiken?

[nicoverduin Profiel PrivéberichtWebsite]

Vwb. De chip heb je de volgende vragen te stellen:
a) hoeveel Flash gebruik ik
b) hoeveel RAM gebruik ik
c) kan de chip I2C aan met LCD (bij de tiny is dat ff lastiger)
d) Zijn de libraries die ik gebruik ook beschikbaar voor die chip.
e) En natuurlijk het aantal IO pinnen die je gebruikt.

Of je geeft 3-4 euro uit voor een Atmega328P chip die programmeer je op de arduino en prik je in je eigen pcb. En als je SMD beheerst kun je zelfs een SMD variant nemen van de Atmega328P. kristalletje, 2 x 20pf cappies, 10K + 100nF voor de RESET, ISP header, paar 100nF voor de Vcc en klaar. De rest zijn aansluit klemmen.

Voor het alarm, extra byte nemen die de uren telt (dus 3e setje uren/minuten/seconden). Die schrijf je in de volgende 3 bytes. Is er 10 uur verlopen dan alarm aan. Maak een knop die het alarm reset en je eeprom weer wist op die 3e set. Begint hij gewoon opnieuw.

[Creator Profiel Privébericht]

Als kijk naar wat ik nu aan geheugen gebruik;
- 121 bytes aan Flash;
- 1927 bytes aan SDRAM;
- en 6 bytes+ aan EEPROM geheugen.

Ik denk dus naar mijn bescheiden mening dat een ATmega328P een prima keus is en gemakkelijk te clonen via de Uno, zijn meteen de libraries bruikbaar.
SMD techniek beheers ik niet en lijkt me ook redelijk kostbaar, maar daar weet ik te weinig van. Ik hou het bij de oude vertrouwde printplaat welke door de CNC portaalfrees wordt bewerkt tot de bekende kopersporen en na omkeren ook nog van een silk laag kan worden voorzien.

Ik denk dat ik zonder I2C bus kan werken omdat ik de PCB toch zelf ontwerp, desnoods in 2 lagen.
Voeding via adapter 12V en dmv LM7805 naar 5V voor IC

Ik denk dat deze code werkt al zal het misschien dubbelingen hebben die echte programmeur niet zou maken.

cpp code

// initialiseer bibliotheken
#include <Arduino.h>
#include <EEPROM.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

#define AAN HIGH            // de knop is "Aan"  als deze HIGH is. Maak hiervan LOW als het omgekeerd is

// setup variabelen:
const int buttonPin = 7;    //stop tellen en save laatste waarden op eeprom
const int buttonAPin = 6;   //stop alarm en reset de waarden op eeprom naar 0
int ledPin = 13;            //Alarm led aan bij verstrijken 10 uur

// EEPROM adressen
const uint16_t EEPROM_UREN            = 0;    // Uren timer op adres 0+1
const uint16_t EEPROM_MINUTEN         = 2;    // Minuten timer op adres 2
const uint16_t EEPROM_ALARM_UREN      = 4;    // Uren alarm op adres 4+5
const uint16_t EEPROM_ALARM_MINUTEN   = 6;    // Minuten alarm op adres 6

// setup tijd teller:
uint32_t timer;             // 32 bits seconden timer
uint16_t hour   = 0;        // wordt gereset door 3 sec stoptoets ingedrukt te houden, anders uitlezen.
uint8_t minute  = 0;
uint8_t second  = 0;

uint16_t hours   = 0;       // wordt gereset door stoptoets.
uint8_t minutes  = 0;       // tijdcode voor projecttijd gedeelte
uint8_t seconds  = 0;

uint16_t houra   = 0;       // wordt gereset door resettoets alarm, anders doortellen tot 10.
uint8_t minutea  = 0;       // tijdcode voor het alarm gedeelte
uint8_t seconda  = 0;

void setup()
{
  pinMode(ledPin, OUTPUT);        //Waarschuwings LED voor onderhoud.
  pinMode(buttonAPin, INPUT);     // reset alarm drukknop
  pinMode(buttonPin, INPUT);      // stop drukknop

  // als je het eeprom wil wissen kun je de stop button gebruiken door deze 3 seconden
  // ingedrukt te houden gedurende 3 seconden bij het opstarten

  timer = millis();                       // we gebruiken gewoon ff de timer
  uint8_t wissen = false;
  while (digitalRead(buttonPin) == AAN)
  {
    delay(250);                         // elke 250ms ff kijken
    if (millis() - timer > 3000)
    {
      wissen = true;                  // we moeten dus wissen
      break;
    }
  }
  if (wissen == true)

  {
    // we gaan het eeprom ff wissen

    EEPROM.write(EEPROM_UREN    , 0xFF);    // high byte
    EEPROM.write(EEPROM_UREN + 1  , 0xFF);  // low byte
    EEPROM.write(EEPROM_MINUTEN , 0xFF);

    // en ook nog eens wachten tot de knop is losgelaten
    while (digitalRead(buttonPin) == AAN) {}
  }

  // ophalen uren en minuten uit EEPROM
  hour    = (EEPROM.read(EEPROM_UREN) * 256) + EEPROM.read(EEPROM_UREN + 1);
  minute  = EEPROM.read(EEPROM_MINUTEN);
  houra    = (EEPROM.read(EEPROM_UREN) * 256) + EEPROM.read(EEPROM_UREN + 1);
  minutea  = EEPROM.read(EEPROM_MINUTEN);

  // als minuten en uren nog op 0xFF staan betekent dit dat het eeprom nog gewist is.
  // dus gaan we alsnog de teller op 0 zetten. Als minute op 255 (0xFF) staat weten we voldoende
  // daar deze beweegt tussen de 0 en 59.
  if (minute == 0xFF)
  {
   // eeprom was nog gewist
    hour    = 0;            // uren en minuten op 0 zetten
    minute  = 0;
  }
  lcd.begin(16, 2);           // the LCD has 16 columns and 2 rows
  timer = 1;                  // start de timer. Deze mag nooit 0 zijn omdat we die waarde voor iets anders gebruiken
}

void loop()
{
  // check de timer
  if (timer != 0)
  {
    // de timer loopt
    if (millis() - timer > 1000)
    {
      timer = millis();       // start de timer alvast voor de volgende keer
      if (timer == 0)
      {
        timer = 1;          // theoretisch 1 x per 49 dagen voorkomen
      }
      second++;               // seconde verlopen
      if (second == 60)
      {
        minute++;           // minuut verlopen?
        second = 0;
      }
      if (minute == 60)
      {
        hour++;             // uur verlopen?
        minute = 0;
      }

      // display resultaat totale tijd
      char theTime[10];       // formaat 000:00:00 = 9 bytes + '\0' op het einde
      //sprintf(theTime, "%03d:%02d:%02d", hour, minute, second); // alternatief met sec. display
      sprintf(theTime, "%04d:%02d   ", hour, minute); // uiteindelijke versie
      lcd.setCursor(0, 1);
      lcd.print("ODO tijd");
      lcd.setCursor(9, 1);
      lcd.println(theTime);

      // tweede timer deel voor projecttijd
      seconds++;          // seconde verlopen
      if (seconds == 60)
      {
        minutes++;           // minuut verlopen?
        seconds = 0;
      }
      if (minutes == 60)
      {
        hours++;             // uur verlopen?
        minutes = 0;
      }

      // display resultaat voor project tijd
      char projectTime[10];       // formaat 000:00 = 9 bytes + '\0' op het einde
      sprintf(projectTime, "%02d:%02d:%02d", hours, minutes, seconds); // alternatief met sec. display
      //sprintf(projectTime, "%02d:%02d   ", hour, minute); // uiteindelijke versie
      lcd.setCursor(0, 0);
      lcd.print("Sessie");
      lcd.setCursor(8, 0);
      lcd.println(projectTime);

      // derde timer deel voor alarmttijd
      seconda++;               // seconde verlopen
      if (seconda == 60)
      {
        minutea++;           // minuut verlopen?
        seconda = 0;
      }
      if (minutea == 60)
      {
        houra++;             // uur verlopen?
        minutea = 0;
      }
      if (houra == 2)     // voor test op 2
      {
        digitalWrite (ledPin, HIGH); // LED aan (dit werkt!)
      }
    }

    //Alarm resetten naar 0 en led uitschakelen, teller begint opnieuw na nieuwe start.
    {
      if (digitalRead(buttonAPin) == AAN)  //lees reset alarm drukknop
      {
        // led alarm uit
        digitalWrite (ledPin, LOW);
        // we gaan het eeprom nu wissen
        EEPROM.write(EEPROM_ALARM_UREN    , 0xFF);    // high byte
        EEPROM.write(EEPROM_ALARM_UREN + 1  , 0xFF);  // low byte
        EEPROM.write(EEPROM_ALARM_MINUTEN , 0xFF);

        // en ook nog eens wachten tot de knop is losgelaten
        while (digitalRead(buttonAPin) == AAN) {}
      }
    }
  }
  // lees de stop drukknop pin uit. debounce is verder niet nodig omdat je als je eenmaal bent gestart dit niet meer
  // te stoppen is
  if (digitalRead(buttonPin) == AAN)
  {
    // de knop is ingedrukt dus eerst de EEPROM waardes wegschrijven
    EEPROM.write(EEPROM_UREN    , hour / 256);  // high byte
    EEPROM.write(EEPROM_UREN + 1  , hour % 256); // low byte
    EEPROM.write(EEPROM_MINUTEN , minute);
    //
    EEPROM.write(EEPROM_ALARM_UREN    , houra / 256);  // high byte
    EEPROM.write(EEPROM_ALARM_UREN + 1  , houra % 256); // low byte
    EEPROM.write(EEPROM_ALARM_MINUTEN , minutea);

    // meer hoeven we niet te doen

    while (1) {}
  }
}

[nicoverduin Profiel PrivéberichtWebsite]

Nou helemaal goed werken gaat het niet:
a) die alarmtijd moet je op 0 zetten bij de setup als er 0xFF in staat. En als je gaat resetten vanwege testen.
b) als de alarm reset knop wordt ingedrukt, dan moet de 10 uren teller weer op 0 zetten en niet meer op 0xFF
c) verder zou ik nog ff goed testen voordat je de PCB maakt.Enne SMD onderdelen kosten veel minder dan conventioneel. Maar in dit geval.... waar hebben we het over.
d) hou wel rekening dat je er een ISP header op toevoegd. Maakt programmeren veel eenvoudiger in de toekomst. Hoeft niet maar dan moet je elke keer de chip overzetten als je wilt veranderen. En een ISP programmer kost een paar euro.