Hallo Zusammen,
ist schon wieder viel Zeit vergangen seit dem letzten Beitrag...
Ich hab jetzt alle Bauteile zusammen und auch noch ein Labornetzteil, dass ich mal testen konnte, ob das unruhige Verhalten des Motors eventuell durch den DAC kommt - aber nein, es hat nichts damit zu tun. Ich hab auch mal das Labornetzteil als 24V Versorgung für den Motor selbst genommen, aber auch damit das selbe Ergebnis.
Die 1nF Kondensatoren hab ich jetzt auch da und versucht die Spannung zu glätten - keine Besserung.
Auch hab ich versucht einen 1 nF Kondensator, wie du, Heinileini, gesagt hast, zwischen B und C des PNP zu schalten - leider auch keine Verbesserung festzustellen.
Als nächstes hab ich mich dann mal mit dem ATTiny85 vertraut gemacht und hab es geschafft, mit dem Arduino Uno als Programmer eine LED blinken zu lassen - WOW!
Dann hab ich nach einem möglichst fertigen Code für eine Flanken-Erkennung gesucht und gefunden.
Und es funktioniert tatsächlich sehr gut mit der Erkennung und das ganz ohne die Transistor-Schaltung. Ich hab einfach den Fototransistor als Eingang am ATTiny85 verwendet und eine LED soll dann angehen, sobald 10 Impulse erkannt wurden.
Das funktioniert gut, wenn ich von Hand drehe und auch im langsamen Modus bei 0V Steuerspannung. Scheint die Impulse wirklich zuverlässig zu erkennen!
Da der ATTiny85 für mich absolutes Neuland ist, verstehe ich den Code leider nicht 100 Prozentig und auch nicht, wieso die LED beim Starten des Programms an ist und beim Erreichen der 10 Impulse ausgeht, statt an... aber wenigstens werden die Impulse mal richtig erkannt.
Jetzt hab ich noch ein Code im Internet gefunden, der den ATTiny85 mit Hilfe der Bibliothek "TinyWireS" zum i2c slave macht. Damit hab ich auch etwas experimentiert. Im ersten Schritt hab ich einfach nur mal dem ATTiny85 eine i2c Adresse zugewiesen, um ihn mit dem Raspberry Pi über den Befehl "i2cdetect -y 1" zu erkennen. Leider wird nichts erkannt.
UPDATE!
Gerade eben hab ich was von Leitungslänge bei i2c gelesen und hab es direkt mal mit einer ganz kurzen Verbindung probiert und der ATTiny85 wird erkannt!! Adresse 0x4 genau wie konfiguriert und der DAC wird weiterhin als 0x60 erkannt. 1A. Dann teste ich jetzt mal noch weiter und melde mich wieder...
@Thomas_v2.1
Du scheinst dich ja gut mit dem ATTiny85 auszukennen. Kannst du mir eventuell etwas auf die Sprünge helfen, wie ich die Verbindung zwischen ATTiny85 und dem Raspberry Pi über i2c realisieren kann, dass ich einen Integer-Wert vom RPi an den ATTiny85 senden kann?
Ich bin an der Stelle noch unsicher, ob ich einfach einen Digitalen Ausgang am ATTiny85 setzen soll, sobald die Anzahl Impulse erreicht wurde, oder ob das vielleicht auch über i2c funktioniert.
Gibt es irgendwelche Unterschiede zwischen den i2c-Bibliotheken, sodass eine Verbindung nicht mit beliebigen Bibliotheken möglich ist? So wie ich es verstehe, ist das i2c Protokoll doch ein Standard und die Bibliotheken sind nur "Wrapper", um die Benutzung zu vereinfachen. Also sollte doch die Verbindung funktionieren, oder?
Vielen Dank auf jeden Fall an Euch beide!
Hier mal noch die beiden Programme, welche ich jeweils auf die ATTiny85 ausgespielt hab:
Für die Flankenerkennung:
Code:
// ATMEL ATTINY 25/45/85 / ARDUINO
// Pin 1 is /RESET
//
// +-\/-+
// Ain0 (D 5) PB5 1| |8 Vcc
// Ain3 (D 3) PB3 2| |7 PB2 (D 2) Ain1
// Ain2 (D 4) PB4 3| |6 PB1 (D 1) pwm1
// GND 4| |5 PB0 (D 0) pwm0
// +----+
/*
Pin 7 <-- switch to Gnd
Pin 5 (PB0) <---- LED ---> 330 R <-----> Gnd
*/
#include <avr/sleep.h> // Sleep Modes
#include <avr/power.h> // Power management
const byte LED = 0; // pin 5 (D0)
const byte SW = 2; // pin 7 (D2)
const byte LED_DEBUG = 4;
volatile unsigned long count = 0;
ISR (INT0_vect)
{
GIMSK &= ~bit(INT0); // disable INT0
}
void setup ()
{
pinMode (LED, OUTPUT);
pinMode (LED_DEBUG, OUTPUT);
pinMode (SW, INPUT);
digitalWrite (SW, HIGH); // input pull-up
ADCSRA = 0; // turn off ADC
MCUCR &= ~(bit(ISC01) | bit(ISC00)); // INT0 on low level
} // end of setup
void loop ()
{
power_timer0_enable ();
delay (100); // let timer reach a known point
digitalWrite (LED, HIGH);
delay (20);
digitalWrite (LED, LOW);
count++; // Zähler hochzählen, sobald eine Flanke erkannt wurde
if (count == 10) // Wenn Zähler == 10 ...
{
digitalWrite (LED_DEBUG, HIGH); // ... dann die LED einschalten (In der Realität geht die LED an diesem Punkt aus und ist von Anfang an eingeschaltet)
}
power_timer0_disable ();
while (digitalRead (SW) == LOW)
{ } // wait for switch to be released
noInterrupts ();
GIFR = bit (INTF0); // clear interrupt flag
GIMSK = bit (INT0); // enable INT0
power_all_disable (); // power off ADC, Timer 0 and 1, serial interface
set_sleep_mode (SLEEP_MODE_PWR_DOWN);
sleep_enable (); // ready to sleep
interrupts ();
sleep_cpu (); // sleep
sleep_disable (); // precaution
} // end of loop
Für die i2c Kommunikation:
Code:
// ATMEL ATtiny45/85
//
// +-\/-+
// Reset 1| |8 Vcc
// Ain3 (D 3) PB3 2| |7 PB2 (D 2) Ain1 SCL
// Ain2 (D 4) PB4 3| |6 PB1 (D 1) pwm1
// GND 4| |5 PB0 (D 0) pwm0 SDA
// +----+
// Code für Attiny85
// Sendet über I2c die Deltawerte des Encoders zwischen jeder Abfrage
// V 0.1
// Get this from https://github.com/rambo/TinyWire
#include <util/atomic.h>
#define CriticalSection ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
#include <TinyWireS.h> // Bezieht I2c Bibliothek ein
#include "avr/interrupt.h"; // Bezieht AVR Interrupt Bibliothek ein
#define I2C_SLAVE_ADDRESS 0x4 // I2c Slave Adresse
volatile byte counter = 100; // Encoder Zähler
void setup() {
TinyWireS.onRequest(requestEvent); // Bei I2c Anfrage springt in requestEvent Funktion
TinyWireS.begin(I2C_SLAVE_ADDRESS); // Verbindet mit I2c Bus
}
void loop() {
}
void requestEvent() {
TinyWireS.send(counter); // Sendet I2c Nachricht
}
.
