Jedna sprawa mnie troszkę zastanawia, bo zmierzyłem bezpośrednio na enkod. kanał A i B bez optoizolacji, to mam napięcia ok 21V. A jak podłączę już optotranzystory przez opornik to na jednym z wyjść enkodera jest 21V a na drugim 17V. Ale już na samym opto jest tak jak wcześniej pisałem 1,2V na obu.
------------------------ [ Dodano po: 8 minutach ]
main.h
[syntax=c]#include <avr/io.h>// dołączenie głównego systemowego pliku nagłówkowego
#include <avr/interrupt.h>
#include <util/delay.h>
#include "d_led.h"// dołączenie naszego pliku nagłówkowego (obsługa LED)
#include "MK_ENCODER/mk_encoder.h" // dołączona obsługa encodera
void my_encoder( int8_t dir, int8_t w ); // własne funkcje do zarejestrowania
uint32_t wynik; // wartość zliczana przez enkoder
int main(void)
{
encoder_init(1);
register_enc_callback( my_encoder );
// ****** inicjalizacja *********
d_led_init(); // inicjalizacja wyświetlacza multipleksowanego
// testowa inicjalizacja zmiennych oraz liczb mających się wyświetlać na wyrw. LED
cy1=1;
cy2=1;
cy3=1;
cy4=1;
sei();// włączenie globalnego zezwolenia na przerwania
//uint16_t licznik=1000;
uint8_t d1,d2,d3,d4;
//********************** pętla główna ****************************//
while(1)
{
ENCODER_EVENT( 1 );
d1=wynik/1000;
if(d1) cy4=d1; else cy4=NIC;
d2=(wynik-(d1*1000))/100;
if(d2) cy3=d2; else cy3=(wynik>999)?0:NIC;
d3=(wynik-(d1*1000)-(d2*100))/10;
if(d3) cy2=d3; else cy2=(wynik>99)?0:NIC;
d4=(wynik-(d1*1000)-(d2*100)-(d3*10));
cy1=d4;
_delay_ms(10);
//if(licznik>9999) licznik=0;
//if(!licznik) licznik=6000;
}
}
void my_encoder( int8_t dir, int8_t w ) {
wynik += w;
}[/syntax]
mk_enkoder.c
[syntax=c]#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/interrupt.h>
#include "mk_encoder.h"
volatile int8_t ed;
volatile int8_t enc_cnt;
volatile uint8_t enc_flag;
//const int8_t table[16] PROGMEM = {0,1,-1,0,-1,0,0,1,1,0,0,-1,0,-1,1,0};
const int8_t table[16] PROGMEM = {0,1,-1,0,-1,0,0,1,1,0,0,-1,0,-1,1,0};
// obsługa enkodera
void (*enc_callback)( int8_t dir, int8_t cnt );
void register_enc_callback( void (*callback)( int8_t dir, int8_t cnt ) ) {
enc_callback = callback;
}
// obsługa klawisza
void (*sw_callback)( void );
void register_sw_callback( void (*callback)( void ) ) {
sw_callback = callback;
}
void encoder_init( uint8_t on_off ) {
/*if( !on_off ) {
#if TIMER == 0
TCCR0 &= ~((1<<CS01)|(1<<CS00)); // stop timer0
TIMSK &= ~(1<<OCIE0);// disable interrupt
#endif
#if TIMER == 2
TCCR2 &= ~(1<<CS22); // stop timer2
TIMSK &= ~(1<<OCIE2);// disable interrupt
#endif
return;
}*/
PIN(ENC_PORT) &= ~(ENC_PH_A|ENC_PH_B);
PORT(ENC_PORT) |= ENC_PH_A|ENC_PH_B;
PIN(ENC_SWPORT) &= ~ENC_SW;
PORT(ENC_SWPORT) |= ENC_SW;
#if TIMER == 0
TCCR0 = (1<<WGM01);// tryb CTC
TCCR0 |= (1<<CS01)|(1<<CS00); // prescaler 64
OCR0 = (uint8_t)(F_CPU / 64 / 1000 ); // 1ms --> poprawka do VIDEO
TIMSK |= (1<<OCIE0);
#endif
#if TIMER == 2
TCCR1A = (1<<WGM10);// tryb CTC
TCCR1B = (1<<WGM12);// tryb CTC
TCCR1B |= (1<<CS11)|(1<<CS10); // prescaler 64
OCR1AL = (uint8_t)(F_CPU / 8 / 1000 ); // 1ms --> poprawka do VIDEO
TIMSK |= (1<<OCIE1A);
#endif
}
void ENCODER_EVENT( int8_t res ) {
uint8_t sreg;
int8_t ecnt;
static uint8_t key_lock;
// obsługa zdarzeia enkodera
if( enc_callback && enc_flag ) {
sreg = SREG;
cli();
ecnt = ed>>2; ed &= 3;
SREG = sreg;// sei()
if(ecnt>1) ecnt=1;
if(ecnt<-1) ecnt=-1;
if(!res) res=1;
if(ecnt) enc_callback( ecnt*-1, ecnt*res );
enc_flag=0;
}
// obsługa zdarzenia przycisku
if( sw_callback ) {
if( !key_lock && !(PIN(ENC_SWPORT) & ENC_SW) ) {
key_lock=1;
// reakcja na wcinięcie klawisza
sw_callback();
}
else if( key_lock && (PIN(ENC_SWPORT) & ENC_SW ) ) {
if( !++key_lock ) {
// ewentualnie reakcja na zwolnienie klawisza ;)
//sw_callback();
}
}
}
}
// Przerwanie timera co 1 ms
ISR( ENCODER_vect , ISR_NOBLOCK ) {
static int8_t last;
static int8_t last_ed;
last = (last << 2) & 0x0F;
if (PHASE_A) last |=2;
if (PHASE_B) last |=1;
ed += pgm_read_byte( &table[last] );
if( last_ed != ed ) enc_flag=1;
last_ed=ed;
}[/syntax]
d_led.c
[syntax=c]#include <avr/io.h>// dołączenie głównego systemowego pliku nagłówkowego
#include <avr/interrupt.h>// dołączenie pl. nagłówkowego potrzebnego do obsł. przerwań
#include <avr/pgmspace.h>// dołączenie pl. nagłówkowego potrzebnego do odczytu
// danych zawartych w pamięci programu FLASH
#include "d_led.h"// dołączenie naszego pliku nagłówkowego
// w nim znajdują się potrzebne tu m.in. definicje preprocesora
// definicje zmiennych globalnych przechowujących cyfry do wyświetlania
// volatile – ponieważ będą wykorzystywane do odczytu i zapisu zarówno w przerwaniu i programie
// głównym. Trzeba więc wyłączyć optymalizację dostępu do nich. (zmienne ulotne)
volatile uint8_t cy1;
volatile uint8_t cy2;
volatile uint8_t cy3;
volatile uint8_t cy4;
// definicja tablicy zawierającej definicje bitowe cyfr LED
const uint8_t cyfry[15] PROGMEM = {
~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_E|SEG_F),// 0
~(SEG_B|SEG_C),// 1
~(SEG_A|SEG_B|SEG_D|SEG_E|SEG_G),// 2
~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_G),// 3
~(SEG_B|SEG_C|SEG_F|SEG_G),// 4
~(SEG_A|SEG_C|SEG_D|SEG_F|SEG_G),// 5
~(SEG_A|SEG_C|SEG_D|SEG_E|SEG_F|SEG_G),// 6
~(SEG_A|SEG_B|SEG_C|SEG_F),// 7
~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_E|SEG_F|SEG_G),// 8
~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_F|SEG_G),// 9
0xFF,// NIC (puste miejsce)
};
// ****** definicja funkcji inicjalizującej pracę z wyświetlaczem multipleksowanym
void d_led_init(void)
{
LED_DATA_DIR = 0xFF; // wszystkie piny portu D jako WYJŚCIA(katody)
LED_DATA = 0xFF;// wygaszenie wszystkich katod – stan wysoki
ANODY_DIR |= CA1 | CA2 | CA3 | CA4;// 4 piny portu B jako WYJŚCIA (anody wyświetlaczy)
ANODY_PORT |= CA1 | CA2 | CA3 | CA4;// wygaszenie wszystkich wyświetlaczy - anody
// ustawienie TIMER0
TCCR0A |= (1<<WGM01);// tryb CTC
TCCR0B |= (1<<CS02)|(1<<CS00);// preskaler = 1024
OCR0A = 38;// dodatkowy podział przez 39 (rej. przepełnienia)
TIMSK |= (1<<OCIE0A);// zezwolenie na przerwanie CompareMatch
}
// ================= PROCEDURA OBSŁUGI PRZERWANIA – COMPARE MATCH
ISR(TIMER0_COMPA_vect)
{
static uint8_t licznik=1;// zmienna do przełączania kolejno anod wyrwietlacza
ANODY_PORT = (ANODY_PORT & 0xFF);// wygaszenie wszystkich wyświetlaczy
if(licznik==1) LED_DATA = pgm_read_byte( &cyfry[cy1] );// gdy zapalony wyśw.1 podaj stan zmiennej c1
else if(licznik==2) LED_DATA = pgm_read_byte( &cyfry[cy2] );// gdy zapalony wyśw.2 podaj stan zmiennej c2
else if(licznik==4) LED_DATA = pgm_read_byte( &cyfry[cy3] );// gdy zapalony wyśw.3 podaj stan zmiennej c3
else if(licznik==8) LED_DATA = pgm_read_byte( &cyfry[cy4] );// gdy zapalony wyśw.4 podaj stan zmiennej c4
ANODY_PORT = (ANODY_PORT & 0xF0) | (licznik & 0x0F);// cykliczne przełączanie kolejnej anody w każdym przerwaniu
// operacje cyklicznego przesuwania bitu zapalającego anody w zmiennej licznik
licznik <<= 1;// przesunięcie zawartości bitów licznika o 1 w lewo
if(licznik>8) licznik = 1;// jeśli licznik większy niż 8 to ustaw na 1
}[/syntax]
Proszę o wyrozumiałość co do kodu, nie umiem jeszcze programować tak jak wy i posługuję się kodem P. Mirka.
Sklejam składam i przerabiam jak umiem i rozumiem.
Być może gdzieś coś źle zrobiłem, zakomentowałem te części kodu których nie potrzebowałem.
Jest możliwe że oba timery sobie przeszkadzają?Statystyki: Napisane przez Meloseb — 6 sty 2015, o 21:41
]]>
(wcale nie mówię, że teraz już wiem i piszę piękne programy).
