Stap 4: Code
[code]
/*******************************************************
RSP Humpleby 2014
Project - adaptieve teller kan worden afgestemd op elke huidige machine.
Voordelen:-
Geschikt voor het verzenden van graaf gegevens terug naar andere locaties voor meer accurate en betrouwbare deel telt.
Geschikt voor het afsluiten van de machine aan einde van run voor verandering over
Exploitant kan vertellen wanneer einde van deel run klaar is met het opslaan van kosten in het "meer dan Looppas"
Kan gemonteerd worden in minder gevoelig posities dan huidige mechanische tellers.
Lange termijn kostenbesparingen.
Betrouwbaarder.
Uitzonderlijk flexibel kan worden geprogrammeerd om extra functies op dezelfde boord zoals machine tempratures opnemen, automatische verlichting, ethernet, aanroepgegevens logging, enz.
Wide + 5v aan + 20 maximale voedingsspanning.
Goedkoper dan mechanische tellers.
Logboeken en tijdstempels zal tonen waar tellers werden opnieuw instellen of geknoeid.
Als exploitanten zich bewust van dit zijn is het mogelijk dat zij minder vatbaar voor "zachte toffee" getallen die in betere / nauwkeuriger graven resulteren zal.
Moet ook mogelijk zijn functie op te nemen van de bar / materiaal toe te voegen typ selectie wat resulteert in betere voorraadniveau van specifieke onderdelen.
Kan worden ingesteld voor de exploitant (onveilige) of onderhoud (veilig) toename wijzigen.
Sensor input schild momenteel voor demonstratie, maar gemakkelijk gemodificeerde voor meerdere bronnen van inductieve, capacitieve, IR, microswitch, etc. etc.
Dit programma momenteel is ingesteld voor bar schaar variabele increment grootte (geschikt voor elke toename van 1 tot 32.767 zie hierboven).
***********************************************************
bekende beperkingen:-
Bovenste limiet 32.767 als gevolg van 8 bit arithmatic (kon gebruiken FLOAT uit te breiden tegen).
Stuc sensor blijven tellen maar tijdstempels zal tonen waar dit gebeurde en dit zou gebeuren op andere elektronische tellers.
Suceptible te hoge elektrische ruis. Moet in geval van afgeschermde / metaal in de meeste toepassingen.
Vereist voeding binnen 10 voet van MCU.
EEPROM schrijven limiet 100.000!!! op welk punt moet eenheid programma naar 4 nieuwe EEPROM locaties (512 beschikbaar)
TO DO *****************************************************
Toevoegen van EEPROM herstellen voor telling bij stroomstoring
menu van de omslaggrootte bundel instellen
increment menu instellen
***********************************************************
Herziening
1.4 gebruik van string-matrix.
Increment automatisch ingesteld op één voor machines dan schuintrekken (gedefinieerd door sting volgorde).
EEPROM schrijven volgens George suggestie toevoegen
EEPROM duidelijk toevoegen voor legitieme reset (waarschijnlijk twee punten)
1.3 toegevoegd Andrew suggestie van bundel countdown.
Toegevoegde routine voor pin hoge eind van de bundel. exploitant signaal.
Toegevoegde machine lijst (matrix) voor toekomstig gebruik.
1.2 opgenomen naar beneden van de graaf.
Toegevoegde graaf increment en lagere maximumgrenzen.
Verbeterde uitgang voor seriële.
1.1 basic counter functie en alleen opnieuw instellen.
********************************************************/
#include / / display bibliotheek
LiquidCrystal lcd (8, 13, 9, 4, 5, 6, 7); Selecteer de pinnen gebruikt op het LCD-scherm
#include / / EEPROM functies
int bundel = 1000; de grootte van de bundel
int nm = 2; selectie van machine 0 = grote shear, 1 = kleine afschuiving enz enz
int lcd_key = 0; belangrijke initiële waarde instellen
int adc_key_in = 0; analoge pincode instellen voor belangrijke lezen
int count = 0; geteld vanaf nul
int inc = 50; instellen van teller increment *** temp ingesteld op 50 voor demo alleen ***
int deb = 300; 1ste ontdendering / valse trigger factor (0,3 seconden)
int del2 = 100; 2de ontdendering / valse trigger factor (0.1 seconden)
int led2 = 11; 11 gebruiken als signaal indicator voor bundel einde
int addr = 0; instellen voor EEPROM schrijven
int va5 = 1234; instellen als een oneven aantal voor lezen terug vanaf EEPROM en overdracht te bundelen die nog niet gebruikt
int. bd0 = ((EEPROM.read(0)*4)); Lees bundel waarde vanaf EEPROM die nog niet gebruikt
int. nm0 = ((EEPROM.read(1)*4)); Nm waarde afgelezen EEPROM die nog niet gebruikt
int. ct0 = ((EEPROM.read(2)*4)); Waarde van de count lezen vanaf EEPROM die nog niet gebruikt
int in0 = ((EEPROM.read(3)*4)); Lees inc waarde vanaf EEPROM die nog niet gebruikt
#define btnRIGHT 0 / / gewend decrement (inc) graaf stappen
#define btnUP 1 / / inrement (inc) tellen
#define btnDOWN 2 / / decrement graaf door (inc)
#define btnLEFT 3 / / gebruikt voor het ophogen van (ex) graaf stappen
#define btnSELECT 4 / / gebruikt om de teller op nul instellen
#define btnNONE 5 / / gebruikt voor fout doeleinden alleen
#define endloop 6 / / jump naar einde van de routine van de bundel
#define herstart / / nog niet gestart
MACHINE lijst (zie "nm" variabele) kunt u deze aanpassen aan uw eigen behoeften, maar ik zet de machines één knippen zou 6 bars die de basis vormt voor de telling van de increment meerdere bezuinigingen op de voorzijde van de lijst doen.
char * Str1 [] = {"grote 45 SHEAR", "kleine 45 SHEAR", "Rechte SHEAR", "Plaat PRESS", "ROLL vorm", "VOORMACHINES", "ONE THREADER", "Twee THREADER",
"IK / D MACHINE", "PEELER", "AUTO PIN EEN", "AUTO PIN TWEE", "HANDLEIDING PIN EEN", "HANDLEIDING PIN TWEE", "KOPTEKST", "WELDER ONE", "WELDER TWEE", "WELDER DRIE"};
int read_LCD_buttons() / / Lees de knoppen
{
herstarten;
adc_key_in = analogRead(0); luiden naar de waarde van het schild
mijn knoppen wanneer Lees zijn gecentreerd op deze valies: 0, 144, 329, 504, 741
ongeveer 50 toevoegen aan deze waarden en controleren om te zien als we nauwe
Als (nm > = 3) inc = 1; Als de machine niet schuintrekken vervolgens toename = 1
Als (bundel < = 0) terug van endloop;
Als (adc_key_in > 1000) return btnNONE; over het algemeen geen schakelaar geactiveerd
BAR INC
Als (adc_key_in < 50 & & inc < = 10) inc = inc + 1; verhogen bar graaf stap-grootte niet meer dan 10 geboden
EEPROM.write (3, inc); Winkel INC in EEPROM
Als (adc_key_in < 50) return btnRIGHT;
TELLER INC
delay(del2);
Als (bundel < = 0) terug van endloop;
Als (adc_key_in < 250) tellen = count + inc; Increment teller door "inc"
EEPROM.write (2, telling); Graaf opgeslagen in EEPROM
Als (adc_key_in < 250) bundel = bundel - inc; verkleinen van de bundel
Als (adc_key_in < 250) return btnUP;
delay(del2);
TELLER-DEC
Als (bundel < = 0) terug van endloop;
Als (adc_key_in < 450) tellen = tellen -inc; decrement teller door "inc"
EEPROM.write (2, telling); Graaf opgeslagen in EEPROM
Als (adc_key_in < 450) bundel = bundle + inc; vergroten van de bundel
EEPROM.write (0, bundel); Winkel bundel in EEPROM
Als (adc_key_in < 450) return btnDOWN;
BAR DEC
delay(del2);
Als (bundel < = 0) terug van endloop;
Als (adc_key_in < 650 & & inc > = 1) inc = inc - 1; decrement bar graaf stap-grootte
EEPROM.write (3, inc); Winkel INC in EEPROM
Als (adc_key_in < 650) btnLEFT retourneert;
ENDLOOP-STAP-SPRINGEN
delay(del2);
Als (bundel < = 0) terug van endloop;
RESET
delay(del2);
Als (adc_key_in < 850) tellen = 0; teller reset
Als (adc_key_in < 850) bundel = 1000; Reset bundel
voor (int i = 0; ik < 3; i ++) / / clear eerste 5 bytes van EEPROM
EEPROM.write (i, 0); Schakel de eerste 5 bytes van EEPROM
Als (adc_key_in < 850) return btnSELECT;
Return btnNONE; in geval van fout
}
void setup / / INITALISE
{
Serial.begin (9600); Instellen van seriële en externe tellen met behulp van "coole term"
terwijl (!. Seriële) {}
; wachten op de seriële poort te verbinden. Alleen nodig voor Leonardo
}
LCD.begin (16, 2); de LCD's aantal kolommen en rijen instellen:
lcd.setCursor (0, 0); lijn 1
LCD.Print ("JENMAR INC c2014"); Splash-scherm
lcd.setCursor (0, 1); lijn 2
LCD.Print ("ADAPTIEVE COUNTER"); Splash-scherm
vertraging (5000); onderbreken van 10 seconden
LCD.Clear(); scherm wissen
lcd.setCursor (0, 0); lijn 2
LCD.Print(Str1[nm]); STD MACHINE LOGO
pinMode (led2, OUTPUT); definiëren van signaal op
}
void loop / / MAIN LOOP
{
lcd.setCursor(0,1); verplaatsen naar het begin van de tweede lijn
lcd_key = read_LCD_buttons(); Lees de knoppen
schakelaar (lcd_key) / / afhankelijk van welke knop werd geduwd, we een actie uitvoeren
{
Case btnRIGHT:
{
Als (inc > = 10) inc = 10; bovengrens zorgen
Serial.println(Str1[nm]);
Serial.Print ("increment =");
Serial.println(Inc);
vertraging (deb); ontdendering en increment teller stap + 1
breken;
}
Case btnLEFT:
{
Als (inc < = 0) inc = 1; ondergrens zorgen
Serial.println(Str1[nm]);
Serial.Print ("Decrement =");
Serial.println(Inc);
vertraging (deb); ontdendering decrement teller - stap1
breken;
}
Case btnUP:
{
LCD.Print(Count); teller plus telling weergeven
LCD.Print ("BNDL >"); Tekst van de bundel
LCD.Print(Bundle); bundel graaf
LCD.Print(""); volgspaties
Serial.println(Str1[nm]);
Serial.Print ("UP count");
Serial.println(Count);
vertraging (deb); ontdendering
breken;
}
Case btnDOWN:
{
LCD.Print(Count); teller minus graaf weergeven
LCD.Print ("BNDL >"); Tekst van de bundel
LCD.Print(Bundle); bundel graaf
LCD.Print(""); volgspaties
Serial.println(Str1[nm]);
Serial.Print ("DOWN count");
Serial.println(Count);
vertraging (deb); ontdendering
breken;
}
Case btnSELECT:
{
LCD.Print(Count); teller terug op nul weergeven
LCD.Print ("BNDL >"); Tekst van de bundel
LCD.Print(Bundle); bundel graaf
LCD.Print(""); volgspaties
Serial.Print ("***");
Serial.Print (Str1[nm]);
Serial.Print ("teller RESET *** =");
Serial.println(Count);
voor (int i = 0; ik < 4; i ++) / / clear eerste 5 bytes van EEPROM
EEPROM.write (i, 0); Schakel de eerste 5 bytes van EEPROM
vertraging (deb); ontdendering
breken;
}
Case endloop:
{
digitalWrite (led2, hoge); de bundel einde signaal inschakelen
LCD.Clear(); scherm wissen
lcd.setCursor (0, 0); lijn 1
LCD.Print ("> bundel einde <"); Splash-scherm
lcd.setCursor (0, 1); lijn 2
LCD.Print ("* verandering OVER *"); Splash-scherm
vertraging (20000); onderbreken van 20 seconden
digitalWrite (led2, laag); de bundel einde signaal uitschakelen
bundel = 1000; Reset bundel
Graaf = 0; teller reset
voor (int i = 0; ik < 4; i ++) / / clear eerste 5 bytes van EEPROM
EEPROM.write (i, 0); Schakel de eerste 5 bytes van EEPROM
LCD.Clear(); scherm wissen
lcd.setCursor (0, 0); lijn 1
LCD.Print(Str1[nm]); STD LOGO
lcd.setCursor(0,1); lijn 2
breken;
}
Case btnNONE:
{//lcd.print ("geen"); behandelen als een reguliere indrukken van een toets
vertraging (deb); ontdendering
breken;
}
Case epWRITE:
// {
Kopieën van kritische variabelen naar EEPROM schrijven
int va0 = bundel / 4; prep variabelen voor eeprom
int va1 = nm / 4; prep variabelen voor eeprom
int va2 = aantal / 4; prep variabelen voor eeprom
int va3 = inc / 4; prep variabelen voor eeprom
EEPROM.write (0, va0); schrijven naar eeprom
EEPROM.write (1, va1); schrijven naar eeprom
EEPROM.write (2, va2); schrijven naar eeprom
EEPROM.write (3, va3); schrijven naar eeprom
// }
Case EPclear:
// {
Legitieme reset *** verplaatst naar legit reset sectie ***
EEPROM duidelijke routine
voor (int i = 0; ik < 4; i ++) / / clear eerste 5 bytes van EEPROM
EEPROM.write (i, 0); Schakel de eerste 5 bytes van EEPROM
breken;
// }
Case EPread:
// {
Lezen en bijwerken van variabelen vanaf EEPROM, als ze bestaan zijn verschillend van 0 of initiële waarde
va0 = (EEPROM.read(0)*4); Lees bundel waarde vanaf EEPROM
int bundel = va0 * 4; Ingestelde variabelen met behulp van de eeprom
va1 = (EEPROM.read(1)*4); Waarde van de count lezen vanaf EEPROM
int count = va1 * 4; Ingestelde variabelen met behulp van de eeprom
va2 = (EEPROM.read(2)*4); Machine naamwaarde lezen vanaf EEPROM
int nm = va2 * 4; Ingestelde variabelen met behulp van de eeprom
va3 = (EEPROM.read(3)*4); Lees increment-waarde vanaf EEPROM
int inc = va4 * 4; Ingestelde variabelen met behulp van de eeprom
breken;
// }
}
}
EOF
[/ code]
