ATNEL tech-forum 2012-08-01T11:33:40+01:00 https://forum.atnel.pl/feed.php?f=4&t=1338&mode 2012-08-01T11:33:40+01:00 2012-08-01T11:33:40+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=11452#p11452 <![CDATA[Re: UART]]> arko_go napisał(a):

BTW - kiedy rusza szkolenie online?


Oj na to to nie jestem na razie w stanie odpowiedzieć.

Statystyki: Napisane przez mirekk36 — 1 sie 2012, o 11:33

]]> 2012-08-01T11:25:22+01:00 2012-08-01T11:25:22+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=11450#p11450 <![CDATA[Re: UART]]> A następny razem jak będę potrzebował coś na szybcika to na pewno zapodam temat do działu rybnego:)

BTW - kiedy rusza szkolenie online?

Statystyki: Napisane przez developer85 — 1 sie 2012, o 11:25

]]> 2012-07-31T22:43:37+01:00 2012-07-31T22:43:37+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=11430#p11430 <![CDATA[Re: UART]]> mirekk36 napisał(a):

Np kolega Malutki_27 jest normalnie na razie naszym mistrzem "rybołóstwa" czyli tak na prawdę szaleje jeśli chodzi o rozdawanie ryb, ale ile sam na tym korzysta ;)



Hmmm, ja tam nic o tym nie wiem :roll: , ale muszę przyznać że to bardzo fajna zabawa takie łowienie rybek i musze przyznać że daje bardzo dużo satysfakcji :D


@arko_go Dawaj co tam masz, nawet jak nie będziesz chciał wykorzystać kodów proponowanych w RYBNYM , to przynajmniej będziesz miał unikatową mozliwość poznania np innego sposobu podejścia do tego samego problemu, a to juz jest bezcenne, wręcz porównywalne z przykładem dobrze opisanego kodu ;)

Statystyki: Napisane przez Malutki_27 — 31 lip 2012, o 22:43

]]> 2012-07-31T17:39:16+01:00 2012-07-31T17:39:16+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=11404#p11404 <![CDATA[Re: UART]]> arko_go napisał(a):

Dzięki za podpowiedzi. Nigdy nie pisałem, że potrzebuje gotowca,


Tak ale nie urażaj się za tą propozycję, bo zobacz że na naszym forum wymyśliliśmy tu niejako wspólnie w pewnej dyskusji w jednym z wątków taką formułę , która pozwala nie to że dostać gotowca - ale za to osoby chętne się pouczyć na prawdziwych zadaniach - a Ty takie masz - mogą popróbować swoich sił - i już nawet teraz jakbyś tam zajrzał wychodzą fajne rzeczy.... Np kolega Malutki_27 jest normalnie na razie naszym mistrzem "rybołóstwa" czyli tak na prawdę szaleje jeśli chodzi o rozdawanie ryb, ale ile sam na tym korzysta ;) .... więc na przyszłość pamiętaj o tym bo wyszła z tego fajna rzecz.

Statystyki: Napisane przez mirekk36 — 31 lip 2012, o 17:39

]]> 2012-07-31T17:34:01+01:00 2012-07-31T17:34:01+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=11403#p11403 <![CDATA[Re: UART]]> Rozwiązania doszedłem już sam:)
Dzięki za podpowiedzi. Nigdy nie pisałem, że potrzebuje gotowca, tylko pytałem bardziej doświadczonych kolegów o pomoc i wskazówki.

Pozdrawiam

Statystyki: Napisane przez developer85 — 31 lip 2012, o 17:34

]]> 2012-07-31T13:49:06+01:00 2012-07-31T13:49:06+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=11382#p11382 <![CDATA[Re: UART]]> po to jest ten nasz dziwny dział ;)

Statystyki: Napisane przez mirekk36 — 31 lip 2012, o 13:49

]]> 2012-07-31T11:17:17+01:00 2012-07-31T11:17:17+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=11366#p11366 <![CDATA[Re: UART]]> To że mam funkcje _delay wsadzone w while() to na razie nie istotne. Chodzi głównie czego Uart psuje wszystko.
[syntax=c]/*
* main.c
*
* Created on: 2012-07-31
* Autor: Arkadiusz Golec
*/


#include <avr/io.h>
#include <util/delay.h>
//#include "LCD/lcd44780.h"
#include <avr/interrupt.h>

#include "MKUART/mkuart.h"

/* przydatne definicje pinów sterujących */
#define WE_A PD1 // piny sterujące L293DNE
#define WE_B PD0
#define KEY1 (1<<PB0) //def klawisz 1
#define KEY2 (1<<PB1) //def klawisza 2
#define KEY_DOWN1 !(PINB & KEY1) //sprawdzanie stanu niskiego na KEY1
#define KEY_DOWN2 !(PINB & KEY2) //sprawdzanie stanu niskiego na KEY2
/* definicje poleceń sterujących pracą silnika */
#define DC_LEWO PORTD &= ~(1<<WE_A); PORTD |= (1<<WE_B) // obrót prawo
#define DC_PRAWO PORTD |= (1<<WE_A); PORTD &= ~(1<<WE_B)// obrót lewo
#define DC_STOP PORTD &= ~(1<<WE_A); PORTD &= ~(1<<WE_B)//stop

// definicja pinów enkodera
#define PHASE_A (PINA & 1<<PA1) // piny enkodera Channel A
#define PHASE_B (PINA & 1<<PA2)//piny enkodera Channel B
#define LED_PIN (1<<PD7) //diodka
#define LED_ON PORTD |= LED_PIN;

volatile int8_t enc_delta; // -128 ... 127
static int8_t last;


//PWM
volatile uint8_t pwm1;

uint16_t pomiar(uint8_t kanal);

void encode_init( void )
{
int8_t new;

new = 0;
if( PHASE_A ==0)
new = 3;
if( PHASE_B ==0)
new ^= 1;
last = new;
enc_delta = 0;
TCCR2 |= (1<<WGM21); // CTC
TCCR2 |= (1<<CS22)|(1<<CS21)|(1<<CS20); //1024 //(1<<CS22); //64
OCR2 = 18;
TIMSK |= (1<<OCIE2);
}


ISR( TIMER2_COMP_vect)
{
int8_t new, diff;
new = 0;
if( PHASE_A ==0)
new = 3;
if( PHASE_B ==0)
new ^= 1; // konwersja do binarki
diff = last - new;
if( diff & 1 ){ // bit 0 = value (1)
last = new; // zapamiętanie nowej wartości w next last
enc_delta += (diff & 2) - 1; // bit 1 = direction (+/-)
}


}

int8_t encode_read1( void ) // odczyt co krok
{
int8_t val;

cli();
val = enc_delta;
enc_delta = 0;
sei();
return val;
}


int8_t encode_read2( void ) // odczyt co 2 kroki
{
int8_t val;

cli();
val = enc_delta;
enc_delta = val & 1;
sei();
return val >> 1;
}


int8_t encode_read4( void ) // odczyt co 4 kroki
{
int8_t val;

cli();
val = enc_delta;
enc_delta = val & 3;
sei();
return val >> 2;
}

int8_t encode_read8( void ) // odczyt co 8 kroki
{
int8_t val;

cli();
val = enc_delta;
enc_delta = val & 4;
sei();
return val >> 3;
}
int8_t encode_read16( void ) // odczyt co 16 kroki
{
int8_t val;

cli();
val = enc_delta;
enc_delta = val & 8;
sei();
return val >> 4;
}

int main(void) {


USART_Init( __UBRR );// inicjalizacja UART

DDRA |=(1<<PA7);
PORTA |= (1<<PA7);

//lcd_init();

int32_t val = 0;
DDRD |= LED_PIN;

encode_init();



/* ustawiamy piny sterujące L293D jako wyjścia */
DDRD |= (1<<WE_A)|(1<<WE_B); // ustawienie pinów sterujących L293DNE jako wyjścia
DDRB &=~ (KEY1| KEY2); // wejście KEY1 KEY2
PORTB |=( KEY1 | KEY2);// podciągnięcie KEY1 KEY2 do VCC

//PWM
//***** SPRZĘTOWY PWM - 1 KANAŁ OC0 (PB3) *******
// ustawienie końcówki OC0 (PB3) sprzętowy PWM jako WYJŚCIE
DDRB |= (1<<PB3);
// ustawienia TIMER0 w Fast PWM
TCCR0 |= (1<<WGM01)|(1<<WGM00);// tryb Fast PWM
TCCR0 |= (1<<COM01)|(1<<COM00);// clear at TOP
TCCR0 |= (1<<CS02)|(1<<CS00);// preskaler = 1
OCR0=pomiar(5);//PWM



ADMUX |= (1<<REFS0)|(1<<ADLAR);// wybór napięcia odniesienia w postaci VCC
ADCSRA |= (1<<ADEN)|(1<<ADPS1)|(1<<ADPS0); // włączenie modułu ADC oraz ustawienie preskalera 64


sei();

while(1)
{
//lcd_cls();
//lcd_locate(0,0);
//lcd_str("PWM");
//lcd_locate(1,0);
//lcd_int(pomiar (5));
/*
lcd_locate(0,5);
lcd_str("ENCODER");
lcd_locate(1,5);
lcd_int(val);
_delay_ms(100);
*/

val += encode_read4();


//uart_puts("ENCODER= ");// wyślij tekst
//uart_putint(val, 10);// wyślij liczbę
//uart_puts(" cm");
//uart_putc('\r');// wyślij znak CR (enter)
//uart_putc('\n');
//_delay_ms(1000);





if( KEY_DOWN1 ) {
_delay_ms(80); //czas drgania styków

OCR0=pomiar(5);
_delay_ms(1);

DC_PRAWO;
} else if ( KEY_DOWN2 ) {
_delay_ms(80);

OCR0=pomiar(5);
_delay_ms(1);

DC_LEWO;
} else {
DC_STOP;
}


}


}



uint16_t pomiar (uint8_t kanal)
{
ADMUX = (ADMUX & 0xF8)| kanal; // PA5 //ustawienie wybranego kanalu w rejestrze ADMUX
ADCSRA |= (1<<ADSC); //start pomiaru przez ustawienie bitu ADSC w rejestrze ADCSRA
while (ADCSRA & (1<<ADSC)); //oczekiwanie na koniec pomiaru (dopóki bit ADSC =1)
// po zakończeniu pomiaru, gdy bit ADSC=0, zwrócenie wyniku w postaci
// 16-to bitowej wartości z rejestrów ADCH i ADCL
return (ADCW>>8);
}

[/syntax]

Statystyki: Napisane przez developer85 — 31 lip 2012, o 11:17

]]> 2012-07-31T09:17:10+01:00 2012-07-31T09:17:10+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=11354#p11354 <![CDATA[Re: UART]]>
Ja bym tak nie stawiał pytania - że wrzucam cały swój kod i proszę o podpowiedź co tu jest źle, bo kto ma wiedzieć jak nie ty. Trzeba lepiej precyzować pytania żeby się szybciej czegoś dowiedzieć....

Czy kolega w ogóle najpierw potrenował sobie używanie timerów programowych z diodami LED ? zrozumiał dokładnie o co chodzi ??? bo niestety wydaje mi się że na razie nie :( .... a tymczasem próbuje je kolega na oślep używać i stąd pewnie efekt że coś tam nie działa albo wszystko nie działa

Najpierw trzeba zrozumieć JEDNO

1. wszystko co dzieje się w pętli while(1) - jest wykonywane miliony raz na sekundę, więc po co np umieszczać wyświetlanie na LCD tak szybko ??? co kolega zrobił właśnie w tej pętli - toż to już jest nieporozumienie i to mocne. Bo nie dość że nie potrzeba tak często to jeszcze to wyświetlanie tak często zapuszczane blokuje tylko niepotrzebnie czas całej aplikacji

2. timer programowy jest po to żeby np takie wyświetlanie odpalać sobie np raz na sekundę albo jak się uprzesz to i 10 no 20 razy max na sekundę. Bo przecież większego odświeżania i tak nigdy nie zobaczysz gołym okiem na LCD

3. funkcja SuperDebounce już sama pięknie korzysta z timerów programowych więc po co w dalszej części znowu robić IFy dla klawiszy ???? Toż do tej funkcji podłączasz swoje własne, które mają coś zrobić gdy klawisz np wciśnięty czy zwolniony i to w nich piszesz reakcję na obsługę każdego klawisza

więcej nie powiem bo niestety nie mam tyle czasu żeby całe kody analizować i to jeszcze bez wyjaśnień co jest konkretnym problemem :( - postaraj się jak pisałem wyżej najpierw poćwiczyć timery programowe a nie od razu wszystko zaprzęgnąć do projektu który robisz - napisać cały program - a potem się zastanawiać co tu nie działa.

Trzeba się nauczyć pisać program etapami

Statystyki: Napisane przez mirekk36 — 31 lip 2012, o 09:17

]]> 2012-07-31T09:04:06+01:00 2012-07-31T09:04:06+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=11353#p11353 <![CDATA[Re: UART]]> Wstawiłem diodkę w przerwanie w ISR(TIMER1_COMPA_vect) - timery programowe i tutaj coś zatrzymało. Nie działa PWM teraz:/ i sterowanie prawo lewo silnikami.
Hilfe!

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


#include "encoder/encoder.h"
#include "MKUART/mkuart.h"

/* przydatne definicje pinów sterujących */
#define WE_A PD1 // piny sterujące L293DNE
#define WE_B PD0
#define KEY1 (1<<PB0) //def klawisz 1
#define KEY2 (1<<PB1) //def klawisza 2
#define KEY_DOWN1 !(PINB & KEY1) //sprawdzanie stanu niskiego na KEY1
#define KEY_DOWN2 !(PINB & KEY2) //sprawdzanie stanu niskiego na KEY2

/* definicje poleceń sterujących pracą silnika */
#define DC_LEWO PORTD &= ~(1<<WE_A); PORTD |= (1<<WE_B) // obrót prawo
#define DC_PRAWO PORTD |= (1<<WE_A); PORTD &= ~(1<<WE_B)// obrót lewo
#define DC_STOP PORTD &= ~(1<<WE_A); PORTD &= ~(1<<WE_B)//stop



/************** funkcja SuperDebounce do obsługi pojedynczych klawiszy ***************/
void SuperDebounce( volatile uint8_t *KPIN,
uint8_t key_mask, uint16_t rep_time, uint16_t rep_wait,
void (*push_proc)(void), void (*rep_proc)(void) );

void kl1_press(void);
void kl1_rep(void);
void kl2_press(void);
void kl2_rep(void);

volatile uint16_t Timer1, Timer2, Timer3, Timer4;/* timery programowe 100Hz */

//PWM
volatile uint8_t pwm1;

uint16_t pomiar(uint8_t kanal);


int main(void) {



/* ustawiamy piny sterujące L293D jako wyjścia */
DDRD |= (1<<WE_A)|(1<<WE_B); // ustawienie pinów sterujących L293DNE jako wyjścia
DDRB &=~ (KEY1| KEY2); // wejście KEY1 KEY2
PORTB |=( KEY1 | KEY2);// podciągnięcie KEY1 KEY2 do VCC

DDRA |=(1<<PA7);
PORTA |= (1<<PA7); //podświetlenie LCD

/* Timer1 – inicjalizacja przerwania co 10ms */
TCCR1A |= (1<<WGM12);// tryb pracy CTC
TCCR1A |= (1<<CS12)|(1<<CS10);// preskaler = 1024
OCR1A = 108;// przerwanie porównania co 10ms (100Hz)
TIMSK = (1<<OCIE1A );// Odblokowanie przerwania CompareMatch

lcd_init();

int32_t val = 0;


encode_init();

//USART_Init( __UBRR );// inicjalizacja UART



//PWM
//***** SPRZĘTOWY PWM - 1 KANAŁ OC0 (PB3) *******
// ustawienie końcówki OC0 (PB3) sprzętowy PWM jako WYJŚCIE

DDRB |= (1<<PB3);

// ustawienia TIMER0 w Fast PWM
TCCR0 |= (1<<WGM01)|(1<<WGM00);// tryb Fast PWM
TCCR0 |= (1<<COM01)|(1<<COM00);// clear at TOP
TCCR0 |= (1<<CS02)|(1<<CS00);// preskaler = 1
OCR0=pomiar(5);//PWM

//ADC

ADMUX |= (1<<REFS0)|(1<<ADLAR);// wybór napięcia odniesienia w postaci VCC
ADCSRA |= (1<<ADEN)|(1<<ADPS1)|(1<<ADPS0); // włączenie modułu ADC oraz ustawienie preskalera 64

sei();

while(1)
{
SuperDebounce(&PINB, KEY_DOWN1, 80, 100, kl1_press, 0 );
SuperDebounce(&PINB, KEY_DOWN2, 80, 100, kl2_press, 0 );


lcd_cls();
lcd_locate(0,0);
lcd_str("PWM");
lcd_locate(1,0);
lcd_int(pomiar (5));
_delay_ms(100);

/*
lcd_locate(0,5);
lcd_str("ENCODER");
lcd_locate(1,5);
lcd_int(val);

*/

val += encode_read4();


//uart_puts("ENCODER= ");// wyślij tekst
//uart_putint(val, 10);// wyślij liczbę
//uart_puts(" cm");
//uart_putc('\r');// wyślij znak CR (enter)
//uart_putc('\n');
//_delay_ms(100);





if( !Timer2 ) {
Timer2=80;
if(KEY_DOWN1)
kl1_press();

} else if ( !Timer2) {
Timer2=80;
if(KEY_DOWN2)
kl2_press();

} else {
DC_STOP;
}


}


}

ISR(TIMER1_COMPA_vect)
{
uint16_t n;

n = Timer1;/* 100Hz Timer1 */
if (n) Timer1 = --n;
n = Timer2;/* 100Hz Timer2 */
if (n) Timer2 = --n;
n = Timer3;/* 100Hz Timer3 */
if (n) Timer3 = --n;
n = Timer4;/* 100Hz Timer4 */
if (n) Timer4 = --n;

}

uint16_t pomiar (uint8_t kanal)
{
ADMUX = (ADMUX & 0xF8)| kanal; // PA5 //ustawienie wybranego kanalu w rejestrze ADMUX
ADCSRA |= (1<<ADSC); //start pomiaru przez ustawienie bitu ADSC w rejestrze ADCSRA
while (ADCSRA & (1<<ADSC)); //oczekiwanie na koniec pomiaru (dopóki bit ADSC =1)
// po zakończeniu pomiaru, gdy bit ADSC=0, zwrócenie wyniku w postaci
// 16-to bitowej wartości z rejestrów ADCH i ADCL
return (ADCW>>8);
}

void SuperDebounce(volatile uint8_t *KPIN,
uint8_t key_mask, uint16_t rep_time, uint16_t rep_wait,
void (*push_proc)(void), void (*rep_proc)(void) ) {

enum KS {idle, debounce, go_rep, wait_rep, rep};

static enum KS key_state;
static uint8_t last_key;
uint8_t key_press;

// zabezpieczenie przed wykonywaniem tej samej funkcji dla
// dwóch klawiszy wciskanych jednocześnie (zawsze będzie
// wykonywana odpowiednia akcja dla tego, który został
// wciśnięty jako pierwszy
if( last_key && last_key != key_mask ) return;

key_press = !(*KPIN & key_mask);

if( key_press && !key_state ) {
key_state = debounce;
Timer1 = 5;
} else
if( key_state ) {
if( key_press && debounce==key_state && !Timer1 ) {
key_state = go_rep;
Timer1=3;
last_key = key_mask;
} else
if( !key_press && key_state>debounce && key_state<rep ) {
if(push_proc) push_proc();/* KEY_UP */
key_state=idle;
last_key = 0;
} else
if( key_press && go_rep==key_state && !Timer1 ) {
if(!rep_time) rep_time=20;
if(!rep_wait) rep_wait=150;
key_state = wait_rep;
Timer1=rep_wait;
} else
if( key_press && wait_rep==key_state && !Timer1 ) {
key_state = rep;
} else
if( key_press && rep==key_state && !Timer1 ) {
Timer1 = rep_time;
if(rep_proc) rep_proc();/* KEY_REP */
}
}

if( key_state>=wait_rep && !key_press ) {
key_state = idle;
last_key = 0;
}
}



void kl1_press(void) {
OCR0=pomiar(5);
DC_PRAWO;
}

void kl1_rep(void) {

}

void kl2_press(void) {
OCR0=pomiar(5);
DC_LEWO;
}

void kl2_rep(void) {
//lcd_locate(0,0);
//lcd_str_P(PSTR("cnt "));
//lcd_int(lcd_cnt++);
//lcd_str_P(PSTR(" "));
}
[/syntax]

enkoder.h
[syntax=c]
#ifndef ENCODER_H_
#define ENCODER_H_

#define PHASE_A (PINA & 1<<PA1) // piny enkodera Channel A
#define PHASE_B (PINA & 1<<PA2)//piny enkodera Channel B

extern volatile int8_t enc_delta; // -128 ... 127
//static int8_t last;

void encode_init( void );

#endif /* ENCODER_H_ */
[/syntax]

enkoder.c
[syntax=c]
#include <avr/io.h>// dołączenie głównego systemowego pliku nagłówkowego
#include <avr/interrupt.h>

#include "encoder.h"

volatile int8_t enc_delta; // -128 ... 127
static int8_t last;

void encode_init( void )
{
int8_t new;

new = 0;
if( PHASE_A ==0)
new = 3;
if( PHASE_B ==0)
new ^= 1;
last = new;
enc_delta = 0;
TCCR2 |= (1<<WGM21); // CTC
TCCR2 |= (1<<CS22)|(1<<CS21)|(1<<CS20); //1024 //(1<<CS22); //64
OCR2 = 18;
TIMSK |= (1<<OCIE2);
}


ISR( TIMER2_COMP_vect)
{
int8_t new, diff;
new = 0;
if( PHASE_A ==0)
new = 3;
if( PHASE_B ==0)
new ^= 1; // konwersja do binarki
diff = last - new;
if( diff & 1 ){ // bit 0 = value (1)
last = new; // zapamiętanie nowej wartości w next last
enc_delta += (diff & 2) - 1; // bit 1 = direction (+/-)
}


}

int8_t encode_read1( void ) // odczyt co krok
{
int8_t val;

cli();
val = enc_delta;
enc_delta = 0;
sei();
return val;
}


int8_t encode_read2( void ) // odczyt co 2 kroki
{
int8_t val;

cli();
val = enc_delta;
enc_delta = val & 1;
sei();
return val >> 1;
}


int8_t encode_read4( void ) // odczyt co 4 kroki
{
int8_t val;

cli();
val = enc_delta;
enc_delta = val & 3;
sei();
return val >> 2;
}

int8_t encode_read8( void ) // odczyt co 8 kroki
{
int8_t val;

cli();
val = enc_delta;
enc_delta = val & 4;
sei();
return val >> 3;
}
int8_t encode_read16( void ) // odczyt co 16 kroki
{
int8_t val;

cli();
val = enc_delta;
enc_delta = val & 8;
sei();
return val >> 4;
}[/syntax]

Statystyki: Napisane przez developer85 — 31 lip 2012, o 09:04

]]> 2012-07-30T20:12:47+01:00 2012-07-30T20:12:47+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=11334#p11334 <![CDATA[Re: UART]]> Za rozwianie moich wątpliwości.

Statystyki: Napisane przez developer85 — 30 lip 2012, o 20:12

]]> 2012-07-30T19:50:45+01:00 2012-07-30T19:50:45+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=11333#p11333 <![CDATA[Re: UART]]> arko_go napisał(a):

Mam kilka niejasności tylko mnie od razu nie zlinczujcie za głupie pytania.

A tam zaraz ;) najwyżej trafiłbyś do naszych Lochów....


arko_go napisał(a):

1. Żeby zrealizować opóźnienia nie stosować funkcji typu _delay? tylko timery programowe? - akurat wykorzystuje dwa przyciski do sterowania silnikiem!

No i co ? myślisz że aby stosować timery programowe to się opłaca dopiero od momentu gdy w programie zastosujesz 425 przycisków ??? A jak dwa do _delay ??? :( .... no toż przecież cała idea prostej wielowątkowości polega na stosowaniu prostego mechanizmu timerów programowych, które działają sobie w oparciu o jeden dowolny timer sprzętowy. Opłaca się je panie kolego używać nawet jakbyś miał tylko pół przycisku ;)


arko_go napisał(a):

2. Aby projekt był pseudo-wątkowy jak to autor ujął to jest do tego potrzebny RTC? nie mogę tego w żaden sposób pojąć.


No tu coś ci się zacięło ;) .... akurat w tym projekcie ( i masz to wyraźnie napisane w książce ) .... RTC jest kolejnym dodatkowym modułem zewnętrznym niezależnie obsługiwanym w systemie wielowątkowym. Wcale nie musi być wykorzystany - chociaż czasem może ponieważ sam potrafi ładnie generować sprzętowo przerwanka co 1Hz

Statystyki: Napisane przez mirekk36 — 30 lip 2012, o 19:50

]]> 2012-07-30T19:32:39+01:00 2012-07-30T19:32:39+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=11328#p11328 <![CDATA[Re: UART]]> 1. Żeby zrealizować opóźnienia nie stosować funkcji typu _delay? tylko timery programowe? - akurat wykorzystuje dwa przyciski do sterowania silnikiem!
2. Aby projekt był pseudo-wątkowy jak to autor ujął to jest do tego potrzebny RTC? nie mogę tego w żaden sposób pojąć.

Statystyki: Napisane przez developer85 — 30 lip 2012, o 19:32

]]> 2012-07-27T17:58:21+01:00 2012-07-27T17:58:21+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=11033#p11033 <![CDATA[Re: UART]]> Też tak myślałem że może się PWM zakłóca, ale usunąłem cały wpis odnośnie PWM-a i dalej to samo.

Statystyki: Napisane przez developer85 — 27 lip 2012, o 17:58

]]> 2012-07-27T15:58:16+01:00 2012-07-27T15:58:16+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=11026#p11026 <![CDATA[Re: UART]]>
Polecam przeczytanie ostatniego rozdziału z pierwszej książki p. Mirka - jest tam opisany system czasu rzeczywistego. Kilka procesów działa równocześnie. U ciebie jest coś podobnego regulacja PWM + wysyłanie informacji przez UART.

Są tam opisane również timery programowe, które moim zdaniem w Twoim programie powinny być zastosowane.

------------------------ [ Dodano po: 7 minutach ]

Rozumiem, że testowałeś ten program który dałeś w ostatnim załączniku. Czyli oprócz inicjalizacji UART wykonywałęś funkcje wysyłające dane na UART.

Usuń ten fragment programu i zobacz czy wszystko będzie Ci chodziło:
Code:
                uart_puts("ENCODER= "); // wyślij tekst
                uart_putint(val, 10);// wyślij liczbę
                uart_puts("    cm");
                uart_putc('\r');                        // wyślij znak CR (enter)
                uart_putc('\n');
                _delay_ms(1000);


Jeżeli będzie Ci chodził program, to musisz wprowadzić timer programowy który będzie Ci sterował wysyłaniem znaków na UART.

Statystyki: Napisane przez IUVOit — 27 lip 2012, o 15:58

]]> 2012-07-27T10:33:30+01:00 2012-07-27T10:33:30+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=10990#p10990 <![CDATA[Re: UART]]> Ale teraz generalnie chodzi o sam UART, bo jak go zainicjalizuje to PWM niedziała do sterowania silnikiem i możliwość sterowania prawo lewo.

------------------------ [ Dodano po: 41 minutach ]

To niema ktoś pomysłu na ten UART czego on nie działa?

Zamieszczam kompletny kod programu może będzie lepiej widać co jest.[syntax=c]
#include <avr/io.h>
#include <util/delay.h>
//#include "LCD/lcd44780.h"
#include <avr/interrupt.h>

#include "MKUART/mkuart.h"

/* przydatne definicje pinów sterujących */
#define WE_A PD1 // piny sterujące L293DNE
#define WE_B PD0
#define KEY1 (1<<PB0) //def klawisz 1
#define KEY2 (1<<PB1) //def klawisza 2
#define KEY_DOWN1 !(PINB & KEY1) //sprawdzanie stanu niskiego na KEY1
#define KEY_DOWN2 !(PINB & KEY2) //sprawdzanie stanu niskiego na KEY2
/* definicje poleceń sterujących pracą silnika */
#define DC_LEWO PORTD &= ~(1<<WE_A); PORTD |= (1<<WE_B) // obrót prawo
#define DC_PRAWO PORTD |= (1<<WE_A); PORTD &= ~(1<<WE_B)// obrót lewo
#define DC_STOP PORTD &= ~(1<<WE_A); PORTD &= ~(1<<WE_B)//stop

// definicja pinów enkodera
#define PHASE_A (PINA & 1<<PA1) // piny enkodera Channel A
#define PHASE_B (PINA & 1<<PA2)//piny enkodera Channel B
#define LED_PIN (1<<PD7) //diodka
#define LED_ON PORTD |= LED_PIN;

volatile int8_t enc_delta; // -128 ... 127
static int8_t last;


//PWM
volatile uint8_t pwm1;

uint16_t pomiar(uint8_t kanal);

void encode_init( void )
{
int8_t new;

new = 0;
if( PHASE_A ==0)
new = 3;
if( PHASE_B ==0)
new ^= 1;
last = new;
enc_delta = 0;
TCCR2 |= (1<<WGM21); // CTC
TCCR2 |= (1<<CS22)|(1<<CS21)|(1<<CS20); //1024 //(1<<CS22); //64
OCR2 = 18;
TIMSK |= (1<<OCIE2);
}


ISR( TIMER2_COMP_vect)
{
int8_t new, diff;
new = 0;
if( PHASE_A ==0)
new = 3;
if( PHASE_B ==0)
new ^= 1; // konwersja do binarki
diff = last - new;
if( diff & 1 ){ // bit 0 = value (1)
last = new; // zapamiętanie nowej wartości w next last
enc_delta += (diff & 2) - 1; // bit 1 = direction (+/-)
}


}

int8_t encode_read1( void ) // odczyt co krok
{
int8_t val;

cli();
val = enc_delta;
enc_delta = 0;
sei();
return val;
}


int8_t encode_read2( void ) // odczyt co 2 kroki
{
int8_t val;

cli();
val = enc_delta;
enc_delta = val & 1;
sei();
return val >> 1;
}


int8_t encode_read4( void ) // odczyt co 4 kroki
{
int8_t val;

cli();
val = enc_delta;
enc_delta = val & 3;
sei();
return val >> 2;
}

int8_t encode_read8( void ) // odczyt co 8 kroki
{
int8_t val;

cli();
val = enc_delta;
enc_delta = val & 4;
sei();
return val >> 3;
}
int8_t encode_read16( void ) // odczyt co 16 kroki
{
int8_t val;

cli();
val = enc_delta;
enc_delta = val & 8;
sei();
return val >> 4;
}

int main(void) {


USART_Init( __UBRR );// inicjalizacja UART
sei();
//DDRA |=(1<<PA7);
//PORTA |= (1<<PA7);

//lcd_init();

int32_t val = 0;
DDRD |= LED_PIN;

encode_init();
sei();


/* ustawiamy piny sterujące L293D jako wyjścia */
DDRD |= (1<<WE_A)|(1<<WE_B); // ustawienie pinów sterujących L293DNE jako wyjścia
DDRB &=~ (KEY1| KEY2); // wejście KEY1 KEY2
PORTB |=( KEY1 | KEY2);// podciągnięcie KEY1 KEY2 do VCC

//PWM
//***** SPRZĘTOWY PWM - 1 KANAŁ OC0 (PB3) *******
// ustawienie końcówki OC0 (PB3) sprzętowy PWM jako WYJŚCIE
DDRB |= (1<<PB3);
// ustawienia TIMER0 w Fast PWM
TCCR0 |= (1<<WGM01)|(1<<WGM00);// tryb Fast PWM
TCCR0 |= (1<<COM01)|(1<<COM00);// clear at TOP
TCCR0 |= (1<<CS02)|(1<<CS00);// preskaler = 1
OCR0=pomiar(5);//PWM



ADMUX |= (1<<REFS0)|(1<<ADLAR);// wybór napięcia odniesienia w postaci VCC
ADCSRA |= (1<<ADEN)|(1<<ADPS1)|(1<<ADPS0); // włączenie modułu ADC oraz ustawienie preskalera 64




while(1)
{
//lcd_cls();
//lcd_locate(0,0);
//lcd_str("PWM");
//lcd_locate(1,0);
//lcd_int(pomiar (5));
/*
lcd_locate(0,5);
lcd_str("ENCODER");
lcd_locate(1,5);
lcd_int(val);
_delay_ms(100);
*/

val += encode_read4();


uart_puts("ENCODER= ");// wyślij tekst
uart_putint(val, 10);// wyślij liczbę
uart_puts(" cm");
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');
_delay_ms(1000);





if( KEY_DOWN1 ) {
_delay_ms(80); //czas drgania styków

OCR0=pomiar(5);
_delay_ms(1);

DC_PRAWO;
} else if ( KEY_DOWN2 ) {
_delay_ms(80);

OCR0=pomiar(5);
_delay_ms(1);

DC_LEWO;
} else {
DC_STOP;
}


}


}



uint16_t pomiar (uint8_t kanal)
{
ADMUX = (ADMUX & 0xF8)| kanal; // PA5 //ustawienie wybranego kanalu w rejestrze ADMUX
ADCSRA |= (1<<ADSC); //start pomiaru przez ustawienie bitu ADSC w rejestrze ADCSRA
while (ADCSRA & (1<<ADSC)); //oczekiwanie na koniec pomiaru (dopóki bit ADSC =1)
// po zakończeniu pomiaru, gdy bit ADSC=0, zwrócenie wyniku w postaci
// 16-to bitowej wartości z rejestrów ADCH i ADCL
return (ADCW>>8);
}

[/syntax]

Statystyki: Napisane przez developer85 — 27 lip 2012, o 10:33

]]> 2012-07-27T10:11:28+01:00 2012-07-27T10:11:28+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=10988#p10988 <![CDATA[Re: UART]]> nie proście by ci było timerem zliczać impulsy , potem je przeliczać na obroty i wyswietlać wynik co 1 sek z dkładnością do np 10 obr
??

Statystyki: Napisane przez SunRiver — 27 lip 2012, o 10:11

]]> 2012-07-27T09:53:41+01:00 2012-07-27T09:53:41+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=10987#p10987 <![CDATA[Re: UART]]>
Chciałem wyniki z enkodera który ładuje 250 impulsów na obrót wyświetlić w terminalu - stąd to opóźnienie.

Statystyki: Napisane przez developer85 — 27 lip 2012, o 09:53

]]> 2012-07-27T09:48:32+01:00 2012-07-27T09:48:32+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=10985#p10985 <![CDATA[Re: UART]]>
... jak dodajesz tylko linijkę USART_Init(__UBRR) i nic więcej to program zaczyna CI "siadać"?

Statystyki: Napisane przez IUVOit — 27 lip 2012, o 09:48

]]> 2012-07-27T09:25:57+01:00 2012-07-27T09:25:57+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=10984#p10984 <![CDATA[Re: UART]]> Chodzi mi o to że przed inicjalizacją UART wszystko działało sterowanie silnikiem, PWM. Gdy włącze
USART_Init( __UBRR );
w tedy silnik kręci się w jedną stronę i nie reaguej na przyciski.

Myślę, że coś jest nie za bardzo z przerwaniami.

Statystyki: Napisane przez developer85 — 27 lip 2012, o 09:25

]]> 2012-07-27T09:17:36+01:00 2012-07-27T09:17:36+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=10983#p10983 <![CDATA[Re: UART]]>
Jak program działał wcześniej to bym proponował wprowadzenie Timerów programowych i wszystko powinno ruszyć. Np wysyłanie do UART co 1 sekundę, wysyłanie na LCD np co pół sekundy.

Statystyki: Napisane przez IUVOit — 27 lip 2012, o 09:17

]]> 2012-07-27T09:10:12+01:00 2012-07-27T09:10:12+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=10982#p10982 <![CDATA[Re: UART]]> IUVOit napisał(a):

Do czego służy _delay_ms(1)? Chyba nie potrzebna linijka, która nie potrzebnie zatrzymuje program?


No tu bym jednak uważał bo już pchanie tylu danych w uart co 1ms to przesada a jak się skasuje tą linijkę to procesor nic w zasadzie nie będzie robił tylko wciąż zajmował obsługą przerwania żeby wysyłać do uarta - a komu potrzebne jest to żeby w terminalu oglądać 1000 razy na skundę napis i te wartości ????? albo po skasowaniu linijki będzie to może 10 tys !!! razy na sekundę :)

tu trzeba się zastanowić - jak prezentować wyniki dla oka, zresztą to samo się tyczy wywoływania napisów na LCD - po co miliony razy na sekundę ?

Statystyki: Napisane przez mirekk36 — 27 lip 2012, o 09:10

]]> 2012-07-27T09:06:39+01:00 2012-07-27T09:06:39+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=10981#p10981 <![CDATA[Re: UART]]>
Code:
                uart_puts("ENCODER= "); // wyślij tekst
                uart_putint(val, 10);// wyślij liczbę
                uart_puts("    cm");
                uart_putc('\r');                        // wyślij znak CR (enter)
                uart_putc('\n');
                _delay_ms(1);


...i program zaczął Ci źle chodzić? Do czego służy _delay_ms(1)? Chyba nie potrzebna linijka, która nie potrzebnie zatrzymuje program?

------------------------ [ Dodano po: 2 minutach ]

Lepiej chyba dodać timer programowy co np 1 sekundę wysyła info. @Mirek, _delay_ms(1) no własnie też się zastanawiałem nad tak dużym odświeżaniem i jego sensem.

Statystyki: Napisane przez IUVOit — 27 lip 2012, o 09:06

]]> 2012-07-27T09:04:32+01:00 2012-07-27T09:04:32+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=10980#p10980 <![CDATA[Re: UART]]>

z drugiej strony pchanie w uart danych co 1ms to przypadkiem nie jakaś przesada ? ;) czemu ma to niby służyć?

Statystyki: Napisane przez mirekk36 — 27 lip 2012, o 09:04

]]> 2012-07-27T08:24:44+01:00 2012-07-27T08:24:44+01:00 https://forum.atnel.pl/viewtopic.php?t=1338&p=10979#p10979 <![CDATA[UART]]> Realizuje sterowanie silnikiem za pomocą PWM (sprzętowym). PWM podglądam na LCD. Odczytuje impulsy z enkodera przy silniku.
I chciałbym impulsy przesłać przez UART na terminal. Po inicjalizacji UART sterowanie klęka. Nic nie działa. Proszę o wskazówki co robię źle.

Odczyt z enkodera - Przerwania
[syntax=c]void encode_init( void )
{
int8_t new;

new = 0;
if( PHASE_A ==0)
new = 3;
if( PHASE_B ==0)
new ^= 1;
last = new;
enc_delta = 0;
TCCR2 |= (1<<WGM21); // CTC
TCCR2 |= (1<<CS22)|(1<<CS21)|(1<<CS20); //1024 //(1<<CS22); //64
OCR2 = 18;
TIMSK |= (1<<OCIE2);
}


ISR( TIMER2_COMP_vect)
{
int8_t new, diff;
new = 0;
if( PHASE_A ==0)
new = 3;
if( PHASE_B ==0)
new ^= 1; // konwersja do binarki
diff = last - new;
if( diff & 1 ){ // bit 0 = value (1)
last = new; // zapamiętanie nowej wartości w next last
enc_delta += (diff & 2) - 1; // bit 1 = direction (+/-)
}[/syntax]

main()
[syntax=c]int main(void) {


USART_Init( __UBRR );// inicjalizacja UART

DDRA |=(1<<PA7);
PORTA |= (1<<PA7);

lcd_init();

int32_t val = 0;
DDRD |= LED_PIN;

encode_init();
sei();


/* ustawiamy piny sterujące L293D jako wyjścia */
DDRD |= (1<<WE_A)|(1<<WE_B); // ustawienie pinów sterujących L293DNE jako wyjścia
DDRB &=~ (KEY1| KEY2); // wejście KEY1 KEY2
PORTB |=( KEY1 | KEY2);// podciągnięcie KEY1 KEY2 do VCC

//PWM
//***** SPRZĘTOWY PWM - 1 KANAŁ OC0 (PB3) *******
// ustawienie końcówki OC0 (PB3) sprzętowy PWM jako WYJŚCIE
DDRB |= (1<<PB3);
// ustawienia TIMER2 w Fast PWM
TCCR0 |= (1<<WGM01)|(1<<WGM00);// tryb Fast PWM
TCCR0 |= (1<<COM01)|(1<<COM00);// clear at TOP
TCCR0 |= (1<<CS02)|(1<<CS00);// preskaler = 1
OCR0=pomiar(5);//PWM



ADMUX |= (1<<REFS0)|(1<<ADLAR);// wybór napięcia odniesienia w postaci VCC
ADCSRA |= (1<<ADEN)|(1<<ADPS1)|(1<<ADPS0); // włączenie modułu ADC oraz ustawienie preskalera 64




while(1)
{
lcd_cls();
lcd_locate(0,0);
lcd_str("PWM");
lcd_locate(1,0);
lcd_int(pomiar (5));
/*
lcd_locate(0,5);
lcd_str("ENCODER");
lcd_locate(1,5);
lcd_int(val);
_delay_ms(100);
*/

val += encode_read4();


uart_puts("ENCODER= ");// wyślij tekst
uart_putint(val, 10);// wyślij liczbę
uart_puts(" cm");
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');
_delay_ms(1);

// odczyt jednego kroku



if( KEY_DOWN1 ) {
_delay_ms(80); //czas drgania styków

OCR0=pomiar(5);
_delay_ms(1);

DC_PRAWO;
} else if ( KEY_DOWN2 ) {
_delay_ms(80);

OCR0=pomiar(5);
_delay_ms(1);

DC_LEWO;
} else {
DC_STOP;
}


}


}



uint16_t pomiar (uint8_t kanal)
{
ADMUX = (ADMUX & 0xF8)| kanal; // PA5 //ustawienie wybranego kanalu w rejestrze ADMUX
ADCSRA |= (1<<ADSC); //start pomiaru przez ustawienie bitu ADSC w rejestrze ADCSRA
while (ADCSRA & (1<<ADSC)); //oczekiwanie na koniec pomiaru (dopóki bit ADSC =1)
// po zakończeniu pomiaru, gdy bit ADSC=0, zwrócenie wyniku w postaci
// 16-to bitowej wartości z rejestrów ADCH i ADCL
return (ADCW>>8);
}
[/syntax]

Statystyki: Napisane przez developer85 — 27 lip 2012, o 08:24

]]>