spacepaste

Paste details

reply | raw

  1.  
  2. /****************************************************************************
  3. * *
  4. * RFM12 basierte, drahtlose RS232 Verbindung *
  5. * *
  6. * Version 1.51 *
  7. * *
  8. * � by Benedikt *
  9. * *
  10. * Email: benedikt83 �t gmx.net *
  11. * *
  12. ****************************************************************************
  13. * *
  14. * Die Fusebits aus externen Takt einstellen, wenn die 10MHz vom RFM12 *
  15. * verwendet werden. Die BOD auf 2,6V einstellen und aktivieren. *
  16. * *
  17. ****************************************************************************
  18. * *
  19. * Die Software darf frei kopiert und ver�ndert werden, solange sie nicht *
  20. * ohne meine Erlaubnis f�r kommerzielle Zwecke eingesetzt wird. *
  21. * *
  22. ***************************************************************************/
  24. #include <avr/io.h>
  25. #include <avr/interrupt.h>
  26. #include <avr/pgmspace.h>
  27. #include <avr/eeprom.h>
  28. #include <stdlib.h>
  29. #include <portbits.h>
  30. #include "global.h"
  31. #include "uart.h"
  32. #include "rf12.h"
  33. #include "leds.h"
  35. #define F_CPU 10000000UL
  36. #include <util/delay.h>
  38. //#define DEBUG // anstelle der empfangenen Daten f�r jede Aktion den Status ausgeben
  40. #define USE_SOFTCONFIG // Konfiguration �ber ein einfaches Men� (auskommentieren wenn nicht verwendet), nicht zusammen mit DIPSWITCH verwenden
  41. //#define USE_DIPSWITCH // DIP Schalter/Jumper an PortC 0-4 (auskommentieren wenn nicht verwendet), nicht zusammen mit SOFTCONFIG verwenden
  42. #define CHANNEL 2 // Sende/Empfangskanal (0-3) (nur g�ltig wenn kein DIP Schalter verwendet wird)
  43. #define RF_BAUDRATE 20000 // Baudrate des RFM12 (nur g�ltig wenn kein DIP Schalter verwendet wird)
  44. #define UART_BAUDRATE 19200 // Baudrate des UARTs (nur g�ltig wenn kein DIP Schalter verwendet wird)
  46. #define CONFIG_BAUD 19200 // Baudrate des UARTs (nur g�ltig im Config Mode)
  48. #define MAX_BUF 128 // Paket Gr��e in Bytes (maximal 250, siehe auch rf12.c)
  49. #define TX_TIMEOUT 150 // Maximale Wartezeit auf Daten in ms (max 500)
  51. #define ANSWER_TIMEOUT 10 // Maximale Wartezeit auf die Best�tigung der Daten in ms (max 500)
  52. #define RETRY 15 // Maximale Anzahl an Sendeversuchen
  54. // define USE_868 in der rf12.c zum Umschalten zwischen 433 (auskommentiert) und 868MHz (aktiv) verwenden! Bei der 868MHz Version ist die Einhaltung der maximalen Sendedauer bei den einzelnen Kan�len zu beachten!
  57. #define CONFIG PIND_4 // Pin f�r Config Jumper (DDR beachten)
  59. volatile unsigned char delaycnt;
  60. unsigned char rxbuf[MAX_BUF+1]; // Puffer f�r empfangene Daten
  61. unsigned char txbuf[MAX_BUF+1]; // Puffer f�r zu sendende Daten
  62. unsigned char flags, tx_cnt, tx_id, tx_status, retrans_cnt;
  64. #ifdef USE_SOFTCONFIG
  65. unsigned long uart_baud, rf_baud;
  66. unsigned char channel;
  67. #endif
  69. #define WAITFORACK 1
  71. void rx_packet(void);
  72. void tx_packet(unsigned char retrans);
  73. void load_settings(void);
  74. void save_settings(void);
  75. void configmode(void);
  76. unsigned long read_number(unsigned long min, unsigned long max);
  77. void show_number(unsigned long val);
  79. int main(void)
  80. {
  81. #ifdef USE_SOFTCONFIG
  82. PORTD=255;
  83. DDRD=230;
  84. DDRC=255;
  85. #else
  86. PORTD=15;
  87. PORTC=255;
  88. DDRD=242;
  89. #endif
  91. sei();
  92. rf12_init(); // ein paar Register setzen (z.B. CLK auf 10MHz)
  94. #ifdef USE_DIPSWITCH
  95. unsigned char c;
  96. unsigned short baud_uart, baud_rf;
  97. c=PINC&7;
  98. if (c==0)
  99. { baud_rf=4000;
  100. baud_uart=UART_BAUD_SELECT(1200, F_CPU);
  101. }
  102. else if (c==1)
  103. { baud_rf=4000;
  104. baud_uart=UART_BAUD_SELECT(2400, F_CPU);
  105. }
  106. else if (c==2)
  107. { baud_rf=8000;
  108. baud_uart=UART_BAUD_SELECT(4800, F_CPU);
  109. }
  110. else if (c==3)
  111. { baud_rf=15000;
  112. baud_uart=UART_BAUD_SELECT(9600, F_CPU);
  113. }
  114. else if (c==4)
  115. { baud_rf=25000;
  116. baud_uart=UART_BAUD_SELECT(19200, F_CPU);
  117. }
  118. else if (c==5)
  119. { baud_rf=30000;
  120. baud_uart=UART_BAUD_SELECT(28800, F_CPU);
  121. }
  122. else if (c==6)
  123. { baud_rf=40000;
  124. baud_uart=UART_BAUD_SELECT(38400, F_CPU);
  125. }
  126. else if (c==7)
  127. { baud_rf=60000;
  128. baud_uart=UART_BAUD_SELECT(57600, F_CPU);
  129. }
  130. c=(PINC&24)/8;
  131. uart_init(baud_uart);
  132. rf12_config(baud_rf, c, 0, QUIET); // Baudrate, Kanal (0-3), Leistung (0=max, 7=min), Umgebungsbedingungen (QUIET, NORMAL, NOISY)
  133. #else
  134. #ifdef USE_SOFTCONFIG
  135. load_settings();
  136. if (!CONFIG)
  137. configmode();
  138. uart_init(UART_BAUD_SELECT(uart_baud, F_CPU));
  139. rf12_config(rf_baud, channel, 0, QUIET); // Baudrate, Kanal (0-3), Leistung (0=max, 7=min), Umgebungsbedingungen (QUIET, NORMAL, NOISY)
  140. #else
  141. uart_init(UART_BAUD_SELECT(UART_BAUDRATE, F_CPU));
  142. rf12_config(RF_BAUDRATE, CHANNEL, 0, QUIET); // Baudrate, Kanal (0-3), Leistung (0=max, 7=min), Umgebungsbedingungen (QUIET, NORMAL, NOISY)
  143. #endif
  144. #endif
  146. TCCR1A=0;
  147. TCCR1B=(1<<WGM12)|1;
  148. OCR1A=((F_CPU+2500)/500)-1;
  149. TIMSK=(1<<OCIE1A);
  151. rf12_rxmode();
  153. for (;;)
  154. { if (rf12_data()) // Daten im RF12 RX Puffer ?
  155. { rx_packet();
  156. }
  157. if (!(flags&WAITFORACK)) // Puffer nur dann f�llen, wenn die alten Daten aus dem Puffer wirklich angekommen sind
  158. { if (uart_data()) // Daten im UART RX Puffer ?
  159. { if (!tx_cnt)
  160. delaycnt=TX_TIMEOUT/2; // Nach dem ersten Byte: timeout starten
  161. txbuf[tx_cnt++]=uart_getchar();
  162. }
  163. if ((tx_cnt>=MAX_BUF)||((tx_cnt)&&(delaycnt==0))) // Puffer voll, oder timeout seit erstem Byte im Puffer vorbei ? -> senden
  164. { tx_status=0; // zu sendender Status
  165. tx_packet(0); // erstmaliger Transfer
  166. #ifdef DEBUG
  167. uart_putc('t');
  168. #endif
  169. }
  170. }
  171. else if (delaycnt==0) // Timeout: Daten nochmal senden
  172. { LED_RETRANS=1;
  173. if (retrans_cnt)
  174. { retrans_cnt--;
  175. tx_packet(1); // retransmit
  176. #ifdef DEBUG
  177. uart_putc('r');
  178. #endif
  179. }
  180. else // Versuche abgelaufen
  181. { LED_ERR=1; // -> Fehler LED an
  182. tx_cnt=0; // -> Daten verwerfen
  183. tx_id++;
  184. flags&=~WAITFORACK; // Daten als OK markieren
  185. #ifdef DEBUG
  186. uart_putc('e');
  187. #endif
  189. }
  190. }
  191. }
  192. }
  194. void rx_packet(void)
  195. { static unsigned char rx_lastid=255;
  196. unsigned char rx_cnt,i, rx_id, status;
  197. rx_cnt=rf12_rxdata(rxbuf, &status, &rx_id); // komplettes Paket empfangen
  198. if (rx_cnt<=MAX_BUF) // Daten g�ltig (d.h. kein CRC Fehler) ?
  199. { if (status&RECEIVED_OK) // Empfangsbest�tigung ?
  200. { flags&=~WAITFORACK; // -> "Warten auf Best�tigung"-Flag l�schen
  201. tx_cnt=0; // -> Daten als gesendet markieren
  202. tx_id++;
  203. LED_RETRANS=0;
  204. LED_ERR=0;
  205. #ifdef DEBUG
  206. uart_putc('a');
  207. #endif
  208. }
  209. if (rx_cnt) // Daten empfangen
  210. { tx_status=RECEIVED_OK; // zu sendender Status
  211. #ifdef DEBUG
  212. uart_putc('p');
  213. #endif
  214. tx_packet(0); // Empfangsbest�tigung senden
  215. retrans_cnt=RETRY; // Retry Counter neu starten
  216. if (rx_id!=rx_lastid) // Handelt es sich um neue Daten ?
  217. {
  218. #ifndef DEBUG
  219. for (i=0; i<rx_cnt; i++) // Daten weiterleiten
  220. uart_putc(rxbuf[i]);
  221. #endif
  222. rx_lastid=rx_id; // Aktuelle ID speichern
  223. }
  224. }
  225. }
  226. else
  227. {
  228. #ifdef DEBUG
  229. uart_putc('n');
  230. #endif
  231. }
  232. }
  234. void tx_packet(unsigned char retrans)
  235. {
  236. rf12_stoprx(); // auf TX umschalten
  237. if ((!retrans)&&((flags&WAITFORACK)||(tx_cnt==0))) // es wird noch auf eine Antwort vom Paket gewartet oder es sind keine Daten zu senden
  238. { rf12_txdata(txbuf, 0, tx_status, 0); // -> kein komplettes neues Paket, sondern nur Status senden
  239. #ifdef DEBUG
  240. uart_putc('s');
  241. #endif
  242. }
  243. else
  244. { rf12_txdata(txbuf, tx_cnt, tx_status, tx_id); // komplettes Paket senden
  245. flags|=WAITFORACK; // auf ACK warten
  246. delaycnt=ANSWER_TIMEOUT/2; // Timeout Counter neu starten
  247. if (!retrans) // erstmalige �bertragung ?
  248. retrans_cnt=RETRY; // -> Retry Counter neu starten
  249. #ifdef DEBUG
  250. uart_putc('d');
  251. #endif
  252. }
  253. rf12_rxmode(); // wieder auf RX umschalten
  254. }
  256. #ifdef USE_SOFTCONFIG
  257. void load_settings(void)
  258. {
  259. if (eeprom_read_byte((void *)1)!=0xAA)
  260. { rf_baud=RF_BAUDRATE;
  261. uart_baud=UART_BAUDRATE;
  262. channel=CHANNEL;
  263. save_settings();
  264. }
  265. channel=eeprom_read_byte((void *)2);
  266. eeprom_read_block(&rf_baud,(void *)3,4);
  267. eeprom_read_block(&uart_baud,(void *)7,4);
  268. }
  270. void save_settings(void)
  271. {
  272. eeprom_write_byte((void *)1,0xAA);
  273. eeprom_write_byte((void *)2,channel);
  274. eeprom_write_block(&rf_baud,(void *)3,4);
  275. eeprom_write_block(&uart_baud,(void *)7,4);
  276. }
  278. void configmode(void)
  279. { unsigned char c;
  280. uart_init(UART_BAUD_SELECT(CONFIG_BAUD, F_CPU));
  281. for(;;)
  282. { uart_puts_P("\r\n\r\n");
  283. uart_puts_P("RFM12 RS232 bridge v1.2\r\n");
  284. uart_puts_P("(c) by Benedikt\r\n");
  285. uart_puts_P("Config Menue\r\n\r\n");
  286. uart_puts_P("Current Settings:\r\n");
  287. uart_puts_P("\r\nRS232 baudrate: ");
  288. show_number(uart_baud);
  289. uart_puts_P("\r\nRFM12 baudrate: ");
  290. show_number(rf_baud);
  291. uart_puts_P("\r\nchannel: ");
  292. show_number(channel);
  293. uart_puts_P("\r\n\r\n");
  294. uart_puts_P("(1) set RS232 baudrate\r\n");
  295. uart_puts_P("(2) set RFM12 baudrate\r\n");
  296. uart_puts_P("(3) set RFM12 channel\r\n");
  297. uart_puts_P("\r\n");
  298. uart_puts_P("(0) exit menu without saving\r\n");
  299. uart_puts_P("(s) exit menu and save settings\r\n");
  300. uart_puts_P("\r\n");
  301. for(;;)
  302. { c=uart_getchar();
  303. if (c=='0')
  304. return;
  305. else if (c=='s')
  306. { uart_puts_P("saved !\r\nLeaving config mode...\r\n");
  307. save_settings();
  308. _delay_ms(10);
  309. return;
  310. }
  311. else if (c=='1')
  312. { uart_puts_P("Enter RS232 baudrate (300-150000)\r\n");
  313. uart_baud=read_number(300,150000);
  314. break;
  315. }
  316. else if (c=='2')
  317. { uart_puts_P("Enter RFM12 baudrate (700-65000)\r\n");
  318. rf_baud=read_number(700,65000);
  319. break;
  320. }
  321. else if (c=='3')
  322. { uart_puts_P("Enter RFM12 channel (0-3)\r\n");
  323. channel=read_number(0,3);
  324. break;
  325. }
  326. else
  327. break;
  328. }
  329. }
  330. }
  332. void show_number(unsigned long val)
  333. { unsigned char i;
  334. char s[8]={32,32,32,32,32,32,32,0};
  335. i=6;
  336. do
  337. { s[i--]=val%10+'0';
  338. }
  339. while (val/=10);
  340. s[7]=0;
  341. uart_puts(s);
  342. }
  344. unsigned long read_number(unsigned long min, unsigned long max)
  345. { unsigned long number;
  346. unsigned char c,i;
  347. for (;;)
  348. { number=0;
  349. for (i=0;i<6;i++)
  350. { c=uart_getchar();
  351. if ((c==10)||(c==13)||(c==32))
  352. break;
  353. if ((c>='0')&&(c<='9'))
  354. { uart_putc(c);
  355. number=number*10+(c-'0');
  356. }
  357. }
  358. if ((number>=min)&&(number<=max))
  359. break;
  360. uart_puts_P("Number out of range, try again !\r\n");
  361. }
  362. return number;
  363. }
  364. #endif
  366. ISR(SIG_OUTPUT_COMPARE1A) // 500Hz Interrupt
  367. {
  368. if (delaycnt)
  369. delaycnt--;
  370. }
  371.  
Powered by spacepaste. Paste removal.