Dziś biblioteka do obsługi enkodera obrotowego. Znów uniwersalna (inicjalizacja i odczyt sprzętu po stronie użytkownika). Możliwości biblioteki:- Nieblokująca.
- Reakcja na zdarzenia z enkodera (użytkownik musi zdefiniować).
- Obsługa przycisku enkodera z rozróżnieniem długości wciśnięcia - 3 poziomy.
Poniżej kod.
encoder.h:[syntax=c]/*
* encoder.c
*
* Created on: 1 maj 2015
* Author: Piotr Rudzki ryba.lodz@gmail.com
* Version: 1.0
* Changelog:
* 1.0 - small code optimizations, and cleanups
* 0.9 - split encPool function code for better code readable
* - added encoder pulse divisor macro for encoders with many pulses between steady states
* - added macro to disable encoder button routines
* 0.8 - initial release
*/
#ifndef ENKODER_H_
#define ENKODER_H_
#include <stdint.h>
#define ENC_BUTTON// Należy zakomentować jeśli nie obsługujemy przycisku enkodera. Zmniejszy kod wynikowy usuwając zbędne funkcje.
#define ENC_DIVISOR4// Ile impulsów generuje enkoder pomiędzy stanami stabilnymi.
#define SHORT_TIME250 // Krótkie wciśnięcie czas wyrażony w zależności od tempa wywoływania funkcji encPool.
#define LONG_TIME1000// Dłuższe j.w.
#define VERY_LONG_TIME3000// Bardzo długie j.w.
// Struktura opisująca stan enkodera.
typedef struct{
uint8_t A;
uint8_t B;
uint8_t SW;
} encState_t;
enum encRotate {STOP, CW, CCW}; // Zdarzenia obracania enkoderem.
#ifdef ENC_BUTTON
enum encButton {NONE, SHORT, LONG, VERY_LONG}; // Zdarzenia przycisku enkodera.
#endif
// Struktura opisująca zdarzenia enkodera.
typedef struct{
enum encRotate rotate;
#ifdef ENC_BUTTON
enum encButton button;
#endif
} encEvent_t;
void regEncState(encState_t (*callback)(void)); // Rejestracja funkcji odczytującej stan enkodera.
void regEncAction(void (*callback)(encEvent_t const event)); // Rejestracja funkcji obsługującej zdarzenia enkodera.
void encPool(void); // Wywołujemy w przerwaniu timera.
#endif /* ENKODER_H_ */[/syntax]
encoder.c:[syntax=c]/*
* encoder.c
*
* Created on: 1 maj 2015
* Author: Piotr Rudzki ryba.lodz@gmail.com
* Version: 1.0
* Changelog:
* 1.0 - small code optimizations, and cleanups
* - small changes in button code it only reacts for release
* 0.9 - split encPool function code for better code readable
* - added encoder pulse divisor macro for encoders with many pulses between steady states
* - added macro to disable encoder button routines
* 0.8 - initial release
*/
#include "encoder.h"
// Odczyt kierunku obrotu enkodera.
// Jeśli przypiszemy jednemu pinowi wagę 1 a drugiemu 2 to sekwencja
// w kierunku wskazówek zegara wygląda tak:
// w kodzie Gray-a:0, 1, 3, 2, 0 ...
// w binarnym:0, 1, 2, 3, 0 ...
static inline enum encRotate readEncRotate(encState_t const * const state) {
static uint8_t encLast = 0; // Ostatnia pozycja enkodera.
static uint8_t encDivisor = 0; // Licznik impulsów enkodera.
uint8_t last = 0, actual = 0; // Zmienne pomocnicze.
// Zmiana kodu Gray-a na binarny.
if (!state->A) {
actual++; // 1
}
if (!state->B) {
actual ^= 3; // XOR 3
}
last = encLast;
encLast = actual; // Zapisujemy aktualną pozycję.
// Ustalamy czy nastąpiła zmiana pozycji. Wynik odejmowania wskazuje czy nastąpił ruch,
// oraz kierunek tego ruchu. Bit 0 wskazuje czy nastąpił ruch, a bit 1 jego kierunek.
// Kierunek wskazówek: 2 - 3 = 255 (0b11111111) (ponieważ posługujemy się zmiennymi typu unsigned)
// Przeciwnie: 0 - 3 = 253 (0b11111101) (j.w.)
actual -= last;
if (actual & 1) {
if (actual & 2) {
if (++encDivisor == ENC_DIVISOR) { // Bierzemy pod uwagę licznik impulsów.
encDivisor = 0;
return CW; // Kierunek wskazówek zegara.
}
} else {
if (--encDivisor == (uint8_t) (0 - ENC_DIVISOR)) { // J.w.
encDivisor = 0;
return CCW; // Kierunek przeciwny do wskazówek zegara.
}
}
}
return STOP;
}
#ifdef ENC_BUTTON
// Obsługa przycisku enkodera.
static inline enum encButton readEncButton(encState_t const * const state) {
static uint16_t pushTime = 0; // Czas trzymania przycisku.
enum encButton tmp;
if (pushTime && state->SW) { // Zwolnienie przycisku.
if ((SHORT_TIME < pushTime) && (pushTime < LONG_TIME)) {
tmp = SHORT;
}
if ((LONG_TIME < pushTime) && (pushTime < VERY_LONG_TIME)) {
tmp = LONG;
}
if (VERY_LONG_TIME < pushTime) {
tmp = VERY_LONG;
}
pushTime = 0;
} else {
tmp = NONE;
}
if (!state->SW) { // Trzymanie przycisku.
++pushTime;
}
return tmp;
}
#endif
// Callback do odczytu stanu enkodera.
encState_t (*_encState)(void);
// Rejestracja powyższej funkcji.
void regEncState(encState_t (*callback)(void)) {
_encState = callback;
}
// Callback wywoływany w przypadku wystąpienia zdarzenia enkodera.
void (*_encEvent)(encEvent_t const event);
// Rejestracja powyższej funkcji.
void regEncAction(void (*callback)(encEvent_t const event)) {
_encEvent = callback;
}
// Funkcja obsługi enkodera wywoływana w przerwaniu timera.
void encPool(void) {
encState_t state; // Odczytany stan enkodera.
encEvent_t event; // Zdarzenie enkodera.
if (_encState) {
state = (*_encState)(); // Pobierz aktualny status enkodera.
}
// Sprawdzenie czy enkoder nie został obrócony.
event.rotate = readEncRotate(&state);
#ifdef ENC_BUTTON
// Sprawdzenie stanu przycisku.
event.button = readEncButton(&state);
#endif
// Wywołujemy callback tylko przy jakimś zdarzeniu.
if (
#ifdef ENC_BUTTON
(event.button != NONE) ||
#endif
(event.rotate != STOP)) {
if (_encEvent) {
(*_encEvent)(event);
}
}
}[/syntax]
Przykład znów dla Atmega2560.
main.h:
[syntax=c]/*
* main.h
*
* Created on: 1 maj 2015
* Author: Piotr Rudzki ryba.lodz@gmail.com
*/
#ifndef MAIN_H_
#define MAIN_H_
#include <avr/io.h>
#include <avr/interrupt.h>
#include "encoder.h"
#define ENKODER_DDR DDRB
#define ENKODER_PIN PINB
#define ENKODER_PORT PORTB
#define ENKODER_A (1 << PB4)
#define ENKODER_B (1 << PB5)
#define ENKODER_SW (1 << PB6)
#endif /* MAIN_H_ */[/syntax]
main.c:[syntax=c]/*
* main.c
*
* Created on: 1 maj 2015
* Author: Piotr Rudzki ryba.lodz@gmail.com
*/
#include "main.h"
// Inicjalizacja enkodera.
static inline void encoderInit() {
ENKODER_DDR &= ~(ENKODER_A | ENKODER_B | ENKODER_SW); // Piny enkodera jako wejście.
ENKODER_PORT |= ENKODER_A | ENKODER_B | ENKODER_SW; // Wewnętrzne pullupy.
}
// Inicjalizacja timera dla Atmegi2560.
static inline void timerInit() {
// Timer1 tryb CTC przerwanie COMPA co 1ms do obsługi enkodera.
TCCR1A = 0;
OCR1A = 249;
TCCR1B = (1 << WGM12) | (1 << CS11) | (1 << CS10);
TCCR1C = 0;
TIMSK1 = (1 << OCIE1A);
// Timer0 dla wizualizacji pracy enkodera. Dioda na pinie PB7;
DDRB |= (1 << PB7);
TCCR0A = (1 << COM0A1) | (1 << WGM00);
TCCR0B = (1 << CS02) | (1 << CS00);
OCR0A = 0;
}
// Odczyt stanu enkodera.
encState_t readEncoder() {
encState_t tmp;
if (ENKODER_PIN & ENKODER_A) { // Stan na pinie A
tmp.A = 1;
} else {
tmp.A = 0;
}
if (ENKODER_PIN & ENKODER_B) { // Stan na pinie B
tmp.B = 1;
} else {
tmp.B = 0;
}
if (ENKODER_PIN & ENKODER_SW) { // Jeśli przycisk nie wciśnięty stan wysoki.
tmp.SW = 1; // Przycisk nie wciśnięty.
} else {
tmp.SW = 0; // Przycisk wciśnięty.
}
return tmp;
}
// Obsługa zdarzeń z enkodera. Jako argument ma przyjmować zmienną typu encEvent_t.
void encoderEvent(encEvent_t const event) {
char liczba[4];
switch (event.rotate) {
case CW: // Ruch w kierunku wskazówek zegara.
OCR0A++;
break;
case CCW: // Ruch w przeciwnym kierunku do wskazówek zegara.
OCR0A--;
break;
default:
break;
}
switch (event.button) {
case SHORT: // Krótkie wciśnięcie przycisku.
OCR0A = 0;
break;
case LONG: // Dłuższe wciśnięcie przycisku.
OCR0A = 127;
break;
case VERY_LONG: // Bardzo długie wciśnięcie przycisku.
OCR0A = 255;
break;
default:
break;
}
}
// Główny program.
int main(void) {
// Rejestracja używanych callbacków.
regEncState(readEncoder); // Rejestracja funkcji odczytujące stan enkodera.
regEncAction(encoderEvent); // Rejestracja funkcji wywoływanej podczas jakiegoś zdarzenia enkodera.
// Inicjalizacja peryferii.
encoderInit(); // Inicjalizacja pinów enkodera.
timerInit(); // Inicjalizacja timerów.
sei(); // Start przerwań.
while (1) {
// Hmmm. Pętla główna pusta, a program działa ;)
}
}
// Przerwanie timera wywoływane co 1ms nieblokujące innych przerwań. Wywołujemy w nim odczyt stanu enkodera.
ISR(TIMER1_COMPA_vect, ISR_NOBLOCK) {
encPool();
}[/syntax]
Timer wywołuje przerwanie co 1 ms dla F_CPU 16000000UL. Dla innego zegara MCU trzeba policzyć na nowo.
Proszę o niekopiowanie kodu w innych miejscach bez mojej zgody. Kod udostępniam do użytku niekomercyjnego.
Jak ktoś ma uwagi z chęcią się zastosuję do nich.
EDYTA1:
Zmiany w kodzie:- Dodałem możliwość wyłączenia obsługi przycisku przez bibliotekę.
- Dodałem obsługę podzielnika impulsów enkodera. Moje wszystkie enkodery pomiędzy stabilnymi pozycjami dają po 4 impulsy.
- Podzieliłem funkcję encPool na kilka aby poprawić czytelność kodu.
EDYTA2:
Kolejne zmiany w kodzie:- Poprawiłem funkcje odczytu kierunku obrotu enkodera (działała odwrotnie, bo miałem odwrotnie podłączony enkoder).
- Dodano więcej komentarzy w kodzie.
- Trochę optymalizacji w celu zmniejszenia kodu wynikowego - każdy bajt w AVR się liczy
- Zmiana działania bardzo długiego wciśnięcia przycisku - teraz reaguje dopiero po puszczeniu.
- Bardziej restrykcyjne przekazywanie zmiennych do funkcji (również callback). Dodałem const wszędzie gdzie funkcja nie powinna zmieniać wartości ani wskaźnika.
- Małe zmiany w kodzie w main.c.
Statystyki: Napisane przez ryba84 — 1 maja 2015, o 21:37
]]>
.