Digitales Zählwerk ( nur Counter ) AKAI GX 620

[DIYLAB]

tja, das hilft mir nix. . .

In diesem Posting stehen die Maße: https://old-fidelity-forum.de/thread-382...pid1292478

[stephan1892]

Hallo an Alle  
Da ich auch so ein Zählwerk für meine beiden" Russinen " haben möchte,hier mal eine ,für andere vielleicht bescheuerte Frage 
Von diesem Arduino und Raspberry Gedöns habe ich keinen blassen Schimmer 
Wie werden den die einzelnen Baugruppen (Lichtschranke,Display und der Prozessor ) miteinander verbunden?
 Bruno ,Du verwendest da ja so ein Steckfeld für den Testaufbau,aber wie geht das in der Praxis? Steckverbinder? Löten?
Ich habe keine Ahnung
Steffen

[DIYLAB]

 Bruno ,Du verwendest da ja so ein Steckfeld für den Testaufbau,aber wie geht das in der Praxis? Steckverbinder? Löten?

Hallo Steffen,

diese Steckbretter nehme ich manchmal zum provisorischen Aufbau, sozusagen für die ersten Versuche.
Bitte gedulde dich noch ein bisschen, ich bin gerade dabei, die zusammengefasste Anleitung zu erstellen, woraus dann alles weitere ersichtlich ist .

LG
Bruno

[Der Karsten]

ich hab da mal ne Frage Bruno,
lässt sich das dann so Programieren das, dass ZW dann in Meter anzeigt, so wie die verbauten mechanischen?
Dazu müßte man dann aber an der jeweiligen Maschine die Umdrehungen des Abnehmers für 1 m Band ermitteln.

[DIYLAB]

lässt sich das dann so Programieren das, dass ZW dann in Meter anzeigt, so wie die verbauten mechanischen?
Dazu müßte man dann aber an der jeweiligen Maschine die Umdrehungen des Abnehmers für 1 m Band ermitteln.

Programmtechnisch alles machbar, nur eine Gegenfrage, da ich mich wirklich nicht mit den verbauten Zählern auskenne:
ändert sich dann nicht auch die Anzeige, wenn der Wickel sich im Durchmesser ändert (mehr oder weniger Impulse)? Oder wo hab ich da den Denkfehler?
Wie ist denn das in den Maschinen, die du meinst?
Das setzt doch wieder eine Impulsabnahme an einer Bandrolle vorraus und nicht so, wie es bei Ingo sein wird?

[Der Karsten]

...ändert sich dann nicht auch die Anzeige, wenn der Wickel sich im Durchmesser ändert (mehr oder weniger Impulse)? Oder wo hab ich da den Denkfehler?...

Ne sorry Bruno, ich hab wieder den Denkfehler drinn, die ZW werden vom rechten Wickelteller per Riemen an das ZW geleitet, kann also nichts mit Metern sein bei den mechanischen.
Was zeigen die dann eigentlich an? Zeit kann es ja nicht sein und Meter ja nu auch nicht, was verdammt wird da gezählt?

Wäre schön wenn man das mal rausbekommen könnte.

[spocintosh]

Es werden Umdrehungen der Zählwerkscheiben gezählt. Einfach nur, um eine Nummer zu generieren, die wiedergefunden werden kann - sonst nichts.

[DIYLAB]

Es werden Umdrehungen der Zählwerkscheiben gezählt. Einfach nur, um eine Nummer zu generieren, die wiedergefunden werden kann - sonst nichts.

Ja das wissen wir, schönen Dank trotzdem .

[spocintosh]

Hä ? Alles klar da drüben ?

Ich hab ne Frage beantwortet - "wissen wir" stimmt also ganz offensichtlich nicht. Und ist gar nicht schlimm.

kann also nichts mit Metern sein bei den mechanischen.
Was zeigen die dann eigentlich an? Zeit kann es ja nicht sein und Meter ja nu auch nicht, was verdammt wird da gezählt?

Wäre schön wenn man das mal rausbekommen könnte.

[DIYLAB]

Software fertig .
Morgen mache ich dann noch die Anleitung, wie alles zusammenpasst.
Vorab für die Mitleser, denen die Controllerprogrammierung schon bekannt ist und die fummeln möchten, das ganze Programm (die beiden verwendeten Libs sind angeführt):

Code:

/* Arduino OLED Tape Counter
* Copyright (C) 2020 by DIYLAB, v0.99, 28.04.2020
*
* This Software is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This Software 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with the Arduino SSD1306Ascii Library.  If not, see
* <http://www.gnu.org/licenses/>.
*
* Used libraries
* ~~~~~~~~~~~~~~
* SSD1306Ascii: <https://github.com/greiman/SSD1306Ascii>
* Arduino OneButton Library: <https://github.com/mathertel/OneButton>
*
* Used mikrocontroller
* ~~~~~~~~~~~~~~~~~~~~
* Arduino nano v3.0
*/

#include <SSD1306Ascii.h>
#include <SSD1306AsciiAvrI2c.h>
#include <OneButton.h>
#include <EEPROM.h>

///////////////////////////////////////////////////////////////
// USER CONFIG SECTION (Only edit here!)                     //
///////////////////////////////////////////////////////////////
// Software configuration:
#define PULSESPERCOUNT    1    // Number of pulses for one count.
#define BRIGHTNESS        128    // Display brightness (0 to 255)

// Hardware pin configuration:
// *Only change if absolutely necessary!
#define SENSOR_A        3    // Controller PIN (Sensor-A)
#define SENSOR_B        2    // Controller PIN (Sensor-B)
#define BUTTON            5    // Controller PIN (RESET-Button)
#define ZEROPOINT        7    // Controller PIN ('00000' pulse)
///////////////////////////////////////////////////////////////

#define LED                13    // Onboard LED
#define LEFT            1    // left rotation
#define RIGHT            2    // right rotation
#define EEPROM_ADDRESS    0x0    // EEPROM address for data store
#define I2C_ADDRESS        0x3C // or 0x3D - depending on display

// Intervals
#define INTERVAL1 1000

OneButton btn(BUTTON, true, true);
SSD1306AsciiAvrI2c oled;

unsigned int loopCounter = 0;
unsigned long secondTick = 0;
unsigned long timeInterval1 = 0;
volatile long counter = 0;
volatile int sensor1 = 0;
volatile int sensor2 = 0;
volatile int direction = 0;
volatile int step = 0;
volatile int divider = 0;
volatile boolean stepFlag0, stepFlag1, stepFlag2, stepFlag3, onboardLEDFlag;

/**
* Setup
********/
void setup() {
    // Set inputs.
    pinMode(SENSOR_A, INPUT);
    pinMode(SENSOR_B, INPUT);

    // Set outputs.
    pinMode(LED, OUTPUT);
    pinMode(ZEROPOINT, OUTPUT);

    // Link the button functions.  
    btn.attachClick(ButtonClick);
    btn.attachDoubleClick(ButtonDoubleClick);
    btn.attachLongPressStart(ButtonLongPressStart);
    btn.attachLongPressStop(ButtonLongPressStop);

    // Initialize Timer 1.
    setupTimer1();

    // Set PinChange Interrupts.
    attachInterrupt(0, CheckState, CHANGE);
    attachInterrupt(1, CheckState, CHANGE);

    // Initialize display.
    oled.begin(&Adafruit128x32, I2C_ADDRESS);

    // Set font.
    oled.setFont(lcdnums12x16);

    // Set display brightness.
    oled.setContrast(BRIGHTNESS);

    // Clear display.
    oled.clear();

    // Set magnification of the font.
    oled.set2X();

    // Get last counter reading from the EEPROM.
    counter = EEPROMReadlong(EEPROM_ADDRESS);

    // Initial settings on the Display from EEPROM.
    WriteOled((counter == -1) ? 0 : counter);
}

/**
* MainLoop
***********/
void loop() {
    // Watching the push button.
    btn.tick();

    // Turn ZEROPOINT output pin off after INTERVAL1 if was on.
    if (millis() > timeInterval1 + INTERVAL1) {
        timeInterval1 = millis();
        if (digitalRead(ZEROPOINT))
            digitalWrite(ZEROPOINT, LOW);
    }

    // Is the edge sequence complete?
    if (stepFlag0 && stepFlag1 && stepFlag2 && stepFlag3)
    {
        // Reset all edge flags.
        stepFlag0 = stepFlag1 = stepFlag2 = stepFlag3 = false;

        // Increase the loop-counter.
        loopCounter++;

        // Count only after reaching the target 'PULSESPERCOUNT'.
        if (loopCounter == PULSESPERCOUNT)
        {
            // Reset the loopCounter.
            loopCounter = 0;

            // Counter up or down, depending on the direction.
            (direction == LEFT) ? counter++ : counter--;

            // Output on the display.
            WriteOled(counter);

            // '00000" Pulse.
            if (counter == 0)
                digitalWrite(ZEROPOINT, HIGH);
        }

        // As long as the sensors provide data,
        // reset timer1 regularly before the timer overflow
        // to avoid unnecessary writing to the EEPROM.
        TCNT1 = 0;
    }
}

/**
* This function will be called when the button was pressed 1 time.
*******************************************************************/
void ButtonClick() {
    WriteOled(counter = 0);
}

/**
* This function will be called when the button was
* pressed 2 times in a short timeframe.
***************************************************/
void ButtonDoubleClick() {
    // Intended for later use!
}

/**
* This function will be called once, when the button is
* pressed for a long time.
*********************************************************/
void ButtonLongPressStart() {
    // Intended for later use!
}

/**
* This function will be called once, when the button is
* released after beeing pressed for a long time.
*********************************************************/
void ButtonLongPressStop() {
    // Intended for later use!
}

/**
* Write OLED Display
*********************/
void WriteOled(unsigned long val) {
    // Buffer for all five digits.
    char buffer[5];

    // Formatting the output.
    sprintf(buffer, "%05ld", val);

    // Output on the display.
    oled.println(buffer);
}

/**
* Check Sensor State after Interrupt
*************************************/
void CheckState() {
    // Interrogate sensors.
    sensor1 = digitalRead(SENSOR_A);
    sensor2 = digitalRead(SENSOR_B);

    // Edge Detector
    if (sensor1 == 1 && sensor2 == 1)
    {
        if (step == 1) { direction = LEFT; }
        if (step == 3) { direction = RIGHT; }
        step = 0;
        stepFlag0 = true;
    }
    if (sensor1 == 0 && sensor2 == 1)
    {
        if (step == 2) { direction = LEFT; }
        if (step == 0) { direction = RIGHT; }
        step = 1;
        stepFlag1 = true;
    }
    if (sensor1 == 0 && sensor2 == 0)
    {
        if (step == 3) { direction = LEFT; }
        if (step == 1) { direction = RIGHT; }
        step = 2;
        stepFlag2 = true;
    }
    if (sensor1 == 1 && sensor2 == 0)
    {
        if (step == 0) { direction = LEFT; }
        if (step == 2) { direction = RIGHT; }
        step = 3;
        stepFlag3 = true;
    }
}

/**
* Timer overflow interrupt.
****************************/
ISR(TIMER1_COMPA_vect) {
    // Increase second counter.
    secondTick++;

    // If LED on, turn LED off.
    if (onboardLEDFlag)
        digitalWrite(LED, LOW);

    if (divider == 0)
    {
        // Only store in EEPROM if the data differ!
        if (EEPROMReadlong(0) != counter)
        {
            // Turn LED on, set flag.
            digitalWrite(LED, HIGH);
            onboardLEDFlag = HIGH;

            // Write counter data to EEPROM.
            EEPROMWritelong(EEPROM_ADDRESS, counter);
        }
    }
    divider++;
    divider %= 5;
}

/**
* Initialize Timer1.
*********************/
void setupTimer1() {
    noInterrupts();
    // Clear registers
    TCCR1A = 0;
    TCCR1B = 0;
    TCNT1 = 0;

    // 1 Hz (16000000/((15624+1)*1024)).
    OCR1A = 15624;
    // CTC
    TCCR1B |= (1 << WGM12);
    // Prescaler 1024.
    TCCR1B |= (1 << CS12) | (1 << CS10);
    // Output Compare Match A Interrupt Enable.
    TIMSK1 |= (1 << OCIE1A);
    interrupts();
}

/**
* Write a 4 byte (32bit) long to the eeprom
* at the specified address to adress + 3.
*********************************************/
void EEPROMWritelong(int address, long value) {
    // Decomposition from a long to 4 bytes by using bitshift.
    byte four = (value & 0xFF);
    byte three = ((value >> 8) & 0xFF);
    byte two = ((value >> 16) & 0xFF);
    byte one = ((value >> 24) & 0xFF);

    // Write the 4 bytes into the eeprom memory.
    EEPROM.write(address, four);
    EEPROM.write(address + 1, three);
    EEPROM.write(address + 2, two);
    EEPROM.write(address + 3, one);
}

/**
* return a 4 byte (32bit) long from the eeprom
* at the specified address to adress + 3.
* returns: long
*********************************************/
long EEPROMReadlong(long address) {
    // Read the 4 bytes from the eeprom memory.
    long four = EEPROM.read(address);
    long three = EEPROM.read(address + 1);
    long two = EEPROM.read(address + 2);
    long one = EEPROM.read(address + 3);

    // Return the recomposed long by using bitshift.
    return ((four << 0) & 0xFF) + ((three << 8) & 0xFFFF) + ((two << 16) & 0xFFFFFF) + ((one << 24) & 0xFFFFFFFF);
}

[stephan1892]

Moin Moin 
Wie soll ich das alles in den kleinen Controller reinkriegen?
Steffen

[akguzzi]

Steffen...
rede mit ihm... reden hilft immer?

[dedefr]

Das wirde noch alles erklärt, etwas geeeeduld bittschön 

[DIYLAB]

Hallo Bastler,

das Herz des Projekts ist die Software, die in den Mikrocontroller muss.
Ich beschreibe nun in einfachen Schritten, wie ihr die Entwicklungsumgebung einrichtet und das Programm kompiliert.

Das kann jeder, versprochen! Für alle Schritte in dieser Anleitung ist kein angeschlossener Mikrocontroller nötig.
Wenn das geklappt hat, seid ihr ein großes Stück weiter .

1. Geht im Browser zu dieser Seite: https://www.arduino.cc/en/main/software

2. Ladet die Arduino Entwicklungsumgebung, passend zu eurem Betriebssystem herunter (gibt es für Windows, macOS und Linux).
Hier wird ausschließlich die Windows Version beschrieben. Nehmt nicht die Windows "App", sondern die konventionelle Version (mit Pfeil im Bild markiert).



Bevor der Download möglich ist, kommt eine Seite, auf der die Entwickler dieser Software unterstützt werden können.
Wenn ihr später vielleicht öfter damit arbeitet, ist das eine nette Möglichkeit, ein kleines bisschen zurückzugeben.
Prinzipiell ist diese Software aber kostenlos!



Ansonsten bitte auf "just download" klicken (ca. 110Mb).

Die momentan aktuelle Version ist die 1.8.12 und die Installationsdatei heißt arduino-1.8.12-windows.exe

3. Installiert die Software. Lasst alle Haken so wie sie sind. Das Installationsverzeichnis würde ich auch so lassen wie es voreingestellt ist.



Da ja später ein Arduino (Mikrocontroller) zum Programmieren via USB angeschlossen werden soll, müssen einige Gerätetreiber installiert werden. Lasst diese Installation auf jeden Fall zu, sonst könnt ihr später keine Verbindung mit dem Controller herstellen!

Hier die Treiber, die ich meine:







Danach ist die Installation erledigt und ihr könnt das Programm zum ersten mal starten.
Jetzt könnte es noch sein, dass die Windows-Firewall eine Meldung bringt.
Bitte wie im Bild einstellen und auf "Zugriff zulassen" klicken.



4. Konfiguriere die Software.

Nehmt die im Bild gezeigten Einstellungen vor (Borard: "Arduino Nano" & Programmer: "USBasp").



5. Bindet die beiden benötigten Software-Bibliotheken in die Entwicklungsumgebung ein.

Um die Bibliotheksverwaltung zu starten, klickt die Punkte wie im Bild gezeigt:



Die erste Bibliothek ist für die Ausgabe auf dem OLED-Display zuständig.

Tragt in das Feld (mit 1. markiert) SSD1306Ascii ein und installiert die Bibliothek (mit 2. markiert).



Die zweite Bibliothek ist für den Taster zuständig. Die Abfrage des Tasters könnte man auch ohne diese Bibliothek machen, allerdings ist durch diese Bibliothek eine überaus komfortable Möglichkeit geschaffen, mit nur einem Taster viele Funktionen auszuführen - ein sehr geniales Stück Software, die Herr Hertel uns kostenlos zur Verfügung stellt.

Tragt also in das Feld (mit 1. markiert) OneButton ein und installiert die Bibliothek (mit 2. markiert).



Wenn alles geklappt hat, sollten die beiden Bibliotheken auch in der Übersicht auftauchen:



6. Jetzt kann unser Programm in den Editor geladen werden.

Entweder ihr kopiert euch den Code aus Beitrag #85 in den Editor oder ihr ladet das Projekt herunter.

Die jeweils aktuellste Version ist immer hier: https://drive.google.com/file/d/1dFChknD...sp=sharing

Wenn ihr euch für den Download entschieden habt, dann schließt bitte das Arduino Programm und packt das ZIP-Archiv aus.

Macht euch irgendwo ein Projektverzeichnis auf der Festplatte, vielleicht namens Arduino. Dort hinein entpackt ihr den Inhalt von TapeCounter.zip

Die Verzeichnisstruktur könnte z.B. dann so aussehen: d:\Projekte\TapeCounter\

Im Verzeichnis TapeCounter sollte sich nun die Datei TapeCounter.ino befinden.

Ein Doppelklick auf die Datei TapeCounter.ino öffnet nun automatisch die Entwicklungsumgebung und lädt das Programm dort zur Bearbeitung hinein.

Das sollte nun so aussehen:



Zu guter letzt wird nun das Programm kompiliert.
Klickt dazu auf SKETCH -> Überprüfen/Kompilieren:



Ist das Programm so wie im Bild erfolgreich kompiliert worden?
Herzlichen Glückwunsch! Du hast es geschafft!

Im nächsten Teil kümmern wir uns um die Hardware  .

LG
Bruno

[dedefr]

Daaaaankeeeeee 

Hat alles tadelos geklappt !

[Rüsselfant]

feddich 

[Rüsselfant]

So,

Die Hardware ist da

[DIYLAB]

Die Hardware ist da

Hey cool
Dann kannst du die Arduino-Tüte schon mal aufreißen und das Ding, ohne irgendetwas anzulöten via USB an Deinen PC stöpseln. Dann biste der Erste der Interessenten, der den Controller programmiert hat

[Rüsselfant]

Naja, wenn ich schon so nen Bekloppten "Fred" eröffne,

muss ich auch wohl in den sauren Appel beissen :-)


Dauert aber, weil ich muss ja auch noch watt arbeiten ^^

[sensor]

So,

Die Hardware ist da

wo haste das alles bestellt?

[DIYLAB]

wo haste das alles bestellt?

Moin Ulf,

wenn Du dich noch ein bisschen geduldest, im zweiten Teil der Anleitung gebe ich euch alle nötigen Links zur Bestellung inkl. Alternativen.

[Rüsselfant]

So  angeschlossen,

wird als USB-Serial CH340  (Com3)   erkannt und leucht grün  ( nicht wie bei Rambo, in blau   )


Ulf   Bruno hat doch Links in diesen Fred implementiert. war über ebay

Aber wie er schrieb, Schlappen still halten..ich weiss, es ist schwer :-)



LG

Ingo

[DIYLAB]

wird als USB-Serial CH340  (Com3)   erkannt und leucht grün

Na das ist doch schon mal toll .

Dann hier ein kleiner Zwischenabschnitt, wie das Programm in den Controller kommt.
Wie auf dem Bild zu sehen ist, bitte überprüfen, ob der Port in der Entwicklungsumgebung korrekt angezeigt wird und ggf. den richtigen Port auswählen.
Das setzt natürlich einen angeschlossen Controller voraus .



Dann auf den Knopp "Hochladen" klicken und beten.
Das Programmieren sollte wie im Bild zu sehen, ohne Fehlermeldung durchlaufen.



Geht nicht? Fehler?
Dann habt ihr nun das offizielle ok, den Händler zu verhauen, denn er hat euch einen Ladenhüter mit altem Bootloader verkauft  .
Macht aber nichts, einfach wie im Bild zu sehen, den alten Bootloader wählen und dann sollte es auch gehen.



Nun muss ich ne Weile weg zum Einkaufen und bin gespannt auf eure Rückmeldungen  .

[Rüsselfant]

Hallo Freunde,

hier ein Photo von der Abdeckung der GX620.
Verhältnis der Zählwerk Öffnung zum digitalem Counter

[DIYLAB]

hier ein Photo von der Abdeckung der GX620.

Die Ausgabe im Display erstreckt sich nicht auf die gesamte Displayfläche und wir können auch andere Zeichensätze/Schriftgrößen benutzen.
Bevor du anfängst, mechanisch etwas abzutragen, bitte erst mal das gesamte Gedöns verdrahten und dann aufs Display schauen, dann ist man schlauer.

Schaltplan gibts heute noch. spät.