]> git.gag.com Git - fw/altos/blob - src/lpc/baud_rate
fixup for interleave
[fw/altos] / src / lpc / baud_rate
1 #!/usr/bin/env nickle
2
3 /*
4  * Given a main clock frequency,
5  * compute USART clock freq and a table
6  * of USART config parameters for our target baud rates
7  */
8
9 real main_clock = 0;
10 real usart_clock = 0;
11
12 real[] baud_rates = { 4800, 9600, 19200, 57600, 115200 };
13
14 void
15 compute_baud_rate(real rate) {
16         int     divaddval;
17         int     mulval;
18
19         real    dl_est = usart_clock / (16 * rate);
20
21         if (dl_est == floor(dl_est)) {
22                 divaddval = 0;
23                 mulval = 1;
24         } else {
25                 if (false) {
26
27                         /* This is how the docs suggest doing it; this
28                          * generates a rate which is reasonably close
29                          */
30
31                         real fr_est = 1.5;
32
33                         /* Compute fractional estimate */
34                         do {
35                                 dl_est = floor(usart_clock / (16 * rate * fr_est) + 0.5);
36                                 fr_est = usart_clock / (16 * rate * dl_est);
37                         } while (fr_est <= 1.1 || 1.9 <= fr_est);
38
39                         /* Given fractional estimate, compute divaddval/mulvals that work best */
40
41                         real best_dist = 1000;
42                         for (int tmp_divaddval = 1; tmp_divaddval < 15; tmp_divaddval++) {
43                                 for (int tmp_mulval = 1; tmp_mulval < 16; tmp_mulval++) {
44                                         real fr = 1 + tmp_divaddval / tmp_mulval;
45                                         real dist = abs(fr - fr_est);
46                                         if (dist < best_dist) {
47                                                 divaddval = tmp_divaddval;
48                                                 mulval = tmp_mulval;
49                                                 best_dist = dist;
50                                         }
51                                 }
52                         }
53                 } else {
54
55                         /* This exhaustively searches for the best match */
56
57                         real my_best_dist = 1e20;
58                         int my_best_dl;
59                         int my_best_divaddval;
60                         int my_best_mulval;
61                         for (int my_dl = 1; my_dl < 1024; my_dl++) {
62                                 for (int my_mulval = 1; my_mulval < 16; my_mulval++) {
63                                         for (int my_divaddval = 0; my_divaddval < my_mulval; my_divaddval++) {
64                                                 real my_rate = usart_clock / ((16 * my_dl) * (1 + my_divaddval/my_mulval));
65
66                                                 real my_dist = abs(rate - my_rate);
67
68                                                 if (my_dist == 0 && my_divaddval == 0) {
69                                                         my_dist = -1;
70                                                 }
71
72                                                 if (my_dist < my_best_dist) {
73                                                         my_best_dl = my_dl;
74                                                         my_best_divaddval = my_divaddval;
75                                                         my_best_mulval = my_mulval;
76                                                         my_best_dist = my_dist;
77                                                 }
78                                         }
79                                 }
80                         }
81
82                         dl_est = my_best_dl;
83                         divaddval = my_best_divaddval;
84                         mulval = my_best_mulval;
85                 }
86         }
87
88         int dl = floor (dl_est);        
89
90         real actual = usart_clock / ((16 * dl) * (1 + divaddval/mulval));
91
92         printf("\t[AO_SERIAL_SPEED_%d] = { /* actual = %8.2f */\n", floor(rate), actual);
93         printf("\t\t.dl = %d,\n", dl);
94         printf("\t\t.divaddval = %d,\n", divaddval);
95         printf("\t\t.mulval = %d\n", mulval);
96         printf("\t},\n");
97 }
98
99 void
100 main() {
101         if (dim(argv) < 2) {
102                 printf ("usage: %s <main-clock>\n", argv[0]);
103                 exit(1);
104         }
105         main_clock = string_to_real(argv[1]);
106
107         for (int div = 0; div < 4; div++) {
108                 if (main_clock / (1 << div) <= 12000000) {
109                         usart_clock = main_clock / (1 << div);
110                         break;
111                 }
112         }
113
114         if (usart_clock == 0) {
115                 printf ("can't get usart clock in range\n");
116                 exit(1);
117         }
118
119         printf ("#define AO_LPC_USARTCLK %d\n\n", floor(usart_clock));
120         printf("static const struct {\n");
121         printf("\tuint16_t dl;\n");
122         printf("\tuint8_t divaddval;\n");
123         printf("\tuint8_t mulval;\n");
124         printf("} ao_usart_speeds[] = {\n");
125         for (int i = 0; i < dim(baud_rates); i++) {
126                 compute_baud_rate(baud_rates[i]);
127         }
128         printf ("};\n");
129 }
130
131 main();