ATNEL tech-forum 2013-05-05T11:57:54+01:00 https://forum.atnel.pl/feed.php?f=4&t=3029&mode 2013-05-05T11:57:54+01:00 2013-05-05T11:57:54+01:00 https://forum.atnel.pl/viewtopic.php?t=3029&p=36177#p36177 <![CDATA[Re: Analizator szerkości impulsu dla pilotów]]> Paul Dirac napisał(a):

To wilekie dzięki. A ta twoja biblioteka sasmunga będzie zgrana z moim pilotem, czy nie?


Wiesz ale ja no tak że tak powiem wróżyć to nie umiem ;) nie wiem

ale weź to w łapki i sprawdź - szybciej będzie ... - a że sposób kodowania wygląda bardzo podobnie to pewnie jak już to najwyżej potrzebne będą niewielkie zmiany czasów być może .... itp

i poczytaj na czacie co ci napisałem o tym MAKRO do przeliczania czasów o które pytałeś ;)

Statystyki: Napisane przez mirekk36 — 5 maja 2013, o 11:57

]]> 2013-05-05T11:49:35+01:00 2013-05-05T11:49:35+01:00 https://forum.atnel.pl/viewtopic.php?t=3029&p=36172#p36172 <![CDATA[Re: Analizator szerkości impulsu dla pilotów]]> Statystyki: Napisane przez Paul Dirac — 5 maja 2013, o 11:49

]]> 2013-05-05T11:38:58+01:00 2013-05-05T11:38:58+01:00 https://forum.atnel.pl/viewtopic.php?t=3029&p=36169#p36169 <![CDATA[Re: Analizator szerkości impulsu dla pilotów]]> .... podziel to przez DWA i już masz połowę mniej - bo każdy bit to przecież dwa impulsy, do tego Header .... a później to już kwestia jak widać najczęściej ilości bitów "rozbiegówki" PRE_DATA ... która bywa bardzo różna, a na końcu w samsungach często już tylko dwa zanegowane bajty przesyłane. ... Więc jak tak na to spojrzeć to dlaczego niby długa ramka. 16 bitów na te dwa bajty zanegowane, 16 bitów na PRE_DATA, jakiś Header i już masz całą ramkę

------------------------ [ Dodano po: 1 minucie ]

o dopiero teraz zobaczyłem co dopisałeś i proszę ;) widzisz jakie długie PRE_DATA ? ;) no i czasy się zgadzają z tym co widać w terminalu ;)

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

dodatkowo jak pisałem w książce zobacz np wartość dla klawisza 2

0xA05F

pierwszy bajt A0 a drugi to zanegowana wartość ;) 5F ;)

------------------------ [ Dodano po: 3 minutach ]

No i na końcu PTRAIL, o którym też piszę - czyli dlatego na końcu masz nieparzystą liczbę impulsów ;) - wszystko się zgadza.

Statystyki: Napisane przez mirekk36 — 5 maja 2013, o 11:38

]]> 2013-05-05T11:30:52+01:00 2013-05-05T11:30:52+01:00 https://forum.atnel.pl/viewtopic.php?t=3029&p=36165#p36165 <![CDATA[Re: Analizator szerkości impulsu dla pilotów]]> W sumie jest super wytłumaczone w zielonej książce jak to robić mając notę podobnego pilota. Ale nie wiem, czemu ta ramka jest taka długa.
Ja tam na podstawie tej noty będę pisał obsługę:
http://lirc.sourceforge.net/remotes/samsung/BN59-00685A

Statystyki: Napisane przez Paul Dirac — 5 maja 2013, o 11:30

]]> 2013-05-05T11:12:43+01:00 2013-05-05T11:12:43+01:00 https://forum.atnel.pl/viewtopic.php?t=3029&p=36161#p36161 <![CDATA[Re: Analizator szerkości impulsu dla pilotów]]>
Poza tym czy ta ramka za każdym razem tak samo wygląda po wciśnięciu jakiegoś jednego klawisza ?

Statystyki: Napisane przez mirekk36 — 5 maja 2013, o 11:12

]]> 2013-05-05T10:47:05+01:00 2013-05-05T10:47:05+01:00 https://forum.atnel.pl/viewtopic.php?t=3029&p=36160#p36160 <![CDATA[Analizator szerkości impulsu dla pilotów]]>
Troche przerobiłem ten program do analizowania tych impulsów i do końca nie rozumiem jak teraz poprawnie analizowac ta ramkę. Ramka jedna trwa u mnie 67 rózne stany. Może lepiej wkleje jak to w terminalu wyszło:
[syntax=c]step: 01PulseWidth: 4525
step: 02PulseWidth: 4429
step: 03PulseWidth: 603
step: 04PulseWidth: 1639
step: 05PulseWidth: 598
step: 06PulseWidth: 1643
step: 07PulseWidth: 603
step: 08PulseWidth: 1638
step: 09PulseWidth: 607
step: 10PulseWidth: 518
step: 11PulseWidth: 598
step: 12PulseWidth: 527
step: 13PulseWidth: 599
step: 14PulseWidth: 526
step: 15PulseWidth: 601
step: 16PulseWidth: 524
step: 17PulseWidth: 602
step: 18PulseWidth: 523
step: 19PulseWidth: 602
step: 20PulseWidth: 1639
step: 21PulseWidth: 608
step: 22PulseWidth: 1634
step: 23PulseWidth: 602
step: 24PulseWidth: 1639
step: 25PulseWidth: 607
step: 26PulseWidth: 518
step: 27PulseWidth: 607
step: 28PulseWidth: 518
step: 29PulseWidth: 597
step: 30PulseWidth: 528
step: 31PulseWidth: 598
step: 32PulseWidth: 527
step: 33PulseWidth: 599
step: 34PulseWidth: 526
step: 35PulseWidth: 599
step: 36PulseWidth: 526
step: 37PulseWidth: 600
step: 38PulseWidth: 524
step: 39PulseWidth: 601
step: 40PulseWidth: 1640
step: 41PulseWidth: 606
step: 42PulseWidth: 518
step: 43PulseWidth: 607
step: 44PulseWidth: 518
step: 45PulseWidth: 607
step: 46PulseWidth: 518
step: 47PulseWidth: 608
step: 48PulseWidth: 518
step: 49PulseWidth: 597
step: 50PulseWidth: 527
step: 51PulseWidth: 599
step: 52PulseWidth: 1643
step: 53PulseWidth: 604
step: 54PulseWidth: 1637
step: 55PulseWidth: 598
step: 56PulseWidth: 527
step: 57PulseWidth: 599
step: 58PulseWidth: 1642
step: 59PulseWidth: 604
step: 60PulseWidth: 1638
step: 61PulseWidth: 599
step: 62PulseWidth: 1642
step: 63PulseWidth: 604
step: 64PulseWidth: 1636
step: 65PulseWidth: 599
step: 66PulseWidth: 1642
step: 67PulseWidth: 602[/syntax]

I teraz nie wiem jak zacząć tą analizę. W zielonej książce jest jakies 16 bitów, u mnie chyba więcej.
A przerobiony kod jest tylko z wyciętymi fargmentami kodu na obsługę lcd:
main.c:
[syntax=c]#include <avr/io.h>// podciągnięcie plików nagłówkowych
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <stdlib.h>
#include <string.h>



// makro przeliczające czasy w us w zależności od F_CPU (automatycznie)
#define ir_micro_s(num) (((num)*((F_CPU/1000UL)/8))/1000)

// stałe preprocesora
#define UART_BAUD 38400// tu definiujemy interesującą nas prędkość
#define __UBRR F_CPU/16/UART_BAUD-1 // obliczamy UBRR dla U2X=0




#define IR_PIN (1<<PD6)// numer pinu wejścia ICP
#define IR_DIR DDRD
#define IR_PORT PORTD

// deklaracje funkcji
void USART_Init( uint16_t baud );// obsługa UART
void uart_puts(char *s);// obsługa UART
void uart_putc( char data );// obsługa UART
void uart_put_int(uint16_t value);// obsługa UART

void send_to_terminal( void );
void send_to_mkdekoder( void );

// definicje zmiennych
volatile uint16_t tab[255];
volatile uint8_t frame_end, pulse_cnt;
volatile uint8_t step;

// zmienne pomocnicze
uint16_t ms=25000;
uint16_t hi;

/* *********** główna funkcja programu *******************/
int main(void) {



/* inicjalizacja IR */
//IR_DIR &= ~IR_PIN;// pin IR jako wejście, ponieważ jest domyślnie to pomijamy
IR_PORT |= IR_PIN;// podciągnięcie wejścia IR do VCC

// KONFIGURACJA PRACY PRZERWANIA ICP I TIMERA1
TCCR1B |= (1<<CS11);// ustawienie preskalera dla Timer1 = 8
TCCR1B &= ~(1<<ICES1);// reakcja na zbocze opadające
TIMSK |= (1<<TICIE1);// odblokowanie przerwania ICP

TIMSK |= (1<<OCIE1A);// odblokowanie przerwania CompareA

OCR1A = ir_micro_s(19000UL);


USART_Init( __UBRR );// inicjalizacja UART

sei();// globalne odblokowanie przerwań




/* **** GŁÓWNA PĘTLA PROGRAMU ***** */
while(1) {

// jeśli odebrano całą ramkę
if( frame_end ) {



// włącz poniższą linię do kompilacji jeśli
// program ma wysyłać tylko dane na terminal PC
send_to_terminal();

// włącz poniższą linię do kompilacji jeśli
// program ma współpracować z MkDekoder
//send_to_mkdekoder();

// czekaj w pętli do czasu aż na wejściu ICP będzie przerwa 90ms
// blokada przed nakładaniem się wielu ramek na wykres gdy
// wciskamy dłużej klawisz pilota
hi=0;
while(1) {
if( !(PIND & (1<<PD6)) ) {ms=30000; hi=0;}
else hi++;
if(!ms--) break;
if(hi>9000) break;
_delay_us(10);
}

TCCR1B &= ~(1<<ICES1);// reakcja na zbocze opadające
// skasowanie flagi przerwania
TIFR |= (1<<ICF1);
// ponowne odblokowanie przerwania ICP1
TIMSK |= (1<<TICIE1);

// skasuj flagę
frame_end = 0;
}
} // koniec pętli głównej ****

} /* ****** koniec MAIN ***** */




/* ************** OBSŁUGA PRZERWANIA ICP DLA TIMER1 ************* */
ISR(TIMER1_CAPT_vect) {

if( step == 0 ) {
TCNT1=0;
pulse_cnt=0;
}

TIFR |= (1<<OCF1A);
TIMSK |= (1<<OCIE1A);

TCCR1B ^= (1<<ICES1);

if( step > 0 ) {
tab[ step-1 ] = TCNT1;
pulse_cnt++;
}

step++;
TCNT1 = 0;

}

ISR( TIMER1_COMPA_vect ) {
step=0;
frame_end = 1;
TIMSK &= ~(1<<OCIE1A);
TIMSK &= ~(1<<TICIE1);
}


// inicjalizacja UART
void USART_Init( uint16_t baud ) {
/* Ustawienie prędkości */
UBRRH = (uint8_t)(baud>>8);
UBRRL = (uint8_t)baud;
/* Załączenie nadajnika i odbiornika */
UCSRB = (1<<RXEN)|(1<<TXEN);
/* Ustawienie format ramki: 8bitów danych, 1 bit stopu */
UCSRC = (1<<URSEL)|(3<<UCSZ0);
}

// przesłanie łańcucha znaków w poolingu (znak po znaku)
// bez buforowania - nie jest zwykle konieczne tak jak przy odbiorze
void uart_puts(char *s)// wysyła łańcuch z pamięci RAM na UART
{
register char c;
while ((c = *s++)) uart_putc(c);// dopóki nie napotkasz 0 wysyłaj znak
}

// wysłanie liczby na UART
void uart_put_int(uint16_t value) {
char string[17];// bufor na wynik funkcji itoa
itoa(value, string, 10);// konwersja value na ASCII
uart_puts(string);// wyślij string na port szeregowy
}

// wysłanie pojedynczego znaku na UART (podstawowa funkcja robocza)
void uart_putc( char data ) {
/* Wait for empty transmit buffer */
while ( !( UCSRA & (1<<UDRE)) );
/* Put data into buffer, sends the data */
UDR = data;
}

// funkcja wysyłająca wszystkie zebrane czasy z tablicy do terminala
void send_to_terminal( void ) {
uint8_t i;
if( !pulse_cnt ) return;
uart_puts("ramka IR:\r\n");
uart_puts("************************");
uart_puts("\r\n");
for( i=0; i<pulse_cnt; i++) {
uart_puts("step: ");
if( i+1 < 10 ) uart_puts("0");
uart_put_int(i+1);
uart_puts("\tPulseWidth: ");
uart_put_int( ((tab[i]*1000UL) / ((F_CPU/1000UL)/8)) );
uart_puts("\r\n");
}
uart_puts("************************");
uart_puts("\r\n");
}[/syntax]

prosiłbym o jakies sugestie żebym mógł ruszyć, wtedy bedzie mi łatwiej, bo obecnie stoję w miejscu.

Statystyki: Napisane przez Paul Dirac — 5 maja 2013, o 10:47

]]>