spacepaste

Paste details

reply | raw

  1.  
  2. /*-
  3. * Copyright (C) 1999, 2002 Matt Armstrong
  4. * All rights reserved.
  5. *
  6. * Redistribution and use in source and binary forms, with or without
  7. * modification, are permitted provided that the following conditions
  8. * are met:
  9. * 1. Redistributions of source code must retain the above copyright
  10. * notice, this list of conditions and the following disclaimer.
  11. * 2. Redistributions in binary form must reproduce the above copyright
  12. * notice, this list of conditions and the following disclaimer in the
  13. * documentation and/or other materials provided with the distribution.
  14. *
  15. * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16. * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18. * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21. * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24. * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25. * SUCH DAMAGE.
  26. */
  28. #ifdef HAVE_CONFIG_H
  29. #include <config.h>
  30. #endif
  32. #include "conf.h"
  34. #include <stdio.h>
  35. #include <stddef.h>
  36. #include <ctype.h>
  37. #include <stdlib.h>
  38. #include <assert.h>
  40. #if HAVE_FCNTL_H
  41. #include <fcntl.h>
  42. #endif
  43. #if HAVE_SYS_IOCTL_H
  44. #include <sys/ioctl.h>
  45. #endif
  46. #if HAVE_SYS_TIME_H
  47. #include <sys/time.h>
  48. #endif
  49. #if HAVE_SYS_TYPES_H
  50. #include <sys/types.h>
  51. #endif
  52. #if HAVE_UNISTD_H
  53. #include <unistd.h>
  54. #endif
  55. #if HAVE_TERMIO_H
  56. #include <termio.h>
  57. #endif
  59. #include "cm17a.h"
  61. enum SIGNAL {
  62. RESET = 0,
  63. HIGH = TIOCM_RTS,
  64. LOW = TIOCM_DTR,
  65. STANDBY = (TIOCM_RTS | TIOCM_DTR)
  66. };
  68. /* The house code is the high nibble of the command data. */
  69. unsigned short house_codes[16] = {
  70. 0x6000, /* A */
  71. 0x7000, /* B */
  72. 0x4000, /* C */
  73. 0x5000, /* D */
  74. 0x8000, /* E */
  75. 0x9000, /* F */
  76. 0xA000, /* G */
  77. 0xB000, /* H */
  78. 0xE000, /* I */
  79. 0xF000, /* J */
  80. 0xC000, /* K */
  81. 0xD000, /* L */
  82. 0x0000, /* M */
  83. 0x1000, /* N */
  84. 0x2000, /* O */
  85. 0x3000, /* P */
  86. };
  88. /* The device codes are described by bits 3, 4, 6, and 10. */
  89. #define DEVICE_BITS 0x0458
  90. unsigned short device_codes[16] = {
  91. 0x0000, /* 1 */
  92. 0x0010, /* 2 */
  93. 0x0008, /* 3 */
  94. 0x0018, /* 4 */
  95. 0x0040, /* 5 */
  96. 0x0050, /* 6 */
  97. 0x0048, /* 7 */
  98. 0x0058, /* 8 */
  99. 0x0400, /* 9 */
  100. 0x0410, /* 10 */
  101. 0x0408, /* 11 */
  102. 0x0418, /* 12 */
  103. 0x0440, /* 13 */
  104. 0x0450, /* 14 */
  105. 0x0448, /* 15 */
  106. 0x0458, /* 16 */
  107. };
  109. /* The command codes are described by bits 1, 2, 5, 7, 8, 9, and
  110. 11. */
  111. unsigned short command_codes[] = {
  112. 0x0000, /* CM17A_ON */
  113. 0x0020, /* CM17A_OFF */
  114. 0x0088, /* BRIGHT */
  115. 0x0098, /* CM17A_DIM */
  116. };
  118. #define ELEMENT_COUNT(a) (sizeof(a) / sizeof((a)[0]))
  120. static unsigned short
  121. cm17a_command_word(int house,
  122. int device,
  123. enum CM17A_COMMAND command)
  124. {
  125. unsigned short retval;
  127. assert(house >= 0 && house < ELEMENT_COUNT(house_codes));
  128. assert(device >= 0 && device < ELEMENT_COUNT(device_codes));
  129. assert(command >= 0 && command < ELEMENT_COUNT(command_codes));
  131. switch (command) {
  132. case CM17A_BRIGHTEN:
  133. case CM17A_DIM:
  134. retval = house_codes[house] | command_codes[command];
  135. break;
  137. default:
  138. retval = (house_codes[house] |
  139. device_codes[device] |
  140. command_codes[command]);
  141. break;
  142. }
  144. return retval;
  145. }
  147. static void sleep_us(unsigned int nusecs)
  148. {
  149. struct timeval tval;
  151. tval.tv_sec = nusecs / 1000000;
  152. tval.tv_usec = nusecs % 1000000;
  153. select(0, NULL, NULL, NULL, &tval);
  154. }
  156. static void
  157. delay(void)
  158. {
  159. sleep_us(500);
  160. }
  162. static int
  163. set(int fd, enum SIGNAL signal)
  164. {
  165. int lines = signal;
  166. int current;
  167. /* FIXME: we should just remember this in a static
  168. variable. */
  169. if (ioctl(fd, TIOCMGET, &current) != 0) {
  170. return -1;
  171. }
  172. current &= ~RESET;
  173. current |= signal;
  174. return ioctl(fd, TIOCMSET, &lines);
  175. }
  177. static int write_byte(int fd, unsigned char byte)
  178. {
  179. int mask = 0x80;
  180. do {
  181. enum SIGNAL signal = (byte & mask) ? HIGH : LOW;
  182. if (set(fd, signal) != 0) {
  183. return -1;
  184. }
  185. delay();
  186. if (set(fd, STANDBY) != 0) {
  187. return -1;
  188. }
  189. delay();
  190. mask >>= 1;
  191. } while (mask);
  192. return 0;
  193. }
  195. static int
  196. write_stream(int fd,
  197. const unsigned char* data,
  198. size_t byte_count)
  199. {
  200. int i;
  201. for (i = 0; i < byte_count; i++) {
  202. int ret = write_byte(fd, data[i]);
  203. if (ret) {
  204. return ret;
  205. }
  206. }
  207. return 0;
  208. }
  210. static int
  211. cm17a_standby(int fd)
  212. {
  213. if (set(fd, STANDBY) != 0) {
  214. return -1;
  215. }
  216. delay();
  217. return 0;
  218. }
  220. static int
  221. cm17a_header(int fd)
  222. {
  223. /* Header bits taken straight from the CM17A spec. */
  224. const unsigned char header[] = {
  225. 0xD5, 0xAA
  226. };
  227. return write_stream(fd, header, sizeof(header));
  228. }
  230. static int
  231. footer(int fd)
  232. {
  233. /* Footer bits taken straight from the CM17A spec. */
  234. return write_byte(fd, 0xAD);
  235. }
  237. static int
  238. cm17a_write_command(int fd,
  239. int house,
  240. int device,
  241. enum CM17A_COMMAND command)
  242. {
  243. short command_word;
  245. command_word = cm17a_command_word(house, device, command);
  247. if (cm17a_standby(fd)) {
  248. return -1;
  249. }
  251. /* The cm17a seems to need another delay period after a
  252. standby to settle down after the reset. */
  253. delay();
  255. if (cm17a_header(fd) ||
  256. write_byte(fd, command_word >> 8) ||
  257. write_byte(fd, command_word) ||
  258. footer(fd)) {
  259. return -1;
  260. }
  262. sleep_us(500000);
  264. return 0;
  265. }
  267. void
  268. cm17a_command(int fd,
  269. int house,
  270. int device,
  271. enum CM17A_COMMAND cmd,
  272. int steps)
  273. {
  274. switch (cmd) {
  275. case CM17A_ON:
  276. case CM17A_OFF:
  277. if (cm17a_write_command(fd, house, device, cmd) != 0) {
  278. fprintf(stderr, "Command failed.\n");
  279. }
  280. break;
  281. case CM17A_BRIGHTEN:
  282. case CM17A_DIM:
  283. {
  284. if (steps < 1 || steps > 6) {
  285. fprintf(stderr,
  286. "Invalid steps (%d). Must be [1..6].\n",
  287. steps);
  288. return;
  289. }
  291. /* Turn the device we wish to control on first. If we don't
  292. do this, the dim command gets handled by the last device
  293. that got turned on. The cm17a dim/brighten command doesn't
  294. use a device code. */
  296. if (cm17a_write_command(fd, house, device, CM17A_ON) != 0) {
  297. fprintf(stderr, "Command failed.\n");
  298. }
  300. while (--steps >= 0) {
  301. if (cm17a_write_command(fd, house, device, cmd)) {
  302. fprintf(stderr, "Command failed.\n");
  303. }
  304. }
  305. break;
  306. }
  307. default:
  308. fprintf(stderr, "Invalid flip operation\n");
  309. }
  310. }
  312. /*
  313. Local Variables:
  314. mode:c
  315. c-file-style:"linux"
  316. tab-width:8
  317. End:
  318. */
  319.  
Powered by spacepaste. Paste removal.