ATNEL tech-forum 2014-03-26T08:56:58+01:00 https://forum.atnel.pl/feed.php?f=22&t=6481&mode 2014-03-26T08:56:58+01:00 2014-03-26T08:56:58+01:00 https://forum.atnel.pl/viewtopic.php?t=6481&p=75827#p75827 <![CDATA[Re: True bypass looper]]> Co do schematu to nie mam rozrysowanego (zrobię go w wolnej chwili)
generalnie nic nadzwyczajnego: cały PORTD podłączony do 8 diod LED,
PORTC podłączony do segmentów wyświetlacza, PORTA linie 4,5,6,7 anody wyswietlacza
i enkoder na PORTB piny 0,1 - obracanie, pin 2 - klawisz.

main.c
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>

#include "mux.h"
#include "MK_ENCODER/mk_encoder.h"


//wlasne funkcje do zarejestrowania
void my_encoder( int8_t dir, int8_t w );
void enc_switch( void );

uint8_t speed;// rozdzielczosc zliczania enkodera
volatile uint32_t wynik;// wartosc zliczana przez enkoder
volatile uint8_t bank;//zmienna testowa

int main(void)
{
encoder_init(1);//init encoder
register_enc_callback( my_encoder );
register_sw_callback( enc_switch );
mux_init();//init multiplexowania
rel_init();//init port z relays

sei();//globalne zezwolenie na przerwania

//inicjlizacja testowa wyswietlacza wartosciami
cyfra[0].val = P;
cyfra[0].blink = FALSE;
cyfra[0].delay = 50;
cyfra[0].dp = TRUE;
cyfra[1].val = 0;
cyfra[1].blink = FALSE;
cyfra[1].delay = 200;
cyfra[2].delay = 150;
cyfra[2].blink = FALSE;
//cyfra[2].val = 1;
cyfra[2].power = TRUE;
cyfra[2].dp = TRUE;
cyfra[2].dp_delay = 200;
cyfra[2].dp_blink = FALSE;
cyfra[3].blink = TRUE;
cyfra[3].delay = 30;
cyfra[3].val = 4;

//petla gloowna programu
while (1)
{
ENCODER_EVENT( speed );
}//koniec petli glownej
}//koniex funkcji main()


void my_encoder( int8_t dir, int8_t w )
{

//cyfra[1].val = w;
if(dir==-1)
{
cyfra[0].val = P;
cyfra[2].val = bank;
if(bank >= 9)
{
bank =0;
}
bank += 1;
}
else
{
cyfra[0].val = L;
bank -= 1;
cyfra[2].val = bank;
if(bank == 0)
{
bank =10;
}
}
}

void enc_switch( void )
{
REL_PORT ^= REL4;
}[/syntax]

mux.h
[syntax=c]#ifndef MUX_H_
#define MUX_H_

//makra dla wyświetlacza 7 segmentowego
#define LED_PORT PORTC
#define DIG_PORT PORTA
#define LED_DIR DDRC
#define DIG_DIR DDRA
//definicje pinow klawiszy: kierunek, port
#define KEYS_DIR DDRB
#define KEYS_PORT PORTB

#define KEY_PIN4 (1<<PB4)
#define KEY_DOWN4 !(PINB & KEY_PIN4)
#define KEY_PIN5 (1<<PB5)
#define KEY_DOWN5 !(PINB & KEY_PIN5)
#define KEY_PIN6 (1<<PB6)
#define KEY_DOWN6 !(PINB & KEY_PIN6)
#define KEY_PIN7 (1<<PB7)
#define KEY_DOWN7 !(PINB & KEY_PIN7)
//definicja RELAYS
#define REL_PORT PORTD
#define REL_DIR DDRD
#define REL1 (1<<0)
#define REL2 (1<<1)
#define REL3 (1<<2)
#define REL4 (1<<3)
#define REL5 (1<<4)
#define REL6 (1<<5)
#define REL7 (1<<6)
#define REL8 (1<<7)
//definicja segmentow wyswietlacza
#define SEG_A (1<<0)
#define SEG_B (1<<1)
#define SEG_C (1<<2)
#define SEG_D (1<<3)
#define SEG_E (1<<4)
#define SEG_F (1<<5)
#define SEG_G (1<<6)
#define SEG_DP (1<<7)
//definicja makr katod wyswietlacza
#define DIG0 (1<<4)
#define DIG1 (1<<5)
#define DIG2 (1<<6)
#define DIG3 (1<<7)
//definicja makr znakow
#define E 10
#define d 11
#define U 12
#define P 13
#define A 14
#define H 15
#define L 16
#define b 17
#define o 18

//bool
#define TRUE 1
#define FALSE 0
//typ złożony do sterowania cyframi
typedef struct
{
volatile uint8_t power; //TRUE or FALSE
volatile uint8_t val; //value to display
volatile uint8_t blink; //TRUE or FALSE
volatile uint8_t delay; //blink delay. 200 = 1 second
volatile uint8_t dp; //TRUE or FALSE
volatile uint8_t dp_delay; //200 = 1 second
volatile uint8_t dp_blink; //TRUE or FALSE - czy punkt ma migac
} Tdigit;

extern Tdigit cyfra[4];

//deklaracje funkcji bibliotecznych
void mux_init(void);
void relays_init(void);

#endif /* MUX_H_ */[/syntax]

mux.c
[syntax=c]#include<avr/io.h>
#include<avr/interrupt.h>
#include<avr/pgmspace.h>
#include"mux.h"

#define TIM_DIV F_CPU/1024/200

Tdigit cyfra[4];

const uint8_t tab[] PROGMEM =
{
(uint8_t) ~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_E|SEG_F), //0
(uint8_t) ~(SEG_B|SEG_C), //1
(uint8_t) ~(SEG_A|SEG_B|SEG_D|SEG_E|SEG_G), //2
(uint8_t) ~(SEG_A|SEG_B|SEG_C|SEG_D |SEG_G), //3
(uint8_t) ~(SEG_B|SEG_C|SEG_F|SEG_G), //4
(uint8_t) ~(SEG_A|SEG_C|SEG_D|SEG_F|SEG_G), //5
(uint8_t) ~(SEG_A|SEG_C|SEG_D|SEG_E|SEG_F|SEG_G), //6
(uint8_t) ~(SEG_A|SEG_B|SEG_C), //7
(uint8_t) ~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_E|SEG_F|SEG_G), //8
(uint8_t) ~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_F|SEG_G), //9
(uint8_t) ~(SEG_A|SEG_D|SEG_E|SEG_F|SEG_G), //litera E
(uint8_t) ~(SEG_B|SEG_C|SEG_D|SEG_E|SEG_G), //litera d
(uint8_t) ~(SEG_B|SEG_C|SEG_D|SEG_E|SEG_F), //litera U
(uint8_t) ~(SEG_A|SEG_B|SEG_E|SEG_F|SEG_G), //litera P
(uint8_t) ~(SEG_A|SEG_B|SEG_C|SEG_E|SEG_F|SEG_G), //litera A
(uint8_t) ~(SEG_B|SEG_C|SEG_E|SEG_F|SEG_G), //litera H
(uint8_t) ~(SEG_D|SEG_E|SEG_F), //litera L
(uint8_t) ~(SEG_C|SEG_D|SEG_E|SEG_F|SEG_G), //litera b
(uint8_t) ~(SEG_C|SEG_D|SEG_E|SEG_G) //litera o
};

void mux_init(void)
{
//inicjalizacja Timer0
OCR0 = TIM_DIV;
TCCR0 |= (1 << WGM01) | (1 << CS02) | (1 << CS00);
TIMSK |= (1 << OCIE0);
//pinologia
LED_DIR |= (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G | SEG_DP);
LED_PORT |= (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G | SEG_DP);
DIG_DIR |= (DIG0 | DIG1 | DIG2 | DIG3);
DIG_PORT |= (DIG0 | DIG1 | DIG2 | DIG3);

//inicjalizacja wyswietlacza zerami
for (uint8_t i = 0; i < 4; i++)
{
cyfra[i].power = TRUE;
cyfra[i].val = 0;
cyfra[i].blink = FALSE;
cyfra[i].delay = 0;
cyfra[i].dp = FALSE;
}
}
//inicjalizacja portu dla relays
void relays_init(void)
{
REL_DIR |= REL1|REL2|REL3|REL4|REL5|REL6|REL7|REL8;//port jako wyjscie
REL_PORT |= REL1|REL2|REL3|REL4|REL5|REL6|REL7|REL8;//stan wysoki
}
//przerwanie od przepelnienia Timer'a 0
ISR(TIMER0_COMP_vect)
{
static uint8_t cnt, flag_reg = 0b00011111, timer[5];
static uint8_t cnt_digit;//zmienna pomocnicza - multiplexowanie

//timery programowe
if (timer[0]) timer[0]--;
if (timer[1]) timer[1]--;
if (timer[2]) timer[2]--;
if (timer[3]) timer[3]--;
if (timer[4]) timer[4]--;//timer dla decimal point na trzecim znaku
//blok timerow programowych
if (!timer[0])
{
flag_reg ^= (1 << 0);
timer[0] = cyfra[0].delay;
}
if (!timer[1])
{
flag_reg ^= (1 << 1);
timer[1] = cyfra[1].delay;
}
if (!timer[2])
{
flag_reg ^= (1 << 2);
timer[2] = cyfra[2].delay;
}
if (!timer[3])
{
flag_reg ^= (1 << 3);
timer[3] = cyfra[3].delay;
}
//timer pod miganie decimal point na trzeciej cyfrze
if (!timer[4])
{
if(cyfra[2].dp_blink)
{
flag_reg ^= (1 << 4);
}
timer[4] = cyfra[2].dp_delay;
}

if (cyfra[cnt].blink == FALSE) flag_reg |= (1 << cnt);

//multiplex
DIG_PORT |= (DIG0 | DIG1 | DIG2 | DIG3);

if ((cyfra[cnt].power == TRUE) && (flag_reg & (1 << cnt)))
{
LED_PORT = pgm_read_byte(&tab[cyfra[cnt].val]);
if((cyfra[2].dp == TRUE) && (flag_reg & (1 << 4)) && cnt==2)
LED_PORT &= ~SEG_DP;
}
else
{
LED_PORT = 255;
}
//sterowanie zmienna odpowiedzialna za zalaczanie danej katody
switch (cnt)
{
case 0: cnt_digit=7;
break;
case 1: cnt_digit=6;
break;
case 2: cnt_digit=5;
break;
case 3: cnt_digit=4;
break;
}
//multiplexowanie
DIG_PORT = (DIG_PORT & ~(DIG0|DIG1|DIG2|DIG3))|(~(1<<cnt_digit) & 0xf0);
if (++cnt > 3) cnt = 0;
}[/syntax]

mk_encoder.h
[syntax=c]#ifndef MK_ENCODER_H_
#define MK_ENCODER_H_

// definicja pinów enkodera
#define ENC_PH_A (1<<PB0)
#define ENC_PH_B (1<<PB1)
#define ENC_PORT B

// definicja pinu przycisku enkodera
#define ENC_SW(1<<PB2)
#define ENC_SWPORTB

//-----------------------------------

// wybór timera 0 lub 2
#define TIMER2
//-----------------------------------


#define PHASE_A (PIN(ENC_PORT) & ENC_PH_A)
#define PHASE_B (PIN(ENC_PORT) & ENC_PH_B)

#if TIMER == 0
#define ENCODER_vect TIMER0_COMP_vect
#endif

#if TIMER == 2
#define ENCODER_vect TIMER2_COMP_vect
#endif


// Makra upraszczajace dostep do portów
// *** PORT
#define PORT(x) SPORT(x)
#define SPORT(x) (PORT##x)
// *** PIN
#define PIN(x) SPIN(x)
#define SPIN(x) (PIN##x)
// *** DDR
#define DDR(x) SDDR(x)
#define SDDR(x) (DDR##x)

void register_enc_callback( void (*callback)( int8_t dir, int8_t cnt ) );
void register_sw_callback( void (*callback)( void ) );
void encoder_init( uint8_t on_off );
void ENCODER_EVENT( int8_t res );

#endif /* MK_ENCODER_H_ */[/syntax]

mk_encoder.c
[syntax=c]#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/interrupt.h>
#include <util/atomic.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};

// obsluga 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;
}

// obsluga klawisza
void (*sw_callback)( void );

void register_sw_callback( void (*callback)( void ) ) {
sw_callback = callback;
}
//init enkodera
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
TCCR2 = (1<<WGM21);// tryb CTC
TCCR2 |= (1<<CS22); // prescaler 64
OCR2 = (uint8_t)(F_CPU / 64 / 1000 ); // 1ms --> poprawka do VIDEO
TIMSK |= (1<<OCIE2);
#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;
}

// obsluga 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]

Statystyki: Napisane przez schizwania — 26 mar 2014, o 08:56

]]> 2014-03-25T21:35:51+01:00 2014-03-25T21:35:51+01:00 https://forum.atnel.pl/viewtopic.php?t=6481&p=75769#p75769 <![CDATA[Re: True bypass looper]]> Trudno się odnieść do takiego schematu i takiego programu jaki przedstawiłeś na tut. forum.
Z całym szacunkiem, ale spróbuj postawić się na miejscu czytającego Twój post i zapominając co Ty wiesz na temat tego urządzenia z samego schematu i programu rozszyfrować o co tu chodzi.
Schemat - moduły z płytki startowej, program - #define i ustawienie portu.
Jeśli to nie jest "wersja komercyjna" to może zamieść chociaż więcej kodu i schemat z "podpiętym" uC.

Pozdr.

Statystyki: Napisane przez kicajek — 25 mar 2014, o 21:35

]]> 2014-03-24T23:09:51+01:00 2014-03-24T23:09:51+01:00 https://forum.atnel.pl/viewtopic.php?t=6481&p=75652#p75652 <![CDATA[True bypass looper]]> Aresaudio. Jestem na etapie "składania" do kupy oprogramowania.
Do projektu pozwoliłem sobie zaadoptować pomysł kolegi Antystatycznego na wyświetlacz 7segmentowy oraz bibliotekę Mirka pod enkoder. Pojawił się mały problem którego nie potrafię rozgryźć. Podczas pracy enkodera (obracanie) zostaje "wyzwolona" obsługa przycisku (którego nie wciskam) - na filmie
iframe
sygnalizowana przez przypadkowo zapalaną zieloną diodę. Generalnie PORTD (port ledów/przekaźników) ustawiłem jako wyjście, ustawiłem stan niski na PORCIE (zgaszenie diod):
[syntax=c]#define REL_PORT PORTD
#define REL_DIR DDRD
#define REL1 (1<<0)
#define REL2 (1<<1)
#define REL3 (1<<2)
#define REL4 (1<<3)
#define REL5 (1<<4)
#define REL6 (1<<5)
#define REL7 (1<<6)
#define REL8 (1<<7)[/syntax]
inicjalizacja:
[syntax=c]void relays_init(void)
{
REL_DIR |= REL1|REL2|REL3|REL4|REL5|REL6|REL7|REL8;//port jako wyjscie
REL_PORT |= REL1|REL2|REL3|REL4|REL5|REL6|REL7|REL8;//stan wysoki
}[/syntax]

a funkcja obsługi klawisza enkodera wygląda tak:
[syntax=c]void enc_switch( void )
{
REL_PORT ^= REL4;
}[/syntax]
taktowanie procesora to 16Mhz. Nie ma zwarć i innych kiksów na płytce, układ enkodera jak na schemacie Ktoś ma jakąś wskazówkę bo lekko "zgłupłem" :) .W sumie to moje pierwsze kroczki w programowaniu uC coś może przeoczyłem ? Oczywiście przy naciskaniu klawisza enkodera dioda zmienia swój stan poprawnie.

Statystyki: Napisane przez schizwania — 24 mar 2014, o 23:09

]]>