ATNEL tech-forum

Re: Wysyłanie i odbieranie danych poprzez serwer UDP_etherne

2014-08-01T14:04:01+01:00

mirek1968 napisał(a):

Mam jeszcze pytanko dotyczące własnego programu podobnego do Twojego "Klient/serwer/UDP" czy stworzenie podobnego programu dostosowanego do własnych potrzeb jest skomplikowane?,a może jest coś podobnego dostępne w sieci?

Nawet na naszym forum nie sprawdziłeś panie kochany ... a nasi koledzy już podawali różne przykłady i kursy w C#, w tym także z tego co pamiętam było o komunikacji UDP

ja ten mój program pisałem w Delphi więc jego źródła i tak mało dadzą komukolwiek i będą poza zasięgiem ... chociaż na życzenie, wysyłam źródła tego programu ...

ale uważam, że na dzisiaj zdecydowanie lepiej robić to sobie i uczyć się programować w C# bo i środowisko od MS masz za darmo

Statystyki: Napisane przez mirekk36 — 1 sie 2014, o 14:04

Re: Wysyłanie i odbieranie danych poprzez serwer UDP_etherne

2014-08-01T13:48:23+01:00

Osobiście uważam że temat komunikacji serwera i klienta po UDP jest dosyć trudny jak dla mnie do zrozumienia tym bardziej cieszę się że to działa:-).
Dzięki Twojej książce BB ,dołączonemu programowi na cd i pomocy ruszyło:-)
Przyznam się szczerze że żałuję troszkę że nie kupiłem całego kompletu sprzedawanego w Twoim sklepie (tzn. książki +PCB).
Kupując książkę BB posiadałem już inną płytkę testową ,ale nie wszystko na niej jest przemyślane do końca o czym się co jakiś czas przekonuję (np w tym teraz przypadku są współdzielone porty PORTB dla SPI oraz LCD).
Ale ma to malutki plusik take bardziej zmuszony jestem do myślenia bo przeważnie nic mi nie działa na samym starcie (to żart:-)).
zrobiłem sobie taki moduł zasilająco-konwertujący na układzie konwertera sygnałów 74LVC125 oraz stabilizatorach MC7805 oraz LM1117-3,3V i całość zasilam zasilaczem 12V DC skutkiem tego jest niezły grzejnik na stabilizatorze 7805 pomimo radiatora:-)
Pewnie muszę sobie kupić jakiś zasilacz np.7,5V zamiast 12V żeby nie było takiej wielkiej temperatury.
Mam jeszcze pytanko dotyczące własnego programu podobnego do Twojego "Klient/serwer/UDP" czy stworzenie podobnego programu dostosowanego do własnych potrzeb jest skomplikowane?,a może jest coś podobnego dostępne w sieci?
Przyznam się że nie szukałem jeszcze dokładnie,ale fajnie by było mieć taki program który by mógł sterować czymś w domu:-),super sprawa naprawdę:-)

Statystyki: Napisane przez mirek1968 — 1 sie 2014, o 13:48

Re: Wysyłanie i odbieranie danych poprzez serwer UDP_etherne

2014-08-01T13:11:48+01:00

Bo przy starcie nie jest sprawdzany ich stan po prostu .... to tylko program demonstracyjny - a nie jakiś sterownik, który jest gotowy na tzw KAŻDĄ sytuację

cieszę się że ruszyło

Statystyki: Napisane przez mirekk36 — 1 sie 2014, o 13:11

Re: Wysyłanie i odbieranie danych poprzez serwer UDP_etherne

2014-08-01T13:01:35+01:00

Wina leżała po mojej stronie a konkretnie problem był w tym że porty PB4-7 na mojej płytce mam na stałe przypiete także do LCD HD44780 a przecież są to porty używane do komunikacji.Zablokowałem na razie LCD z zakomentowałem go w programie.
Teraz diody LED mogę załączać i wyłanczać z programu Klient/serwer /UDP i działa mi to dobrze,działa mi także komunikacja zwrotna od płytki testowej do laptopa tzn przyciski dają mi tekst amka <-- [ SuperDebounce klawsz nr: 128 ]
ramka <-- [ SuperDebounce klawsz nr: 64 ] w zależności który wcisna.
Czyli wszystko było by OK,mam tylko pytanie dlaczego po odpaleniu programu Klient/serwer /UDP mam już na starcie aktywne okienka zapalenia LED-ów? (w tym momencie diody na płytce nie świeca jeszcze)
tak jak poniżej na fotce.Co prawda jak je odznaczę i ponownie zaznaczę to zaświecaja się i gasną wtedy ledy prawidłowo ,czy tak ma ten program czy też jest to związane z czymś innym?

Statystyki: Napisane przez mirek1968 — 1 sie 2014, o 13:01

Re: Wysyłanie i odbieranie danych poprzez serwer UDP_etherne

2014-08-01T12:26:21+01:00

No ATmega16 ma o połowę mniej pamięci RAM .... więc sprawdź ile zostaje ci wolnego po kompilacji ... jeśli zajętość RAM wynosi max ok 90% to może zostać taki bufor jak jest

zmieniłeś też jak widzę MAC address - naprawdę nie wiem po co ? ... widzisz tak to jest .... gdy ktoś ma kłopoty z pierwszym odpaleniem kodu to zawsze mówię - sprawdź na oryginale ... zmień tylko swoje adresy IP .... i często każdy tak jak ty odpowiada - że "NO sprawdzam na oryginale" a później się okazuje że .... a zmieniłem tylko to i siamto ale wg mnie to nie powinno mieć znaczenia. To wiesz - tak to można to uruchamiać miesiącami .... i w końcu powiedzieć że kod z książki nie działa

weź więc nie kombinuj - odpal kod z książki , ustaw tylko swoje adresy IP i wtedy jestem w stanie coś pomóc ...

Na kombinacje przyjdzie czas później i zobaczysz że wszystkie ci wyjdą ok ?

ty na razie masz jakiś mega poważny problem bo np te adres w tablicy kilku adresów jak się źle wpisze to co najwyżej nie ma komunikacji zwrotnej po UDP z procka do programu na PC ... a poza tym WSZYSTKO MUSI DZIAŁAĆ

powiedz mi czy jak odpalasz program na PC to zapala ci się takie jasno niebieskie światełko w lewym rogu górnym i masz napisane w statusie, że serwer UDP jest aktywny ?

Statystyki: Napisane przez mirekk36 — 1 sie 2014, o 12:26

Re: Wysyłanie i odbieranie danych poprzez serwer UDP_etherne

2014-08-01T12:11:21+01:00

Sprawdzałem firewall dodał ten program do wyjątku i nie blokuje go.
Zastanawiam się nad jedną sprawą jeśli Twój program serwera działał u mnie bardzo dobrze to czym to może być spowodowane że teraz mam problem.co prawda program serwera testowałem na procku Atmega328P a teraz klienta UDP testuję na Atmedze 16 taktowanym 16Mhz.
Zastanawiam się także nad wielkością bufora ramki
[syntax=c]// ustalamy wielkość bufora dla ramek TCP/UDP
#define BUFFER_SIZE 650[/syntax]

Czy u mnie nie powinno być mniej?,a jeśli tak to ile być zaproponował?

No i jeszcze jedna spawa ze względu na to że mój procesor jest tatowany zewnętrznym kwarcem 16MHz to musiałem zmienić OCR
[syntax=c]OCR2 = 156; //bo 16000000/1024/100[/syntax]

Poniżej podaje ustawienia fusebitów do sprawdzenia czy na pewno się nie pomyliłem gdzieś.

Statystyki: Napisane przez mirek1968 — 1 sie 2014, o 12:11

Re: Wysyłanie i odbieranie danych poprzez serwer UDP_etherne

2014-08-01T11:32:26+01:00

Być może Firewall windowsa zablokował program na PC ?

Statystyki: Napisane przez mirekk36 — 1 sie 2014, o 11:32

Re: Wysyłanie i odbieranie danych poprzez serwer UDP_etherne

2014-08-01T10:09:49+01:00

Poprawiłem te numery IP zgodnie z uwagami jakie napisałeś ale nadal jak próbuję np. wysłać tekst ,czy zapalić LED to nie działa mi nic.
Diody led oraz przyciski mam podłączone jak na rysunku poniżej

Na każde kliknięcie w danym oknie w programie Klient/server UDP reaguje mi dioda na karcie sieciowej ENC ale brak reakcji na płytce testowej Atmega16.
Cały kod main.c dokładnie taki sam jak w BB z moimi modyfikacjami dotyczącymi wejść przycisków oraz wyjść na LED-y
oraz mac adresu i IP poniżej.

[syntax=c]/*********************************************
* vim:sw=8:ts=8:si:et
* To use the above modeline in vim you must have "set modeline" in your .vimrc
* Author: Guido Socher
* Copyright: GPL V2
*
* Tuxgraphics AVR webserver/ethernet board
*
* http://tuxgraphics.org/electronics/
* Chip type : Atmega88/168/328 with ENC28J60
*
*
* ---> OBSŁUGA KLIENT/SERWER komunikacji UDP <-----
* MODYFIKACJE: Mirosław Kardaś --- ATmega32
*
*********************************************/
#include
#include
#include
#include
#include
#include
#include "ip_arp_udp_tcp.h"
#include "enc28j60.h"
#include "util/delay.h"
#include "net.h"

#include "LCD/lcd44780.h"

//-------------------------- definicje preprocesora ---------------------------------
#define LED1_DDRDDRD
#define LED1_PORTPORTD
#define LED1(1<#define LED1_ONLED1_PORT |= LED1
#define LED1_OFFLED1_PORT &= ~LED1
#define LED1_TOGLED1_PORT ^= LED1

#define LED2_DDRDDRD
#define LED2_PORTPORTD
#define LED2(1<#define LED2_ONLED2_PORT |= LED2
#define LED2_OFFLED2_PORT &= ~LED2
#define LED2_TOGLED2_PORT ^= LED2

#define KL_PORTPORTD
#define KL1(1<#define KL2(1<//-------------------------- definicje preprocesora ---------------------------------

//---------------------------------------------------------------------------------------------------------------
// ustalamy adres MAC
static uint8_t mymac[6] = {0x00,'K','U','B','U','S'};
// ustalamy adres IP urządzenia
static uint8_t myip[4] = {192,168,0,10};

// ustalamy porty UDP z jakich będziemy korzystać
// może ich być dowolna ilość
static uint16_t myport[] = {1200,22700};
// ustalamy adres IP bramy domyślnej w sieci LAN
static uint8_t gwip[4] = {192,168,0,1};

// ustalamy wielkość bufora dla ramek TCP/UDP
#define BUFFER_SIZE 650
static uint8_t buf[BUFFER_SIZE+1];

// wskaźnik do funkcji zwrotnej własnego zdarzenia UDP_EVENT()
static void (*mk_udp_event_callback)(uint8_t *peer_ip, uint16_t port,
uint16_t datapos, uint16_t len);

// funkcja do rejestracji funkcji zwrotnej w zdarzeniu UDP_EVENT()
void register_udp_event_callback(void (*callback)(uint8_t *peer_ip,
uint16_t port, uint16_t datapos, uint16_t len))
{
mk_udp_event_callback = callback;
}
//---------------------------------------------------------------------------------------------------------------

//---------------------------------- deklaracje funkcji -------------------------------
void ping_callback(uint8_t *ip);

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

void mk_send_udp(uint8_t nr_klawisza);

void udp_event_callback(uint8_t *peer_ip, uint16_t port,
uint16_t datapos, uint16_t len);

void UDP_EVENT(uint16_t *port);

void parse_set_led(char * buf);
void parse_get_led(char * s);
void parse_set_lcd(char * buf);
//---------------------------------- deklaracje funkcji -------------------------------

//---------------------------------- deklaracje zmiennych globalnych -------------------------------
// indeksy adresów IP w postaci przyjaznych nazw
enum ip_names {ip_pc, ip_sterownik1};
// adresy IP sterowników z którymi będziemy się komunikować
// za pomocą protokołu UDP
static uint8_t farip[2][4] = { {192,168,0,11}, {192,168,0,180} };

// timer programowy na usługi funkcji SuperDebounce()
volatile uint8_t Timer1;/* timer programowy 100Hz */

// separator tokenów we własnych ramkach przesyłanych przez UDP
char sep[] = "^";

// przydzielenie kodów we własnych ramkach przesyłanych przez UDP
#define ILOSC_KOMEND 3
enum commands {set_led, get_led, set_lcd};

// tablica wskaźników do funkcji parsujących w pamięci FLASH
void (*parse_fun[ILOSC_KOMEND])(char *buf) PROGMEM = {
parse_set_led,
parse_get_led,
parse_set_lcd
};

//---------------------------------- deklaracje zmiennych globalnych -------------------------------

//======================= main() ================================================
int main(void){

/********** inicjalizacja pinów/portów *********************/
// podświetlenie wyświetlacza LCD
DDRA |= (1<PORTA |= (1<
// po resecie piny klawiszy są wejściami
// podciągnięcie wejść klawiszy do VCC
KL_PORT |= KL1|KL2;

// kierunki pinów diod LED jako wyjścia
LED1_DDR |= LED1;
LED2_DDR |= LED2;
// wyłączenie diod LED
LED1_OFF;
LED2_OFF;

/********** inicjalizacja modułów sprzętowych procesora *********************/
/* Timer2 – inicjalizacja przerwania co 10ms */
TCCR2 |= (1<TCCR2 |= (1<OCR2 = 156;// przerwanie porównania co 10ms (100Hz) było 108 bo 11059200/1024/100
TIMSK = (1<
/********** inicjalizacja funkcji bibliotecznych *********************/
lcd_init();
lcd_str("Start..");

/********** inicjalizacja funkcji obsługi stosu TCP *********************/
/*inicjalizacja układu enc28j60*/
enc28j60Init(mymac);

// konfiguracja diod LED w gnieździe RJ45
// zielona (LEDA) - link
// żółta (LEDB) - rx/tx
// enc28j60PhyWrite(PHLCON,0b0000 0100 0111 01 10);
enc28j60PhyWrite(PHLCON,0x476);

// inicjalizacja stosu TCP
init_ip_arp_udp_tcp(mymac,myip,80);

// inicjalizacja bramy domyślnej
// konieczne dla funkcji klienckich
client_set_gwip(gwip);
/********** inicjalizacja funkcji obsługi stosu TCP *********************/

// zarejestrowanie własnej procedury obsługi/reakcji na ping
register_ping_rec_callback(&ping_callback);

// zarejestrowanie własnej procedury obsługi/reakcji na
// przychodzące pakiety UDP
register_udp_event_callback(udp_event_callback);

/********** włączenie przerwań globalnych *********************/
sei();

/******************************************************/
/************ **********************/
/********** główna pętla programu *********************/
/*********** **********************/
/******************************************************/
while(1){

// zdarzenie sprawdzające czy są jakieś dane
// z sieci/układu ENC28j60
UDP_EVENT(myport);

// przykładowa obsługa klawiszy i wysyłanie
// własnych klienckich ramek UDP do wybranych urządzeń w sieci
SuperDebounce(&PIND, (1< SuperDebounce(&PIND, (1<
}
}
//======================= main() koniec =========================================

/******* funkcja obsługująca komendę set_led ******/
void parse_set_led(char * buf) {
char *wsk;
uint8_t nr_led, led_on;

wsk = strtok_r(NULL, sep, &buf);
if( wsk ) {
nr_led = atoi(wsk);
wsk = strtok_r(NULL, sep, &buf);
if( wsk ) {
led_on = atoi(wsk);
switch( nr_led ) {
case 1: if(led_on) LED1_ON; else LED1_OFF; break;
case 2: if(led_on) LED2_ON; else LED2_OFF; break;
case 3: if(led_on) PORTA |= (1<}
}
}
}

/******* funkcja obsługująca komendę get_led ******/
void parse_get_led(char * s) {
char str[20];
sprintf(str,"%i^%i^%i^%i", get_led, (PIND & (1<>4, (PIND & (1<>5, (PINA & (1<>7 );
make_udp_reply_from_request(buf,str,strlen(str), myport[0]);
}

/******* funkcja obsługująca komendę set_lcd ******/
void parse_set_lcd(char * buf) {
char *wsk, *wsk1;

wsk = strtok_r(NULL, sep, &buf);
wsk1 = strtok_r(NULL, sep, &buf);
if( wsk ) {
lcd_cls();
lcd_str( wsk );
lcd_locate(1,0);
lcd_str( wsk1 );
}
}

/****/
/******* własna funkcja użytkownika w której możemy reagować na ramkę UDP ***********/
/****/
void udp_event_callback(uint8_t *peer_ip, uint16_t port, uint16_t datapos, uint16_t len) {
uint8_t i=0;
char str[40];

// wskaźnik na potrzeby funkcji strtok_r
char *wsk, *reszta;

// wyświetlamy na LCD z jakiego IP nadeszła ramka
// wyświetlamy na jaki port nadeszła ramka
lcd_cls();
lcd_str("UDP from: ");
lcd_int(port);
lcd_locate(1,0);
while(i<4){
lcd_int(peer_ip[i]);
if(3==i) break;
lcd_str(".");
i++;
}

// jeśli ramka przyszła na drugi numer portu z listy myport[]
if(port == myport[1]) {
// odpowiadamy na zapytanie UDP po ten sam port
strcpy(str,"Ramka odpowiedzi UDP");
make_udp_reply_from_request(buf,str,strlen(str), port);

// wysyłamy nową ramkę na dowolny inny port
strcpy((char*)&buf[datapos],"Nowa ramka UDP!");
send_udp_prepare(buf, 1200, farip[ip_pc], 43500);
send_udp_transmit(buf,strlen(str));
}

// jeśli ramka przyszła na pierwszy numer portu z listy myport[]
if(port == myport[0]) {
// sprawdzamy czy zawiera dane
wsk = strtok_r((char*)&buf[datapos], sep, &reszta);
if( wsk ) {
// jeśli zawiera dane to sprawdzamy jaka komenda
switch( atoi(wsk) ) {
// i w zależności od komendy wywołujemy odpowienią
// funkcję parsującą z tabeli wskaźników do funkcji parsujących
// przekazujemy jednocześnie wskaźnik do pozostałej części
// łańcucha z danymi, który funkcje będą parsować we własnym zakresie
case set_led: parse_fun[set_led](reszta); break;
case get_led: parse_fun[get_led](reszta); break;
case set_lcd: parse_fun[set_lcd](reszta);
}
}
}
}

/********** zdarzenie UDP EVENT ***********************/
void UDP_EVENT(uint16_t *port) {
// zmienne tymczasowe (automatyczne)
uint16_t plen, dat_p;
uint16_t dport;
uint8_t is_my_port=0;
uint8_t i=0;

uint8_t udp_data_len=0;

// sprawdzamy czy istnieje nowy odebrany pakiet
plen = enc28j60PacketReceive(BUFFER_SIZE, buf);
// obsługa niższych warstw stosu TCP jak ICMP, ARP itp
// m.inn tą drogą obsługiwane są zewnętrzne PING'i
// w tym miejscu sprawdzane jest od razu czy odczytana ramka
// jest posiada typ jaki obsługiwany jest przez ten stos TCP
// oraz czy jest ona zaadresowana do nas (w numeru IP)
dat_p=packetloop_icmp_tcp(buf,plen);

// jeśli długość odebranej ramki jest większa niż 0
// to oznacza, że mamy do czynienia z prawidłowo odebraną
// ramką wraz z prawidłową sumą kontrolną
// sprawdzamy także, czy na pewno mamy do czynienia z ramką UDP a nie np TCP
if( plen && buf[IP_PROTO_P]==IP_PROTO_UDP_V ) {

// sprawdzamy do jakiego nr portu kierowana jest ta ramka UDP
dport = (buf[UDP_DST_PORT_H_P]<<8) | buf[UDP_DST_PORT_L_P];

// sprawdzamy w pętli czy jest to ramka przeznaczona do
// portu nasłuchowego, które obsługuje nasze urządzenie
// listę dowolnej ilości portów definiujemy w tablicy myport[]
// która przekazywana jest jako parametr do zdarzenia/funkcji UDP_EVENT()
do {
if( (is_my_port = (port[i++] == dport)) ) break;
} while (i
// sprawdzamy czy informacja przyszła na obsługiwany przez nas port UDP
if ( is_my_port ){
udp_data_len=buf[UDP_LEN_L_P]-UDP_HEADER_LEN;

// jeśli wszystko się zgadza to sprawdzamy, czy zarejestrowana jest
// funkcja zwrotna przez użytkownika. Jeśli nie jest zarejestrowana
// to nie wykonana się żadna akcja poza powyżej obsługą
// niższych warstw stosu TCP (np PING czy ARP)
// Jeśli jest zarejestrowana to zostanie wywołana z odpowiednimi parametrami
// 1. podany będzie adres IP skąd nadeszła ramka
// 2. podany będzie port na jaki została do nas skierowana ramka
// 3. indeks do bufora całej ramki TCP, wskazujący na początek danych w ramce UDP
// 4. ilość danych w bajtach przesłanych w ramce UDP
if(mk_udp_event_callback) (*mk_udp_event_callback)(&(buf[IP_SRC_P]), dport, UDP_DATA_P, udp_data_len);
}
}
}

/******* funkcja wysyłająca własne dane przez UDP w zależności od klawisza ******/
void mk_send_udp(uint8_t nr_klawisza) {
char str[30];
// przygotowanie własnej ramki (tekest) oraz np numer wciśniętego klawisza
sprintf(str,"SuperDebounce klawsz nr: %i", nr_klawisza);
// przesłanie ramki do wybranego adresu IP pod wskazany (dowolny) port
// w tym przypadku wysyłamy dane do komputera PC
send_udp(buf, str, strlen(str), 1100, farip[ip_pc], 21000);
}

/******* funkcja callback ping *********/
// dzięki tej funkcji zwrotnej możemy dowiedzieć się
// jaki adres IP PING'uje nasz układ i reagować na
// to w specyficzny sposób
void ping_callback(uint8_t *ip) {
// za każdym razem gdy przychodzi PING do naszego urządzenia
// zmieniamy stan diody LED na przeciwny
LED1_TOG;
}

/************** funkcja SuperDebounce do obsługi pojedynczych klawiszy ***************
* AUTOR: Mirosław Kardaś
* ZALETY:
* - nie wprowadza najmniejszego spowalnienia
* - posiada funkcję REPEAT (powtarzanie akcji dla dłużej wciśniętego przycisku)
* - można przydzielić różne akcje dla trybu REPEAT i pojedynczego kliknięcia
* - można przydzielić tylko jedną akcję wtedy w miejsce drugiej przekazujemy 0 (NULL)
* - zabezpieczenie przed naciśnięciem dwóch klawiszy jednocześnie
*
* Wymagania:
* Timer programowy utworzony w oparciu o Timer sprzętowy (przerwanie 100Hz)
*
* Parametry wejściowe - 6 :
* *KPIN - nazwa PINx portu na którym umieszczony jest klawisz, np: PINB
* key_mask - maska klawisza np: (1< * rep_time - czas powtarzania funkcji rep_proc w trybie REPEAT
* rep_wait - czas oczekiwania do przejścia do trybu REPEAT
* push_proc - wskaźnik do własnej funkcji wywoływanej raz po zwolenieniu przycisku
* rep_proc - wskaźnik do własnej funkcji wykonywanej w trybie REPEAT
**************************************************************************************/
void SuperDebounce(volatile uint8_t *KPIN,
uint8_t key_mask, uint16_t rep_time, uint16_t rep_wait,
void (*push_proc)(uint8_t), void (*rep_proc)(uint8_t) ) {

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_stateif(push_proc) push_proc(key_mask);/* 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_mask);/* KEY_REP */
}
}

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

/**** obsługa przerwania Timer2 CompareMatch *****/
// potrzebnego do realizacji timera programowego dla SuperDebounce()
// można je wykorzystać na utworzenie dodatkowych własnych timerów programowych
ISR(TIMER2_COMP_vect)
{
uint8_t n;

n = Timer1;/* 100Hz Timer1 */
if (n) Timer1 = --n;
}[/syntax]

Statystyki: Napisane przez mirek1968 — 1 sie 2014, o 10:09

Re: Wysyłanie i odbieranie danych poprzez serwer UDP_etherne

2014-08-01T03:50:19+01:00

mirek1968 napisał(a):

W programie Klient/serwer UDP jest tam takie okno adres IP urzadzenia czy tam mam wpisać adres IP z mojej atmegi?

No pewnie że adres procka.

mirek1968 napisał(a):

Następna sprawa nie rozumiem tych numerów portów UDP

Gdy działasz w sieci lokalnej (mam nadzieję) ... to po co konfigurować porty na routerze? nie trzeba ... Ja nie za bardzo rozumiem czego nie rozumiesz w tych portach jak mówisz? ot są to przykładowe porty strzelone z głowy. Jak chcesz możesz je zamienić na dowolne inne ale musisz pamiętać aby wtedy je wszędzie w programie też podmienić. Nie mniej jednak po co mieszać na początek ? Lepiej odpalić to tak jak jest bo na 100000% to działa - a jeśli nie to pewnie robisz jakiegoś babola ... ale może zaraz się coś wyjaśni.

mirek1968 napisał(a):

Następne pytanie jakie adresy powinienem wpisać poniżej??

I tu pewnie leży pies pogrzebany - bo przecież w Bluebooku opisuję ten kod dokładnie i do czego są jakie adresy .. ale już przypominam:

linia kodu:

[syntax=c]// indeksy adresów IP w postaci przyjaznych nazw
enum ip_names {ip_pc, ip_sterownik1};[/syntax]
mówi o tym, który adres w tej tablicy za co odpowiada, więc widać że pierwszy, te o indexie = 0 {ip_pc}, to adres naszego komputera gdzie masz odpalony program do testowania UDP, a drugi adres {ip_sterownik1} to jakiś np inny procek gdybyś testował ... ale jest on chyba nawet w programie nie używany ... pokazałem tylko że można w ten sposób dodać adresy kolejnych urządzeń bądź komputerów z którymi chcemy się kontaktować. Więc pierwszym adresem w tej tabeli:

[syntax=c]static uint8_t farip[2][4] = { {192,168,0,10}, {192,168,0,11} };[/syntax]

powinien być koniecznie adres twojego komputera, a drugi ? nie ważne na razie jaki będzie

mirek1968 napisał(a):

Wpisałem tu adres Atmegi oraz swojego laptopa jako druga pozycja ale nie jestem pewien czy dobrze zrobiłem??

No to teraz już chyba widzisz, że niedobrze zrobiłeś (bo adres twojego kompa - lapka) powinien być jako pierwszy a drugi jest nieistotny w tym przykładzie programu

mirek1968 napisał(a):

Następne pytanie dotyczące programu Klient/serwer UDP czy zapalanie i gaszenie diód led 1 i 2 jest skonfigurowane w tym programie i przydzielone do konkretnych wyjść czy też niema to znaczenia na jakich wyjściach mam diody LED w swoim projekcie?

Programu na PC nie interesuje na jakich pinach masz diody panie kochany - to sobie ustalasz w programie w procku

mirek1968 napisał(a):

Poniżej znajduje się mój plik main i proszę o korektę i pomoc bo poza serwerem nic mi nie działa na UDP

Programu na razie nie mam czasu analizować - proponuję NAJPIERW zawsze odpal to tak jak z książki - żeby zobaczyć że rusza i działa - a później dopiero modyfikuj kod ... bo tak, to sam sobie dodatkowe problemy robisz gdy namodyfikujesz kod i nic ci nie działa. Mówię tu o modyfikacjach poza tymi konfiguracyjnymi odnośnie adresów IP

Statystyki: Napisane przez mirekk36 — 1 sie 2014, o 03:50

Wysyłanie i odbieranie danych poprzez serwer UDP_ethernet

2014-07-31T23:43:37+01:00

Mam problem z wysyłaniem i odbieraniem danych poprzez moduł karty ethernetowej ENC28J60 na Atmegę 16 taktowaną kwarcem 16MHz.
pierwsza częśc opisana w BB dotycząca serwera działa mi dobrze ,natomiast z nadawaniem i odbieraniem ramek mam problem.Korzystam z programu Klient/serwer UDP zamieszczonego na płycie cd z BB i nie potrafię nic wysterować na mojej płytce testowej.Mam kilka pytań co do tego programu oraz do poprawności mojego kodu w c.
W programie Klient/serwer UDP jest tam takie okno adres IP urzadzenia czy tam mam wpisać adres IP z mojej atmegi? czyli 192,168,0,10 czy też może adres IP mojego laptopa?? 192,168,0,11 ?
Następna sprawa nie rozumiem tych numerów portów UDP
[syntax=c]// ustalamy porty UDP z jakich będziemy korzystać
// może ich być dowolna ilość
static uint16_t myport[] = {1200,22700};[/syntax]

Dlaczego 1200 i 22700 osobiście nie mam dostępu do parametrów mojego routera i niewiem czy tam mam to wpisać jak w przykładzie.

Następne pytanie jakie adresy powinienem wpisać poniżej??

[syntax=c]// indeksy adresów IP w postaci przyjaznych nazw
enum ip_names {ip_pc, ip_sterownik1};
// adresy IP sterowników z którymi będziemy się komunikować
// za pomocą protokołu UDP
static uint8_t farip[2][4] = { {192,168,0,10}, {192,168,0,11} };[/syntax]

Wpisałem tu adres Atmegi oraz swojego laptopa jako druga pozycja ale nie jestem pewien czy dobrze zrobiłem??
Następne pytanie dotyczące programu Klient/serwer UDP czy zapalanie i gaszenie diód led 1 i 2 jest skonfigurowane w tym programie i przydzielone do konkretnych wyjść czy też niema to znaczenia na jakich wyjściach mam diody LED w swoim projekcie?

Poniżej znajduje się mój plik main i proszę o korektę i pomoc bo poza serwerem nic mi nie działa na UDP

[syntax=c]/*********************************************
* vim:sw=8:ts=8:si:et
* To use the above modeline in vim you must have "set modeline" in your .vimrc
* Author: Guido Socher
* Copyright: GPL V2
*
* Tuxgraphics AVR webserver/ethernet board
*
* http://tuxgraphics.org/electronics/
* Chip type : Atmega88/168/328 with ENC28J60
*
*
* ---> OBSŁUGA KLIENT/SERWER komunikacji UDP <-----
* MODYFIKACJE: Mirosław Kardaś --- ATmega32
*
*********************************************/
#include
#include
#include
#include
#include
#include
#include "ip_arp_udp_tcp.h"
#include "enc28j60.h"
#include "util/delay.h"
#include "net.h"

#include "LCD/lcd44780.h"

//-------------------------- definicje preprocesora ---------------------------------
#define LED1_DDRDDRD
#define LED1_PORTPORTD
#define LED1(1<#define LED1_ONLED1_PORT |= LED1
#define LED1_OFFLED1_PORT &= ~LED1
#define LED1_TOGLED1_PORT ^= LED1

#define LED2_DDRDDRD
#define LED2_PORTPORTD
#define LED2(1<#define LED2_ONLED2_PORT |= LED2
#define LED2_OFFLED2_PORT &= ~LED2
#define LED2_TOGLED2_PORT ^= LED2

#define KL_PORTPORTD
#define KL1(1<#define KL2(1<//-------------------------- definicje preprocesora ---------------------------------

//---------------------------------------------------------------------------------------------------------------
// ustalamy adres MAC
static uint8_t mymac[6] = {0x00,'K','U','B','U','S'};
// ustalamy adres IP urządzenia
static uint8_t myip[4] = {192,168,0,10};

// ustalamy porty UDP z jakich będziemy korzystać
// może ich być dowolna ilość
static uint16_t myport[] = {1200,22700};
// ustalamy adres IP bramy domyślnej w sieci LAN
static uint8_t gwip[4] = {192,168,0,1};

// ustalamy wielkość bufora dla ramek TCP/UDP
#define BUFFER_SIZE 650
static uint8_t buf[BUFFER_SIZE+1];

// wskaźnik do funkcji zwrotnej własnego zdarzenia UDP_EVENT()
static void (*mk_udp_event_callback)(uint8_t *peer_ip, uint16_t port,
uint16_t datapos, uint16_t len);

// funkcja do rejestracji funkcji zwrotnej w zdarzeniu UDP_EVENT()
void register_udp_event_callback(void (*callback)(uint8_t *peer_ip,
uint16_t port, uint16_t datapos, uint16_t len))
{
mk_udp_event_callback = callback;
}
//---------------------------------------------------------------------------------------------------------------

//---------------------------------- deklaracje funkcji -------------------------------
void ping_callback(uint8_t *ip);

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

void mk_send_udp(uint8_t nr_klawisza);

void udp_event_callback(uint8_t *peer_ip, uint16_t port,
uint16_t datapos, uint16_t len);

void UDP_EVENT(uint16_t *port);

void parse_set_led(char * buf);
void parse_get_led(char * s);
void parse_set_lcd(char * buf);
//---------------------------------- deklaracje funkcji -------------------------------

//---------------------------------- deklaracje zmiennych globalnych -------------------------------
// indeksy adresów IP w postaci przyjaznych nazw
enum ip_names {ip_pc, ip_sterownik1};
// adresy IP sterowników z którymi będziemy się komunikować
// za pomocą protokołu UDP
static uint8_t farip[2][4] = { {192,168,0,10}, {192,168,0,11} };

// timer programowy na usługi funkcji SuperDebounce()
volatile uint8_t Timer1;/* timer programowy 100Hz */

// separator tokenów we własnych ramkach przesyłanych przez UDP
char sep[] = "^";

// przydzielenie kodów we własnych ramkach przesyłanych przez UDP
#define ILOSC_KOMEND 3
enum commands {set_led, get_led, set_lcd};

// tablica wskaźników do funkcji parsujących w pamięci FLASH
void (*parse_fun[ILOSC_KOMEND])(char *buf) PROGMEM = {
parse_set_led,
parse_get_led,
parse_set_lcd
};

//---------------------------------- deklaracje zmiennych globalnych -------------------------------

//======================= main() ================================================
int main(void){

/********** inicjalizacja pinów/portów *********************/
// podświetlenie wyświetlacza LCD
DDRA |= (1<PORTA |= (1<
// po resecie piny klawiszy są wejściami
// podciągnięcie wejść klawiszy do VCC
KL_PORT |= KL1|KL2;

// kierunki pinów diod LED jako wyjścia
LED1_DDR |= LED1;
LED2_DDR |= LED2;
// wyłączenie diod LED
LED1_OFF;
LED2_OFF;

/********** inicjalizacja modułów sprzętowych procesora *********************/
/* Timer2 – inicjalizacja przerwania co 10ms */
TCCR2 |= (1<TCCR2 |= (1<OCR2 = 156;// przerwanie porównania co 10ms (100Hz) było 108 bo 11059200/1024/100
TIMSK = (1<
/********** inicjalizacja funkcji bibliotecznych *********************/
lcd_init();
lcd_str("Start..");

/********** inicjalizacja funkcji obsługi stosu TCP *********************/
/*inicjalizacja układu enc28j60*/
enc28j60Init(mymac);

// konfiguracja diod LED w gnieździe RJ45
// zielona (LEDA) - link
// żółta (LEDB) - rx/tx
// enc28j60PhyWrite(PHLCON,0b0000 0100 0111 01 10);
enc28j60PhyWrite(PHLCON,0x476);

// inicjalizacja stosu TCP
init_ip_arp_udp_tcp(mymac,myip,80);

// inicjalizacja bramy domyślnej
// konieczne dla funkcji klienckich
client_set_gwip(gwip);
/********** inicjalizacja funkcji obsługi stosu TCP *********************/

// zarejestrowanie własnej procedury obsługi/reakcji na ping
register_ping_rec_callback(&ping_callback);

// zarejestrowanie własnej procedury obsługi/reakcji na
// przychodzące pakiety UDP
register_udp_event_callback(udp_event_callback);

/********** włączenie przerwań globalnych *********************/
sei();

/******************************************************/
/************ **********************/
/********** główna pętla programu *********************/
/*********** **********************/
/******************************************************/
while(1){

// zdarzenie sprawdzające czy są jakieś dane
// z sieci/układu ENC28j60
UDP_EVENT(myport);

// przykładowa obsługa klawiszy i wysyłanie
// własnych klienckich ramek UDP do wybranych urządzeń w sieci
SuperDebounce(&PIND, (1< SuperDebounce(&PIND, (1<
}
}
//======================= main() koniec =========================================

/******* funkcja obsługująca komendę set_led ******/
void parse_set_led(char * buf) {
char *wsk;
uint8_t nr_led, led_on;

wsk = strtok_r(NULL, sep, &buf);
if( wsk ) {
nr_led = atoi(wsk);
wsk = strtok_r(NULL, sep, &buf);
if( wsk ) {
led_on = atoi(wsk);
switch( nr_led ) {
case 1: if(led_on) LED1_ON; else LED1_OFF; break;
case 2: if(led_on) LED2_ON; else LED2_OFF; break;
case 3: if(led_on) PORTA |= (1<}
}
}
}

/******* funkcja obsługująca komendę get_led ******/
void parse_get_led(char * s) {
char str[20];
sprintf(str,"%i^%i^%i^%i", get_led, (PIND & (1<>4, (PIND & (1<>5, (PINA & (1<>7 );
make_udp_reply_from_request(buf,str,strlen(str), myport[0]);
}

/******* funkcja obsługująca komendę set_lcd ******/
void parse_set_lcd(char * buf) {
char *wsk, *wsk1;

wsk = strtok_r(NULL, sep, &buf);
wsk1 = strtok_r(NULL, sep, &buf);
if( wsk ) {
lcd_cls();
lcd_str( wsk );
lcd_locate(1,0);
lcd_str( wsk1 );
}
}

/****/
/******* własna funkcja użytkownika w której możemy reagować na ramkę UDP ***********/
/****/
void udp_event_callback(uint8_t *peer_ip, uint16_t port, uint16_t datapos, uint16_t len) {
uint8_t i=0;
char str[40];

// wskaźnik na potrzeby funkcji strtok_r
char *wsk, *reszta;

// wyświetlamy na LCD z jakiego IP nadeszła ramka
// wyświetlamy na jaki port nadeszła ramka
lcd_cls();
lcd_str("UDP from: ");
lcd_int(port);
lcd_locate(1,0);
while(i<4){
lcd_int(peer_ip[i]);
if(3==i) break;
lcd_str(".");
i++;
}

// jeśli ramka przyszła na drugi numer portu z listy myport[]
if(port == myport[1]) {
// odpowiadamy na zapytanie UDP po ten sam port
strcpy(str,"Ramka odpowiedzi UDP");
make_udp_reply_from_request(buf,str,strlen(str), port);

// wysyłamy nową ramkę na dowolny inny port
strcpy((char*)&buf[datapos],"Nowa ramka UDP!");
send_udp_prepare(buf, 1200, farip[ip_pc], 43500);
send_udp_transmit(buf,strlen(str));
}

// jeśli ramka przyszła na pierwszy numer portu z listy myport[]
if(port == myport[0]) {
// sprawdzamy czy zawiera dane
wsk = strtok_r((char*)&buf[datapos], sep, &reszta);
if( wsk ) {
// jeśli zawiera dane to sprawdzamy jaka komenda
switch( atoi(wsk) ) {
// i w zależności od komendy wywołujemy odpowienią
// funkcję parsującą z tabeli wskaźników do funkcji parsujących
// przekazujemy jednocześnie wskaźnik do pozostałej części
// łańcucha z danymi, który funkcje będą parsować we własnym zakresie
case set_led: parse_fun[set_led](reszta); break;
case get_led: parse_fun[get_led](reszta); break;
case set_lcd: parse_fun[set_lcd](reszta);
}
}
}
}

/********** zdarzenie UDP EVENT ***********************/
void UDP_EVENT(uint16_t *port) {
// zmienne tymczasowe (automatyczne)
uint16_t plen, dat_p;
uint16_t dport;
uint8_t is_my_port=0;
uint8_t i=0;

uint8_t udp_data_len=0;

// sprawdzamy czy istnieje nowy odebrany pakiet
plen = enc28j60PacketReceive(BUFFER_SIZE, buf);
// obsługa niższych warstw stosu TCP jak ICMP, ARP itp
// m.inn tą drogą obsługiwane są zewnętrzne PING'i
// w tym miejscu sprawdzane jest od razu czy odczytana ramka
// jest posiada typ jaki obsługiwany jest przez ten stos TCP
// oraz czy jest ona zaadresowana do nas (w numeru IP)
dat_p=packetloop_icmp_tcp(buf,plen);

// jeśli długość odebranej ramki jest większa niż 0
// to oznacza, że mamy do czynienia z prawidłowo odebraną
// ramką wraz z prawidłową sumą kontrolną
// sprawdzamy także, czy na pewno mamy do czynienia z ramką UDP a nie np TCP
if( plen && buf[IP_PROTO_P]==IP_PROTO_UDP_V ) {

// sprawdzamy do jakiego nr portu kierowana jest ta ramka UDP
dport = (buf[UDP_DST_PORT_H_P]<<8) | buf[UDP_DST_PORT_L_P];

// sprawdzamy w pętli czy jest to ramka przeznaczona do
// portu nasłuchowego, które obsługuje nasze urządzenie
// listę dowolnej ilości portów definiujemy w tablicy myport[]
// która przekazywana jest jako parametr do zdarzenia/funkcji UDP_EVENT()
do {
if( (is_my_port = (port[i++] == dport)) ) break;
} while (i
// sprawdzamy czy informacja przyszła na obsługiwany przez nas port UDP
if ( is_my_port ){
udp_data_len=buf[UDP_LEN_L_P]-UDP_HEADER_LEN;

// jeśli wszystko się zgadza to sprawdzamy, czy zarejestrowana jest
// funkcja zwrotna przez użytkownika. Jeśli nie jest zarejestrowana
// to nie wykonana się żadna akcja poza powyżej obsługą
// niższych warstw stosu TCP (np PING czy ARP)
// Jeśli jest zarejestrowana to zostanie wywołana z odpowiednimi parametrami
// 1. podany będzie adres IP skąd nadeszła ramka
// 2. podany będzie port na jaki została do nas skierowana ramka
// 3. indeks do bufora całej ramki TCP, wskazujący na początek danych w ramce UDP
// 4. ilość danych w bajtach przesłanych w ramce UDP
if(mk_udp_event_callback) (*mk_udp_event_callback)(&(buf[IP_SRC_P]), dport, UDP_DATA_P, udp_data_len);
}
}
}

/******* funkcja wysyłająca własne dane przez UDP w zależności od klawisza ******/
void mk_send_udp(uint8_t nr_klawisza) {
char str[30];
// przygotowanie własnej ramki (tekest) oraz np numer wciśniętego klawisza
sprintf(str,"SuperDebounce klawsz nr: %i", nr_klawisza);
// przesłanie ramki do wybranego adresu IP pod wskazany (dowolny) port
// w tym przypadku wysyłamy dane do komputera PC
send_udp(buf, str, strlen(str), 1100, farip[ip_pc], 21000);
}

/******* funkcja callback ping *********/
// dzięki tej funkcji zwrotnej możemy dowiedzieć się
// jaki adres IP PING'uje nasz układ i reagować na
// to w specyficzny sposób
void ping_callback(uint8_t *ip) {
// za każdym razem gdy przychodzi PING do naszego urządzenia
// zmieniamy stan diody LED na przeciwny
LED1_TOG;
}

/************** funkcja SuperDebounce do obsługi pojedynczych klawiszy ***************
* AUTOR: Mirosław Kardaś
* ZALETY:
* - nie wprowadza najmniejszego spowalnienia
* - posiada funkcję REPEAT (powtarzanie akcji dla dłużej wciśniętego przycisku)
* - można przydzielić różne akcje dla trybu REPEAT i pojedynczego kliknięcia
* - można przydzielić tylko jedną akcję wtedy w miejsce drugiej przekazujemy 0 (NULL)
* - zabezpieczenie przed naciśnięciem dwóch klawiszy jednocześnie
*
* Wymagania:
* Timer programowy utworzony w oparciu o Timer sprzętowy (przerwanie 100Hz)
*
* Parametry wejściowe - 6 :
* *KPIN - nazwa PINx portu na którym umieszczony jest klawisz, np: PINB
* key_mask - maska klawisza np: (1< * rep_time - czas powtarzania funkcji rep_proc w trybie REPEAT
* rep_wait - czas oczekiwania do przejścia do trybu REPEAT
* push_proc - wskaźnik do własnej funkcji wywoływanej raz po zwolenieniu przycisku
* rep_proc - wskaźnik do własnej funkcji wykonywanej w trybie REPEAT
**************************************************************************************/
void SuperDebounce(volatile uint8_t *KPIN,
uint8_t key_mask, uint16_t rep_time, uint16_t rep_wait,
void (*push_proc)(uint8_t), void (*rep_proc)(uint8_t) ) {

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_stateif(push_proc) push_proc(key_mask);/* 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_mask);/* KEY_REP */
}
}

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

/**** obsługa przerwania Timer2 CompareMatch *****/
// potrzebnego do realizacji timera programowego dla SuperDebounce()
// można je wykorzystać na utworzenie dodatkowych własnych timerów programowych
ISR(TIMER2_COMP_vect)
{
uint8_t n;

n = Timer1;/* 100Hz Timer1 */
if (n) Timer1 = --n;
}[/syntax]

Statystyki: Napisane przez mirek1968 — 31 lip 2014, o 23:43