int dg_echo(int sockfd, SA *pcliaddr, socklen_t clilen)
{
int ret;
#ifndef EMULATE
#ifdef FTDI
if ((ret = dmx_init(&ftdic)) == EXIT_SUCCESS)
#endif // FTDI
#ifdef SC12
if ((ret = dmx_init(port, 250000L, FOSSIL_PARITY_NO, 8, 2)) == EXIT_SUCCESS)
// if ((ret = dmx_init(port, 19200L, FOSSIL_PARITY_NO, 8, 1)) == EXIT_SUCCESS)
#endif // SC12
#endif // EMULATE
{
int n, m;
int channel;
int nchars;
socklen_t len;
unsigned char mesg[MAXLINE];
int i;
#ifdef SC12
int error;
#endif
bzero(dmx, sizeof(dmx));
#ifndef EMULATE
#ifndef SC12
set_timer();
#endif
#endif
for ( ; ; ) {
#ifdef SC12
n = recvfrom(sockfd, mesg, MAXLINE, MSG_BLOCKING, 0L, pcliaddr, &error);
if (n >= 20) // minimum required ArtDMX size
{
#else
len = clilen;
n = recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len);
#endif
if (strcmp(mesg, "Art-Net") == 0)
{
int opcode = mesg[8] | mesg[9] << 8;
if (opcode == 0x5000) // OpDmx
{
int length = mesg[16] << 8 | (mesg[17] & 0xFE); // force even
if (length <= 512)
{
bcopy(mesg + 18, dmx + 1, length);
dmx_write(port, dmx, length + 1);
fossil_flush_output(port);
}
}
}
#ifdef SC12
}
#endif
}
}
return ret;
}
void notmain(void) {
int i;
hardware_init();
dmx_init();
dmx_set_port_direction(DMX_PORT_DIRECTION_INP, true);
rdm_device_info_init();
printf("[V%s] %s Compiled on %s at %s\n", DEVICE_SOFTWARE_VERSION, hardware_board_get_model(), __DATE__, __TIME__);
printf("RDM Responder / DMX Slave, Devices connected : %d\n", dmx_devices_get_devices_connected());
const uint8_t *uid_device = rdm_device_info_get_uuid();
printf("Device UUID : %.2x%.2x:%.2x%.2x%.2x%.2x, Label :", uid_device[0], uid_device[1], uid_device[2], uid_device[3], uid_device[4], uid_device[5]);
monitor_print_root_device_label();
hardware_watchdog_init();
events_init();
for (;;) {
for (i = 0; i < (int)(sizeof(poll_table) / sizeof(poll_table[0])); i++) {
poll_table[i].f();
hardware_watchdog_feed();
}
events_check();
}
}
/**
* @ingroup firmware
*
*
*
* @param boot_dev
* @param arm_m_type
* @param atags
* @return
*/
int notmain(uint32_t boot_dev, uint32_t arm_m_type, uint32_t atags) {
int i = 0;
hardware_init();
dmx_init();
dmx_devices_init();
hardware_print_board_model();
printf("Compiled on %s at %s\n", __DATE__, __TIME__);
printf("DMX Slave-Analyzer, Devices connected : %d\n", dmx_devices_get_devices_connected());
ui_start(0x00); // User Interface
ui_reinit();
ui_text_line_1("DMX512 Receiver", 15);
ui_text_line_2("Booting........", 15);
dmx_devices_init();
hardware_watchdog_init();
events_init();
for (;;) {
hardware_watchdog_feed();
for (i = 0; i < sizeof(poll_table) / sizeof(poll_table[0]); i++) {
poll_table[i].f();
}
events_check();
}
return 0;
}
/**
* @ingroup firmware
*
*
*
* @param boot_dev
* @param arm_m_type
* @param atags
* @return
*/
int notmain(uint32_t boot_dev, uint32_t arm_m_type, uint32_t atags)
{
hardware_init();
dmx_init();
printf("Compiled on %s at %s\n", __DATE__, __TIME__);
ui_start(0x00); // User Interface
ui_reinit();
ui_text_line_1("DMX512 Receiver", 15);
ui_text_line_2("Booting........", 15);
dmx_devices_read_config();
dmx_devices_init();
watchdog_init();
events_init();
for (;;)
{
watchdog_feed();
int i = 0;
for (i = 0; i < sizeof(poll_table) / sizeof(poll_table[0]); i++)
{
poll_table[i].f();
}
events_check();
}
return 0;
}
void Dmx::Init(void) {
assert(!m_IsInitDone);
if (!m_IsInitDone) {
dmx_init();
m_IsInitDone = true;
}
}
Dmx::Dmx(uint8_t nGpioPin, bool DoInit): m_IsInitDone(DoInit) {
#ifndef NDEBUG
printf("Dmx::Dmx nGpioPin=%d\n", nGpioPin);
#endif
dmx_init_set_gpiopin(nGpioPin);
if (DoInit) {
dmx_init();
}
}
void notmain(void) {
int i;
hardware_init();
dmx_init();
hardware_print_board_model();
printf("Compiled on %s at %s\n", __DATE__, __TIME__);
printf("Logic RDM Sniffer, DMX512 data analyzer for 32 channels");
hardware_watchdog_init();
events_init();
for (;;) {
hardware_watchdog_feed();
for (i = 0; i < (int)(sizeof(poll_table) / sizeof(poll_table[0])); i++) {
poll_table[i].f();
}
events_check();
}
}
int
cdli_ns8390init()
{
struct ndd *nddp;
struct ns_8022 *filter;
struct ns_user *ns_user;
int ret;
printf("%s initializing pseudo-CDLI ns8390 driver\n", ns8390wdname);
if (!(nddp = (struct ndd *)kalloc(sizeof(struct ndd))))
{
return(ENOMEM);
}
bzero((char *)nddp, sizeof(*nddp));
nddp->ndd_name = ns8390wdname;
nddp->ndd_unit = 0;
nddp->ndd_type = NDD_ISO88023;
nddp->d_ops = cdli_ns8390_dops;
nddp->ndd_open = cdli_ns8390_open;
nddp->ndd_close = cdli_ns8390_close;
nddp->ndd_output = cdli_ns8390_output;
nddp->ndd_ctl = cdli_ns8390_ctl;
(void) dmx_init(nddp);
if (ret = ns_attach(nddp)) /* Add network device driver */
{
goto bad;
}
if (!(filter = (struct ns_8022 *)kalloc(sizeof(*filter))))
{
return(ENOMEM);
}
bzero((char *)filter, sizeof(*filter));
filter->filtertype = NS_STATUS_MASK;
filter->dsap = 0x0;
filter->orgcode[0] = '\0';
filter->orgcode[1] = '\0';
filter->orgcode[2] = '\0';
filter->ethertype = NS_ETHERTYPE;
eth_add_demuxer(nddp->ndd_type);
if (!(ns_user = (struct ns_user *)kalloc(sizeof(struct ns_user))))
{
return(ENOMEM);
}
bzero((char *)ns_user, sizeof(struct ns_user));
ns_user->isr = 0;
if (ret = dmx_8022_add_filter(nddp, filter, ns_user)) /* Add demuxing filter */
{
goto bad;
}
ret = ns_alloc(nddp->ndd_name, &nddp);
bad:
return(ret);
}
int main(int argc, char **argv)
{
struct timespec start, end;
// initialize DMX
if (EXIT_FAILURE == dmx_init(&ftdic))
{
fprintf(stderr, "unable to init dmx\n");
return EXIT_FAILURE;
}
// initialize universe
memset(&dmx, 0, sizeof(dmx));
// initialize UDP server
int sockfd, n, packet_counter, msec_diff;
struct sockaddr_in servaddr, cliaddr;
socklen_t len;
if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
{
fprintf(stderr, "error %d creating socket: %s\n", errno, strerror(errno));
dmx_shutdown();
return EXIT_FAILURE;
}
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(UDP_PORT);
if (bind(sockfd,(struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
{
fprintf(stderr, "error %d binding server address to socket: %s\n", errno, strerror(errno));
dmx_shutdown();
return EXIT_FAILURE;
}
fprintf(stdout, "initialized DMX hardware and network service. Listening to UDP connections at port %d\n", UDP_PORT);
packet_counter = 0;
clock_gettime(CLOCK_MONOTONIC, &start);
for (;;)
{
len = sizeof(cliaddr);
n = recvfrom(sockfd, dmx.body, sizeof(dmx.body), 0, (struct sockaddr *)&cliaddr, &len);
clock_gettime(CLOCK_MONOTONIC, &end);
packet_counter++;
msec_diff = timespec_diff(&end, &start);
if (msec_diff > 1000000)
{
msec_diff = 0;
}
start = end;
// fprintf(stdout, "packet %d, diff = %d\n", packet_counter, msec_diff);
universe_set(dmx, sizeof(dmx));
// usleep(4*DMX_CHANNELS);
}
dmx_shutdown();
exit (0);
}
