WebSVN – svnkaklik – Diff – /programy/C/avr/RS232toRS485/P232.c


// 1.6.2007
//----------------------------------------------------------------------------------
//	Prevodnik RS232 <--> RS485
//	pri startbitu na RS232 zapne okamzite vysilac pokud nejsou detekovana data z RS485.
//----------------------------------------------------------------------------------
//Program je urcen k rizeni toku dat v prevodniku RS232 na RS485. S cilem eliminovat jakekoliv prvky nastavovene uzivatelem 
//bez nutnosti pouziti hardwaroveho rizeni toku. Program tedy dokaze detekovat prenosovou rychlost, paritni bit a stopbit.  
//
//
//Algoritmus:
//  Princip je zalozen na mereni nejkratsiho casoveho useku v osmi vzorcich, delka vzorku 
//  se odviji od velikosti prave nejmensiho zmereneho vzorku.
//  Vzorek se meri pomoci 8mi bitoveho casovace a interruptu od zmeny vstupu. casovac je osetren
//  proti pretekani (pocet preteceni se uklada, do promenne s ktere se zpetne vypocita 16bitove cislo, 
//  casovac se tedy virtualne chova jako 16ti bitovy.)
//  Mereni delky bitu 
//  
//  Aktualni implementace teto metody se chova tak, ze pokud je vyslan bajt ktery po startbitu obsahuje N 
//  stejnych bitu, tak je tato sekvence detekovana jako jeden bit to zpusobi ze detekovana rychlost je N krat 
//  mensi, nez skutecna. Dusledkem je, ze pokud se jeste pred stopbitem neobjevi samostatny bit s jinou hodnotou, 
//  nez predchozi sekvence. Tak bude vysílání povoleno po dubu osminásobku zmìøené délky "bitu" plus dalí dva bity jako stopbity.
//  
//
//Vlastnosti:
//  Tento program je shopen detekovat pararitní bit, ale neni shopen detekovat poèet stopbitù.
//  To znamená e kdy bude parita logická jedna, tak bude rozpoznána jako stop bit.
//  Tato vlastnost ale pøíli nevadí, protoe chování algoritmu lze upravit tak, e bude predpokládat dva nebo tøi stopbity.
//  V takovém pøípadì se packet pøenese korektnì i kdy parita bude jedna, i nula.
//   
// Tento zpusob detekce neni imuni proti nahodnym chybovim spickam vzniklych v dusledku ruseni. 
// Proto je nutene napajeni kvalitne stbilizovat, pouzivat blokovaci kondenzatory a 
// zabezpecit, aby nedochazelo ke zvedani zeme.
////////////////////////////////////////////////////////////////////////////////////////
//
//Autor: Jakub Kakona (kaklik@mlab.cz)
//
////////////////////////////////////////////////////////////////////////////////////////
//TODO:
//  Optimalizovat kod, (hlavne najit casove vyhodnejsi umisteni pro nastavovani defaultnich hodnot promennych)
//  Bylo bydobre zavest uspavani pred prijetim bajtu.
//  Vykouset program na ATtiny13
//  Pri rychlostech mensich nez 9600kbps dochazi k pretekani promennych a algoritmus se nechova korektne.
//  Neni vyzkousen break, byly testovany pouze ASCII znaky vysilane pres terminal z klavesnice.  
//  Aktivovat WatchDog timer.
//  Neni vyzkouseno na vyssím taktu CPU jak 3,7MHz
//////////////////////////////////////////////////////////////////////////////////////
//
 
 
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include <ctype.h>
#include <avr/eeprom.h>
#include <avr/pgmspace.h>
 
#define POVOLOVAK_LOW	PORTB &= ~(1<<PB3)   // nastaveni nuly na vystup, krery zapina povoleni vysilani RS485
#define POVOLOVAK_HIGH  PORTB |= (1<<PB3)    // nastaveni jednicky na tentyz vystup
#define DATA	(PIND & (1<<PD3))			// nastaveni vstupu, na kterem se budou detekovat data, musi byt stejny jako vstup pouziteho interruptu 
 
volatile unsigned int preteceni;  // promenna na ukladani poctu preteceni casovace
volatile unsigned int bit;		// promena pro pocitani bitu v bajtu
volatile unsigned long int bitdelay; // obsahuje aktualni zmereny cas delky bitu
volatile unsigned long int cas;		// urcuje nejkratsi nalezeny cas delky bitu
 
ISR(TIMER0_OVF_vect)   // interrupt od preteceni casovace
{
  preteceni++;			// kdyz pretece, poznamenej to.
}
 
ISR(INT1_vect)   // interrupt od zmeny vstupu na datech
{
  if ((bitdelay=(TCNT0+preteceni*0x0100)) < cas) cas = bitdelay; // provnani jestli zrovna zmereny cas je kratsi nez nejmensi znamy cas   
  TCNT0 = 0;					// zacni znova merit cas zacatku stopbitu
  preteceni=0;				// vynuluj vsechny casove promenne
  bit++;		// posun pocitadlo bitu o jednicku 
}
 
// ------------------------------------------------------------------
//	Main
// ------------------------------------------------------------------
int main(void)
{
int stopbit;
int ctvrtbit;
 
/*typedef struct {		// struktura pro celoèíselné dìlení 
int quot;
int rem;
} div_t;*/
 
 
  DDRB |= (1<<DDB3);     // povoleni vystupu na povolovak 
 
  TIMSK |= (1 << TOIE0); // Enable timer overflow interrupt
 
  MCUCR |= (1 << ISC10); // nastaveni preruseni od zmeny vstupu pro interrupt INT0
  GIMSK |= (1 << INT1);  // povoleni interruptu INT0
   
  TCCR0B |= (1 << CS00);  // Set up timer 
 
  sei();   // enable interrupts
 
  while(1)
  {
	if(!DATA)   // kdyz je 0 na datech 
	{ 
	  POVOLOVAK_HIGH;    // zapni vysilani
 
      TCNT0=0;
      preteceni=0;
	  bit=0;			// vynuluj vsechny promenne pro mereni casu a pocitani bitu
	  cas = 0xFFFF;    // nastav cas delky bitu na nejvetsi mozny
	  	  	  	  
	  while (bit <= 8)  // odpocitej dobu 8mi bitu
	  {
	    if ((TCNT0+preteceni*0x0100) >= (cas + (ctvrtbit = cas >> 2))) // zkontroluj jestli necekame na dalsi bit dele nez je nekratsi znema delka bitu
// v kontrole je rezerva delky ctvrt bitu
		{
		  bit++;						// pokud jsme cekali dele, tak bit uz ubehl, to znamena, ze muzeme pocitadlo bitu posunout o jednicku
//		  div(ctvrtbit,0x0100);			// funkce pro implementaci celociselneho deleni zustava ale nepouzita kvuli nutnosti zavest datove struktury, bude ji nutno pouzit pro vetsi rychlosti   
          TCNT0 = ctvrtbit % 0x0100; //reminder; 					// zacni znova merit cas do dalsiho mozneho bitu 
          preteceni = ctvrtbit/0x0100; //quota;
		} 
	  }
 
	  while (!DATA);				// cekani na stop bit (detekce pripadneho paritniho bitu)
 
	  for (stopbit=2;stopbit >= 0;stopbit--)    // odpocitej dva stopbity
	  {
	    while ((TCNT0+preteceni*0x0100) <= cas) 
		{
		  if(!DATA) break;
        }
	  }
    }
    else  POVOLOVAK_LOW;  	// kdyz je 1 prepni na prijem 
  }
  return(0);
}

Subversion Repositories svnkaklik

(root)/programy/C/avr/RS232toRS485/P232.c @ 509 – Rev 409 → 410

Rev 409		Rev 410
1	`// 1.6.2007`	1	`// 1.6.2007`
2	`//----------------------------------------------------------------------------------`	2	`//----------------------------------------------------------------------------------`
3	`// Prevodnik RS232 <--> RS485`	3	`// Prevodnik RS232 <--> RS485`
4	`// pri startbitu na RS232 zapne okamzite vysilac pokud nejsou detekovana data z RS485.`	4	`// pri startbitu na RS232 zapne okamzite vysilac pokud nejsou detekovana data z RS485.`
5	`//----------------------------------------------------------------------------------`	5	`//----------------------------------------------------------------------------------`
6	`//Program je urcen k rizeni toku dat v prevodniku RS232 na RS485. S cilem eliminovat jakekoliv prvky nastavovene uzivatelem`	6	`//Program je urcen k rizeni toku dat v prevodniku RS232 na RS485. S cilem eliminovat jakekoliv prvky nastavovene uzivatelem`
7	`//bez nutnosti pouziti hardwaroveho rizeni toku. Program tedy dokaze detekovat prenosovou rychlost, paritni bit a stopbit.`	7	`//bez nutnosti pouziti hardwaroveho rizeni toku. Program tedy dokaze detekovat prenosovou rychlost, paritni bit a stopbit.`
8	`//`	8	`//`
9	`//`	9	`//`
10	`//Algoritmus:`	10	`//Algoritmus:`
11	`// Princip je zalozen na mereni nejkratsiho casoveho useku v osmi vzorcich, delka vzorku`	11	`// Princip je zalozen na mereni nejkratsiho casoveho useku v osmi vzorcich, delka vzorku`
12	`// se odviji od velikosti prave nejmensiho zmereneho vzorku.`	12	`// se odviji od velikosti prave nejmensiho zmereneho vzorku.`
13	`// Vzorek se meri pomoci 8mi bitoveho casovace a interruptu od zmeny vstupu. casovac je osetren`	13	`// Vzorek se meri pomoci 8mi bitoveho casovace a interruptu od zmeny vstupu. casovac je osetren`
14	`// proti pretekani (pocet preteceni se uklada, do promenne s ktere se zpetne vypocita 16bitove cislo,`	14	`// proti pretekani (pocet preteceni se uklada, do promenne s ktere se zpetne vypocita 16bitove cislo,`
15	`// casovac se tedy virtualne chova jako 16ti bitovy.)`	15	`// casovac se tedy virtualne chova jako 16ti bitovy.)`
16	`// Mereni delky bitu`	16	`// Mereni delky bitu`
17	`//`	17	`//`
18	`// Aktualni implementace teto metody se chova tak, ze pokud je vyslan bajt ktery po startbitu obsahuje N`	18	`// Aktualni implementace teto metody se chova tak, ze pokud je vyslan bajt ktery po startbitu obsahuje N`
19	`// stejnych bitu, tak je tato sekvence detekovana jako jeden bit to zpusobi ze detekovana rychlost je N krat`	19	`// stejnych bitu, tak je tato sekvence detekovana jako jeden bit to zpusobi ze detekovana rychlost je N krat`
20	`// mensi, nez skutecna. Dusledkem je, ze pokud se jeste pred stopbitem neobjevi samostatny bit s jinou hodnotou,`	20	`// mensi, nez skutecna. Dusledkem je, ze pokud se jeste pred stopbitem neobjevi samostatny bit s jinou hodnotou,`
21	`// nez predchozi sekvence. Tak bude vysílání povoleno po dubu osminásobku zmìøené délky "bitu" plus dalí dva bity jako stopbity.`	21	`// nez predchozi sekvence. Tak bude vysílání povoleno po dubu osminásobku zmìøené délky "bitu" plus dalí dva bity jako stopbity.`
22	`//`	22	`//`
23	`//`	23	`//`
24	`//Vlastnosti:`	24	`//Vlastnosti:`
25	`// Tento program je shopen detekovat pararitní bit, ale neni shopen detekovat poèet stopbitù.`	25	`// Tento program je shopen detekovat pararitní bit, ale neni shopen detekovat poèet stopbitù.`
26	`// To znamená e kdy bude parita logická jedna, tak bude rozpoznána jako stop bit.`	26	`// To znamená e kdy bude parita logická jedna, tak bude rozpoznána jako stop bit.`
27	`// Tato vlastnost ale pøíli nevadí, protoe chování algoritmu lze upravit tak, e bude predpokládat dva nebo tøi stopbity.`	27	`// Tato vlastnost ale pøíli nevadí, protoe chování algoritmu lze upravit tak, e bude predpokládat dva nebo tøi stopbity.`
28	`// V takovém pøípadì se packet pøenese korektnì i kdy parita bude jedna, i nula.`	28	`// V takovém pøípadì se packet pøenese korektnì i kdy parita bude jedna, i nula.`
29	`//`	29	`//`
30	`// Tento zpusob detekce neni imuni proti nahodnym chybovim spickam vzniklych v dusledku ruseni.`	30	`// Tento zpusob detekce neni imuni proti nahodnym chybovim spickam vzniklych v dusledku ruseni.`
31	`// Proto je nutene napajeni kvalitne stbilizovat, pouzivat blokovaci kondenzatory a`	31	`// Proto je nutene napajeni kvalitne stbilizovat, pouzivat blokovaci kondenzatory a`
32	`// zabezpecit, aby nedochazelo ke zvedani zeme.`	32	`// zabezpecit, aby nedochazelo ke zvedani zeme.`
33	`////////////////////////////////////////////////////////////////////////////////////////`	33	`////////////////////////////////////////////////////////////////////////////////////////`
34	`//`	34	`//`
35	`//Autor: Jakub Kakona (kaklik@mlab.cz)`	35	`//Autor: Jakub Kakona (kaklik@mlab.cz)`
36	`//`	36	`//`
37	`////////////////////////////////////////////////////////////////////////////////////////`	37	`////////////////////////////////////////////////////////////////////////////////////////`
38	`//TODO:`	38	`//TODO:`
39	`// Optimalizovat kod, (hlavne najit casove vyhodnejsi umisteni pro nastavovani defaultnich hodnot promennych)`	39	`// Optimalizovat kod, (hlavne najit casove vyhodnejsi umisteni pro nastavovani defaultnich hodnot promennych)`
40	`// Bylo bydobre zavest uspavani pred prijetim bajtu.`	40	`// Bylo bydobre zavest uspavani pred prijetim bajtu.`
41	`// Vykouset program na ATtiny13`	41	`// Vykouset program na ATtiny13`
42	`// Pri rychlostech mensich nez 9600kbps dochazi k pretekani promennych a algoritmus se nechova korektne.`	42	`// Pri rychlostech mensich nez 9600kbps dochazi k pretekani promennych a algoritmus se nechova korektne.`
43	`// Neni vyzkousen break, byly testovany pouze ASCII znaky vysilane pres terminal z klavesnice.`	43	`// Neni vyzkousen break, byly testovany pouze ASCII znaky vysilane pres terminal z klavesnice.`
44	`// Aktivovat WatchDog timer.`	44	`// Aktivovat WatchDog timer.`
45	`// Neni vyzkouseno na vyssím taktu CPU jak 3,7MHz`	45	`// Neni vyzkouseno na vyssím taktu CPU jak 3,7MHz`
46	`//////////////////////////////////////////////////////////////////////////////////////`	46	`//////////////////////////////////////////////////////////////////////////////////////`
47	`//`	47	`//`
48		48
49		49
50	`#include <avr/io.h>`	50	`#include <avr/io.h>`
51	`#include <avr/interrupt.h>`	51	`#include <avr/interrupt.h>`
52	`#include <stdlib.h>`	52	`#include <stdlib.h>`
53	`#include <ctype.h>`	53	`#include <ctype.h>`
54	`#include <avr/eeprom.h>`	54	`#include <avr/eeprom.h>`
55	`#include <avr/pgmspace.h>`	55	`#include <avr/pgmspace.h>`
56		56
57	`#define POVOLOVAK_LOW PORTB &= ~(1<<PB3) // nastaveni nuly na vystup, krery zapina povoleni vysilani RS485`	57	`#define POVOLOVAK_LOW PORTB &= ~(1<<PB3) // nastaveni nuly na vystup, krery zapina povoleni vysilani RS485`
58	`#define POVOLOVAK_HIGH PORTB \|= (1<<PB3) // nastaveni jednicky na tentyz vystup`	58	`#define POVOLOVAK_HIGH PORTB \|= (1<<PB3) // nastaveni jednicky na tentyz vystup`
59	`#define DATA (PIND & (1<<PD3)) // nastaveni vstupu, na kterem se budou detekovat data, musi byt stejny jako vstup pouziteho interruptu`	59	`#define DATA (PIND & (1<<PD3)) // nastaveni vstupu, na kterem se budou detekovat data, musi byt stejny jako vstup pouziteho interruptu`
60		60
61	`volatile unsigned int preteceni; // promenna na ukladani poctu preteceni casovace`	61	`volatile unsigned int preteceni; // promenna na ukladani poctu preteceni casovace`
62	`volatile unsigned int bit; // promena pro pocitani bitu v bajtu`	62	`volatile unsigned int bit; // promena pro pocitani bitu v bajtu`
63	`volatile unsigned long int bitdelay; // obsahuje aktualni zmereny cas delky bitu`	63	`volatile unsigned long int bitdelay; // obsahuje aktualni zmereny cas delky bitu`
64	`volatile unsigned long int cas; // urcuje nejkratsi nalezeny cas delky bitu`	64	`volatile unsigned long int cas; // urcuje nejkratsi nalezeny cas delky bitu`
65		65
66	`ISR(TIMER0_OVF_vect) // interrupt od preteceni casovace`	66	`ISR(TIMER0_OVF_vect) // interrupt od preteceni casovace`
67	`{`	67	`{`
68	`preteceni++; // kdyz pretece, poznamenej to.`	68	`preteceni++; // kdyz pretece, poznamenej to.`
69	`}`	69	`}`
70		70
71	`ISR(INT1_vect) // interrupt od zmeny vstupu na datech`	71	`ISR(INT1_vect) // interrupt od zmeny vstupu na datech`
72	`{`	72	`{`
73	`if ((bitdelay=(TCNT0+preteceni*0x0100)) < cas) cas = bitdelay; // provnani jestli zrovna zmereny cas je kratsi nez nejmensi znamy cas`	73	`if ((bitdelay=(TCNT0+preteceni*0x0100)) < cas) cas = bitdelay; // provnani jestli zrovna zmereny cas je kratsi nez nejmensi znamy cas`
74	`TCNT0 = 0; // zacni znova merit cas zacatku stopbitu`	74	`TCNT0 = 0; // zacni znova merit cas zacatku stopbitu`
75	`preteceni=0; // vynuluj vsechny casove promenne`	75	`preteceni=0; // vynuluj vsechny casove promenne`
76	`bit++; // posun pocitadlo bitu o jednicku`	76	`bit++; // posun pocitadlo bitu o jednicku`
77	`}`	77	`}`
78		78
79	`// ------------------------------------------------------------------`	79	`// ------------------------------------------------------------------`
80	`// Main`	80	`// Main`
81	`// ------------------------------------------------------------------`	81	`// ------------------------------------------------------------------`
82	`int main(void)`	82	`int main(void)`
83	`{`	83	`{`
84	`int stopbit;`	84	`int stopbit;`
85	`int ctvrtbit;`	85	`int ctvrtbit;`
86		86
87	`/*typedef struct { // struktura pro celoèíselné dìlení`	87	`/*typedef struct { // struktura pro celoèíselné dìlení`
88	`int quot;`	88	`int quot;`
89	`int rem;`	89	`int rem;`
90	`} div_t;*/`	90	`} div_t;*/`
91		91
92		92
93	`DDRB \|= (1<<DDB3); // povoleni vystupu na povolovak`	93	`DDRB \|= (1<<DDB3); // povoleni vystupu na povolovak`
94		94
95	`TIMSK \|= (1 << TOIE0); // Enable timer overflow interrupt`	95	`TIMSK \|= (1 << TOIE0); // Enable timer overflow interrupt`
96		96
97	`MCUCR \|= (1 << ISC10); // nastaveni preruseni od zmeny vstupu pro interrupt INT0`	97	`MCUCR \|= (1 << ISC10); // nastaveni preruseni od zmeny vstupu pro interrupt INT0`
98	`GIMSK \|= (1 << INT1); // povoleni interruptu INT0`	98	`GIMSK \|= (1 << INT1); // povoleni interruptu INT0`
99		99
100	`TCCR0B \|= (1 << CS00); // Set up timer`	100	`TCCR0B \|= (1 << CS00); // Set up timer`
101		101
102	`sei(); // enable interrupts`	102	`sei(); // enable interrupts`
103		103
104	`while(1)`	104	`while(1)`
105	`{`	105	`{`
106	`if(!DATA) // kdyz je 0 na datech`	106	`if(!DATA) // kdyz je 0 na datech`
107	`{`	107	`{`
108	`POVOLOVAK_HIGH; // zapni vysilani`	108	`POVOLOVAK_HIGH; // zapni vysilani`
109		109
110	`TCNT0=0;`	110	`TCNT0=0;`
111	`preteceni=0;`	111	`preteceni=0;`
112	`bit=0; // vynuluj vsechny promenne pro mereni casu a pocitani bitu`	112	`bit=0; // vynuluj vsechny promenne pro mereni casu a pocitani bitu`
113	`cas = 0xFFFF; // nastav cas delky bitu na nejvetsi mozny`	113	`cas = 0xFFFF; // nastav cas delky bitu na nejvetsi mozny`
114		114
115	`while (bit <= 8) // odpocitej dobu 8mi bitu`	115	`while (bit <= 8) // odpocitej dobu 8mi bitu`
116	`{`	116	`{`
117	`if ((TCNT0+preteceni*0x0100) >= (cas + (ctvrtbit = cas >> 2))) // zkontroluj jestli necekame na dalsi bit dele nez je nekratsi znema delka bitu`	117	`if ((TCNT0+preteceni*0x0100) >= (cas + (ctvrtbit = cas >> 2))) // zkontroluj jestli necekame na dalsi bit dele nez je nekratsi znema delka bitu`
118	`// v kontrole je rezerva delky ctvrt bitu`	118	`// v kontrole je rezerva delky ctvrt bitu`
119	`{`	119	`{`
120	`bit++; // pokud jsme cekali dele, tak bit uz ubehl, to znamena, ze muzeme pocitadlo bitu posunout o jednicku`	120	`bit++; // pokud jsme cekali dele, tak bit uz ubehl, to znamena, ze muzeme pocitadlo bitu posunout o jednicku`
121	`// div(ctvrtbit,0x0100); // funkce pro implementaci celociselneho deleni zustava ale nepouzita kvuli nutnosti zavest datove struktury, bude ji nutno pouzit pro vetsi rychlosti`	121	`// div(ctvrtbit,0x0100); // funkce pro implementaci celociselneho deleni zustava ale nepouzita kvuli nutnosti zavest datove struktury, bude ji nutno pouzit pro vetsi rychlosti`
122	`TCNT0 = ctvrtbit % 0x0100; //reminder; // zacni znova merit cas do dalsiho mozneho bitu`	122	`TCNT0 = ctvrtbit % 0x0100; //reminder; // zacni znova merit cas do dalsiho mozneho bitu`
123	`preteceni = ctvrtbit/0x0100; //quota;`	123	`preteceni = ctvrtbit/0x0100; //quota;`
124	`}`	124	`}`
125	`}`	125	`}`
126		126
127	`while (!DATA); // cekani na stop bit (detekce pripadneho paritniho bitu)`	127	`while (!DATA); // cekani na stop bit (detekce pripadneho paritniho bitu)`
128		128
129	`for (stopbit=2;stopbit >= 0;stopbit--) // odpocitej dva stopbity`	129	`for (stopbit=2;stopbit >= 0;stopbit--) // odpocitej dva stopbity`
130	`{`	130	`{`
131	`while ((TCNT0+preteceni*0x0100) <= cas)`	131	`while ((TCNT0+preteceni*0x0100) <= cas)`
132	`{`	132	`{`
133	`if(!DATA) break;`	133	`if(!DATA) break;`
134	`}`	134	`}`
135	`}`	135	`}`
136	`}`	136	`}`
137	`else POVOLOVAK_LOW; // kdyz je 1 prepni na prijem`	137	`else POVOLOVAK_LOW; // kdyz je 1 prepni na prijem`
138	`}`	138	`}`
139	`return(0);`	139	`return(0);`
140	`}`	140	`}`