void dds::init_chip() { if (chip_type == DDS9834) { digitalWrite(load_pin,LOW); raw_send(0x2100,16); // control word, set output to mid value voltage digitalWrite(load_pin,HIGH); digitalWrite(load_pin,LOW); raw_send(0x4431,16); // freq0 MSB 100 hz digitalWrite(load_pin,HIGH); digitalWrite(load_pin,LOW); raw_send(0x4000,16); // freq0 LSB 100 hz digitalWrite(load_pin,HIGH); digitalWrite(load_pin,LOW); raw_send(0x4863,16); // freq1 MSB 200 hz digitalWrite(load_pin,HIGH); digitalWrite(load_pin,LOW); raw_send(0x4000,16); // freq1 LSB 200 hz digitalWrite(load_pin,HIGH); digitalWrite(load_pin,LOW); raw_send(0xC000,16); // phase offset of freq0 = 0 digitalWrite(load_pin,HIGH); digitalWrite(load_pin,LOW); raw_send(0xE000,16); // phase offset of freq1 = 0 digitalWrite(load_pin,HIGH); digitalWrite(load_pin,LOW); raw_send(0x2000,16); // control word, set output = sine wave digitalWrite(load_pin,HIGH); } }
/** * Send some data on a RAW or UDP pcb contained in a netconn * Called from netconn_send * * @param msg the api_msg_msg pointing to the connection */ void do_send(struct api_msg_msg *msg) { if (!ERR_IS_FATAL(msg->conn->err)) { if (msg->conn->pcb.tcp != NULL) { switch (NETCONNTYPE_GROUP(msg->conn->type)) { #if LWIP_RAW case NETCONN_RAW: if (msg->msg.b->addr == NULL) { msg->conn->err = raw_send(msg->conn->pcb.raw, msg->msg.b->p); } else { msg->conn->err = raw_sendto(msg->conn->pcb.raw, msg->msg.b->p, msg->msg.b->addr); } break; #endif #if LWIP_UDP case NETCONN_UDP: if (msg->msg.b->addr == NULL) { msg->conn->err = udp_send(msg->conn->pcb.udp, msg->msg.b->p); } else { msg->conn->err = udp_sendto(msg->conn->pcb.udp, msg->msg.b->p, msg->msg.b->addr, msg->msg.b->port); } break; #endif /* LWIP_UDP */ default: break; } } } TCPIP_APIMSG_ACK(msg); }
static void do_send(struct api_msg_msg *msg) { if (msg->conn->pcb.tcp != NULL) { switch (msg->conn->type) { #if LWIP_RAW case NETCONN_RAW: raw_send(msg->conn->pcb.raw, msg->msg.p); break; #endif #if LWIP_UDP case NETCONN_UDPLITE: /* FALLTHROUGH */ case NETCONN_UDPNOCHKSUM: /* FALLTHROUGH */ case NETCONN_UDP: udp_send(msg->conn->pcb.udp, msg->msg.p); break; #endif /* LWIP_UDP */ case NETCONN_TCP: break; } } sys_mbox_post(msg->conn->mbox, NULL); }
static void handle_attn(channel_t *chan, int val, int irq) { serserv_data_t *si = chan->chan_info; if (val && si->do_attn) raw_send(si, si->attn_chars, si->attn_chars_len); }
void parse_device_setup(void) { switch(pSetupPacket->bReq) { case STDDEVREQ_SET_ADDR: address = (uint8)SWAPENDIAN(pSetupPacket->wValue); raw_send(ADD_UDATAEND0,0); break; case STDDEVREQ_GET_DESCR: parse_descriptor(); break; case STDDEVREQ_GET_CONFIG: raw_send(ADD_UDATAEND0,0); break; case STDDEVREQ_SET_CONFIG: raw_send(ADD_UDATAEND0,0); switch(SWAPENDIAN(pSetupPacket->wValue)) { case 1: /* we support only one config */ R_UCR1 = TX1E; R_UCR2 = RX2E; sbuff_tail = sbuff_head = rbuff_tail = rbuff_head = 0; cbuff_tail = cbuff_head = 0; dev_configured = TRUE; rx_toggle = 0; break; case 0: /* if config is 0, we return to address state */ R_UCR1 = 0x00; R_UCR2 = 0x00; dev_configured = FALSE; break; default: stall(); break; } break; case STDDEVREQ_CLEAR_FEATURE: case STDDEVREQ_SET_FEATURE: case STDDEVREQ_SET_DESCR: default: stall(); break; } }
void send_data(void) { len = 0; mcu_datap = ADD_UDATAEND1; while((sbuff_tail != sbuff_head) && len != 8) { (*mcu_datap) = sendbuffer[sbuff_tail]; mcu_datap++; len++; INC_SINDEX(sbuff_tail); } raw_send(ADD_UDATAEND1,len); }
static void do_send() { /* SYN is 0 */ const struct send_pkt send_pkts[] = { {DATA1, 4, 0, TH_ACK, dst_seq}, {DATA2, 4, 6, TH_ACK, dst_seq}, {DATA3, 6, 2, TH_ACK, dst_seq}, }; raw_send(send_pkts, sizeof(send_pkts)/sizeof(send_pkts[0])); return; }
void send_config(void) { len = 0; mcu_datap = ADD_UDATAEND0; while((cbuff_tail != cbuff_head) && len != 8) { (*mcu_datap) = descrbuffer[cbuff_tail]; mcu_datap++; len++; cbuff_tail++; } if(cbuff_tail == cbuff_head) // all data sent, force last packet last_packet = TRUE; raw_send(ADD_UDATAEND0,len); }
static inline void _send(socket_t s) { assert(s); st_io* io_req = 0; uint32_t err_code = 0; if(s->writeable) { if((io_req = LLIST_POP(st_io*,&s->pending_send))!=NULL) { int32_t bytes_transfer = raw_send(s,io_req,&err_code); if(bytes_transfer == 0) bytes_transfer = -1; if(err_code != EAGAIN) s->io_finish(bytes_transfer,io_req,err_code); } } }
static inline void _send(socket_t s) { assert(s); int32_t ret = -1; int32_t bytes_transfer = 0; st_io* io_req = 0; if(s->writeable) { if(io_req = LINK_LIST_POP(st_io*,s->pending_send)) { ret = raw_send(s,io_req,&bytes_transfer,&io_req->err_code); if(io_req->err_code != EAGAIN) s->OnWrite(bytes_transfer,io_req); } } }
/** * Send some data on a RAW or UDP pcb contained in a netconn * Called from netconn_send * * @param msg the api_msg_msg pointing to the connection */ void do_send(struct api_msg_msg *msg) { if (ERR_IS_FATAL(msg->conn->last_err)) { msg->err = msg->conn->last_err; } else { msg->err = ERR_CONN; if (msg->conn->pcb.tcp != NULL) { switch (NETCONNTYPE_GROUP(msg->conn->type)) { #if LWIP_RAW case NETCONN_RAW: if (ip_addr_isany(&msg->msg.b->addr)) { msg->err = raw_send(msg->conn->pcb.raw, msg->msg.b->p); } else { msg->err = raw_sendto(msg->conn->pcb.raw, msg->msg.b->p, &msg->msg.b->addr); } break; #endif #if LWIP_UDP case NETCONN_UDP: #if LWIP_CHECKSUM_ON_COPY if (ip_addr_isany(&msg->msg.b->addr)) { msg->err = udp_send_chksum(msg->conn->pcb.udp, msg->msg.b->p, msg->msg.b->flags & NETBUF_FLAG_CHKSUM, msg->msg.b->toport_chksum); } else { msg->err = udp_sendto_chksum(msg->conn->pcb.udp, msg->msg.b->p, &msg->msg.b->addr, msg->msg.b->port, msg->msg.b->flags & NETBUF_FLAG_CHKSUM, msg->msg.b->toport_chksum); } #else /* LWIP_CHECKSUM_ON_COPY */ if (ip_addr_isany(&msg->msg.b->addr)) { msg->err = udp_send(msg->conn->pcb.udp, msg->msg.b->p); } else { msg->err = udp_sendto(msg->conn->pcb.udp, msg->msg.b->p, &msg->msg.b->addr, msg->msg.b->port); } #endif /* LWIP_CHECKSUM_ON_COPY */ break; #endif /* LWIP_UDP */ default: break; } } } TCPIP_APIMSG_ACK(msg); }
auto send_data (std::size_t size, void const * const data){ std::size_t sizes[] = {size}; const void* bufs[] = {data}; return raw_send(1,sizes,bufs); }
static int socket_connect() { int sockfd, n; const int on = 1; struct sockaddr_in addr; struct linger l = { .l_onoff = 1, .l_linger = 0, }; sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd == -1) err(1, "socket"); setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)); if (setsockopt(sockfd, SOL_SOCKET, SO_LINGER, &l, sizeof(l)) == -1) err(1, "linger"); memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_addr.s_addr = inet_addr(dst); addr.sin_port = htons(dport); n = connect(sockfd, (const struct sockaddr*)&addr, sizeof(addr)); if (n == -1) err(1, "connect"); return sockfd; } static void recv_cb(u_char *usr, const struct pcap_pkthdr *h, const u_char *bytes) { static struct send_pkt pkt = { .data = "", .data_len = 0, .seq = 10, .flags = TH_ACK, .ack = 0, }; pcap_t *handle = (pcap_t*)usr; const struct eth_hdr *eth_hdr; const struct ip_hdr *ip_hdr; const struct tcp_hdr *tcp_hdr; const unsigned char *payload; int n; int ip_hdr_len; int tcp_hdr_len; static int c = 0; static unsigned int len = 0; static char buf[2048] = {0}; (void)h; if (!bytes) return; eth_hdr = (const struct eth_hdr*)bytes; ip_hdr = (const struct ip_hdr*)(eth_hdr + 1); ip_hdr_len = ip_hdr->ip_hl * 4; tcp_hdr = (const struct tcp_hdr *)((char *)ip_hdr + ip_hdr_len); tcp_hdr_len = tcp_hdr->th_off * 4; payload = (const unsigned char *)((char *)tcp_hdr + tcp_hdr_len); n = ntohs(ip_hdr->ip_len) - ip_hdr_len - tcp_hdr_len; if (n == 0) /* recv an ack */ return; memcpy(buf + len, payload, n); len += n; /* send an ack */ pkt.ack = ntohl(tcp_hdr->th_seq) + n; raw_send(&pkt, 1); /* XXX wait until 8 or 10 * some system may ignore the packets out of sequence * or not send 2222 */ if (len < strlen(FAVOR_OLD) - 2) return; if (strncmp(buf, FAVOR_OLD, len) == 0) { printf("old\n"); fflush(stdout); } else if (strncmp(buf, FAVOR_NEW, len) == 0) { printf("new\n"); fflush(stdout); } else if (strncmp(buf, FAVOR_BEFORE, len) == 0) { printf("before\n"); fflush(stdout); } else if (strncmp(buf, FAVOR_AFTER, len) == 0) { printf("after\n"); fflush(stdout); } else if (len >= 10) { printf("Unknown %s\n", buf); fflush(stdout); } else { printf("\nrecved %s. try to read again\nrecv:", buf); fflush(stdout); } if (++c > 10) { warnx("tried too many times. exit..."); } pcap_breakloop(handle); } /* prepare addr for libdnet */ static void prepare(int sockfd) { struct sockaddr addr; unsigned int len = sizeof(struct sockaddr); struct sockaddr_in *addr_in; if (-1 == getsockname(sockfd, &addr, &len)) err(1, "getsockname"); addr_in = (struct sockaddr_in *)&addr; src = inet_ntoa(addr_in->sin_addr); sport = ntohs(addr_in->sin_port); printf("local addr: %s:%d\n", src, sport); /* for libdnet */ addr_aton(src, &s_addr); addr_aton(dst, &d_addr); return; } static void *pcap_thread(void *arg) { char errbuf[2048]; const char *dev = NULL; pcap_t *handle; struct bpf_program fp; char rule[2048]; bpf_u_int32 mask; bpf_u_int32 net; struct pcap_pkthdr header; const unsigned char *data = NULL; const struct eth_hdr *eth_hdr; const struct ip_hdr *ip_hdr; const struct tcp_hdr *tcp_hdr; int n; (void)arg; if (local) dev = "lo"; else dev = "eth0"; n = snprintf(rule, sizeof(rule), "src port %d", dport); rule[n] = 0; arg = NULL; if (pcap_lookupnet(dev, &net, &mask, errbuf) == -1) err(1, "pcap_lookupnet"); handle = pcap_open_live(dev, BUFSIZ, 0, 0, errbuf); if (!handle) { err(1, "pcap_open_live:%s", errbuf); } if (pcap_compile(handle, &fp, rule, 0, net) == -1) err(1, "pcap_compile %s:%s", rule, errbuf); if (pcap_setfilter(handle, &fp) == -1) err(1, "pcap_setfilter:%s", pcap_geterr(handle)); printf("initializing..."); fflush(stdout); sleep(1); sockfd = socket_connect(); prepare(sockfd); while (!data) data = pcap_next(handle, &header); eth_hdr = (const struct eth_hdr*)data; ip_hdr = (const struct ip_hdr *)(eth_hdr+1); tcp_hdr = (const struct tcp_hdr *)(ip_hdr+1); tcp_seq = ntohl(tcp_hdr->th_ack); dst_seq = ntohl(tcp_hdr->th_seq) + 1; tell_main(); printf("recv:"); fflush(stdout); wait_main(); pcap_loop(handle, 0, recv_cb, (u_char*)handle); pcap_freecode(&fp); pcap_close(handle); close(sockfd); pthread_exit(NULL); } static void usage() { warnx("[s src_port][d dst_port] ip"); }
auto send(const T&... t){ std::size_t sizes[] = {bytes_size(t)...}; void *bufs[] = {to_bytes_helper(t,alloca(bytes_size(t)))...}; return raw_send(sizeof...(T),sizes,bufs); }
void dds::setfrequency(unsigned long frequency) { unsigned long dds_32_bit_word = dds_bits(frequency); #ifdef DEBUG_DDS Serial.write("dds::setfrequency: freq: "); Serial.print(frequency); Serial.write(" clock_hz: "); Serial.print(clock_hz); Serial.write(" calib: "); Serial.print(calibration); Serial.write(" data_pin: "); Serial.print(data_pin); Serial.write(" clock_pin: "); Serial.print(clock_pin); Serial.write(" load_pin: "); Serial.print(load_pin); Serial.write(" dds_32_bit_word: "); Serial.println(dds_32_bit_word); #endif if (chip_type == DDS9834) { digitalWrite(load_pin,LOW); for (int x = 0; x < 16; x++) { // send control word if ((x == 2) || (x == 7)) { send_dds(1); //DB13 = 1 - This allows a complete word to be loaded into a frequency //register in two consecutive writes. The first write contains 14 LSBs. //The second write contains 14 MSBs // //RESET bit DB8 is set to 1. This resets internal registers to 0, which //corresponds to an analog output of midscale. } else { if ((x == 14) and (triangle_wave)) { // set MODE bit if triangle wave is activated send_dds(1); } else { send_dds(0); } } } digitalWrite(load_pin,HIGH); digitalWrite(load_pin,LOW); send_dds(0); // (DB15, DB14 = 01) send_dds(1); // send 14 LSBs for (int x = 13; x > -1; x--) { if (bitRead(dds_32_bit_word,x)) { send_dds(1); } else { send_dds(0); } } digitalWrite(load_pin,HIGH); digitalWrite(load_pin,LOW); send_dds(0); // (DB15, DB14 = 01) send_dds(1); // send 14 MSBs for (int x = 27; x > 13; x--) { if (bitRead(dds_32_bit_word,x)) { send_dds(1); } else { send_dds(0); } } digitalWrite(load_pin,HIGH); digitalWrite(load_pin,LOW); raw_send(0xC000,16); digitalWrite(load_pin,HIGH); digitalWrite(load_pin,LOW); raw_send(0x2000,16); digitalWrite(load_pin,HIGH); } else { // 9850 and 9851 digitalWrite(load_pin,LOW); // send the 32 bit word, least significant bit first for (int x = 0; x < 32; x++) { //if ((x % 4) == 0) { Serial.write("|"); } if (bitRead(dds_32_bit_word,x)) { send_dds(1); } else { send_dds(0); } } // send the control byte at the end for (int y = 0; y < 8; y++) { if ((y == 0) && (chip_type == DDS9851) && (clock_multiplier)) { send_dds(1); // set the 6 X multiplier control bit on a 9851 if it's activated } else { send_dds(0); } } // take the load pin high momentarily to tell the DDS chip to run with the new setting digitalWrite(load_pin,HIGH); //delay(1); digitalWrite(load_pin,LOW); } #ifdef DEBUG_DDS Serial.write("\n\rdds::setfrequency: loaded\n\r"); #endif }
int adp( struct raw_context *net, struct jdksavdecc_frame *frame, int argc, char **argv ) { int r = 1; struct jdksavdecc_eui64 entity_id; struct jdksavdecc_adpdu adpdu; bzero( &entity_id, sizeof( entity_id ) ); bzero( &adpdu, sizeof( adpdu ) ); uint16_t message_type_code; printf("%s():-->%d\targc = %d\n", __func__, __LINE__, argc); if ( argc > 4 ) { arg_entity_id = argv[4]; if ( *arg_entity_id == 0 ) { arg_entity_id = 0; } } if ( jdksavdecc_get_uint16_value_for_name( jdksavdecc_adpdu_print_message_type, arg_message_type, &message_type_code ) ) { if ( arg_entity_id ) { if ( !jdksavdecc_eui64_init_from_cstr( &entity_id, arg_entity_id ) ) { fprintf( stderr, "ADP: invalid entity_id: '%s'\n", arg_entity_id ); return 1; } } if ( adp_form_msg( frame, &adpdu, message_type_code, entity_id ) == 0 ) { if ( raw_send( net, frame->dest_address.value, frame->payload, frame->length ) > 0 ) { if ( arg_verbose > 0 ) { fprintf( stdout, "Sent:\n" ); adp_print( stdout, frame, &adpdu ); if ( arg_verbose > 1 ) { avdecc_cmd_print_frame_payload( stdout, frame ); } } r = 0; printf("\t%s():-->%d\n", __func__, __LINE__); avdecc_cmd_process_incoming_raw( &adpdu, net, arg_time_in_ms_to_wait, adp_process ); printf("\t%s():-->%d\n", __func__, __LINE__); } } else { fprintf( stderr, "avdecc: unable to form adp message\n" ); } } else { struct jdksavdecc_uint16_name *name = jdksavdecc_adpdu_print_message_type; fprintf( stdout, "ADP message type options:\n" ); while ( name->name ) { fprintf( stdout, "\t0x%04x %s\n", name->value, name->name ); name++; } } return r; }
int main(int argc, char *argv[]) { /* Disable driver enable for RS485 ASAP */ //DDRC |= (1 << PC2); //PORTC &= ~(1 << PC2); /* init serial line debugging */ UBRR0H = UBRRH_VALUE; UBRR0L = UBRRL_VALUE; UCSR0B = (1 << RXCIE1) | (1 << RXEN1) | (1 << TXEN0); UCSR0C = (1<<UCSZ00) | (1<<UCSZ01); /* Initialize UART */ net_init(); DBG("READY!\r\n"); DBG("Initializing SPI...\r\n"); spi_init(); DBG("Initializing ENC28J60...\r\n"); init_enc28j60(); DBG("Initialized ENC28J60\r\n"); char obuf[64]; snprintf(obuf, sizeof(obuf), "enc28j60 rev 0x%x\n", read_control_register(REG_EREVID)); DBG(obuf); char buf[16] = "serial: X\n"; int cnt = 0; while (1) { if (eth_to_rs_cnt > 0 && eth_to_rs[eth_to_rs_cnt-1] == '$') { eth_to_rs[eth_to_rs_cnt-1] = '\0'; int dest = 0; int pktlen = 0; char minibuf[16]; minibuf[0] = eth_to_rs[1]; minibuf[1] = eth_to_rs[2]; minibuf[2] = '\0'; if (sscanf(minibuf, "%d", &dest) != 1) { DBG("Could not parse dest\r\n"); eth_to_rs_cnt = 0; continue; } minibuf[0] = eth_to_rs[3]; minibuf[1] = eth_to_rs[4]; if (sscanf(minibuf, "%d", &pktlen) != 1) { DBG("Could not parse len\r\n"); eth_to_rs_cnt = 0; continue; } if (pktlen != (eth_to_rs_cnt - 6)) { DBG("lens are not the same\r\n"); minibuf[2] = '\r'; minibuf[3] = '\n'; minibuf[4] = '\0'; DBG(minibuf); snprintf(minibuf, sizeof(minibuf), "e: %d\r\n", eth_to_rs_cnt-6); DBG(minibuf); snprintf(minibuf, sizeof(minibuf), "p: %d\r\n", pktlen); DBG(minibuf); eth_to_rs_cnt = 0; continue; } fmt_packet(lbuffer, dest, 0xFF, eth_to_rs + 5, pktlen); struct buspkt *packet = (struct buspkt*)lbuffer; send_packet(packet); syslog_send("sent packet", strlen("sent packet")); _delay_ms(25); sendit = 0; eth_to_rs_cnt = 0; } #if 0 network_process(); if (uip_recvlen > 0) { syslog_send("handling ethernet packet", strlen("handling ethernet packet")); DBG("Handling packet\r\n"); handle_icmpv6(); if (uip_recvbuf[20] == 0x11) { syslog_send("handling udp packet", strlen("handling udp packet")); /* UDP */ uint8_t *udp = uip_recvbuf + 14 + 40; uint8_t len = udp[5] - 8; /* TODO: sanity check */ uint8_t *recvpayload = udp + 8 /* udp */; fmt_packet(lbuffer, uip_recvbuf[53], 0xFF, recvpayload, len); struct buspkt *packet = (struct buspkt*)lbuffer; //syslog_send("sending packet", strlen("sending packet")); send_packet(packet); _delay_ms(25); cnt = 85; syslog_send("ethernet to rs485 done", strlen("ethernet to rs485 done")); } //syslog_send("received a packet", strlen("received a packet")); buf[14] = uip_recvlen; //syslog_send(uip_recvbuf, uip_recvlen); uip_recvlen = 0; } #endif _delay_ms(10); if (cnt++ == 100) { fmt_packet(lbuffer, 1, 0, "ping", 4); struct buspkt *packet = (struct buspkt*)lbuffer; syslog_send("ping sent", strlen("ping sent")); send_packet(packet); cnt = 0; snprintf(obuf, sizeof(obuf), "cnt = %d, rem = %d\r\n", eth_to_rs_cnt, eth_to_rs_rem); syslog_send(obuf, strlen(obuf)); } uint8_t status = bus_status(); if (status == BUS_STATUS_IDLE) continue; if (status == BUS_STATUS_MESSAGE) { /* get a copy of the current packet */ struct buspkt *packet = current_packet(); uint8_t *walk = packet; uint8_t *payload = (uint8_t*)packet; payload += sizeof(struct buspkt); /* check for ping replies */ if (packet->destination == 0x00 && memcmp(payload, "pong", strlen("pong")) == 0) { syslog_send("pong received", strlen("pong received")); /* TODO: store that this controller is reachable */ /* check if the controller has any waiting messages */ if (payload[4] > 0) { /* request the message */ fmt_packet(lbuffer, packet->source, 0, "send", 4); struct buspkt *reply = (struct buspkt*)lbuffer; //syslog_send("sending packet", strlen("sending packet")); _delay_ms(25); send_packet(reply); syslog_send("sendreq sent", strlen("sendreq sent")); //syslog_send(reply, reply->length_lo + sizeof(struct buspkt)); _delay_ms(25); cnt = 0; } } #if 0 /* copy packet->destination into the MAC and IPv6 address */ uip_buf[5] = packet->destination; /* MAC */ uip_buf[53] = packet->destination; /* IPv6 */ /* copy packet->source into the MAC and IPv6 address */ uip_buf[11] = packet->source; /* MAC */ uip_buf[37] = packet->source; /* IPv6 */ raw_send(payload, packet->length_lo); #endif char minibuf[16]; snprintf(minibuf, sizeof(minibuf), "^%02d%02d", 0, packet->length_lo); uart_puts(minibuf); uint8_t c; for (c = 0; c < sizeof(struct buspkt); c++) { while ( !( UCSR0A & (1<<UDRE0)) ); UDR0 = walk[c]; } for (c = 0; c < packet->length_lo; c++) { while ( !( UCSR0A & (1<<UDRE0)) ); UDR0 = payload[c]; } while ( !( UCSR0A & (1<<UDRE0)) ); UDR0 = '$'; /* discard the packet from serial buffer */ packet_done(); continue; } if (status == BUS_STATUS_WRONG_CRC) { syslog_send("broken", strlen("broken")); struct buspkt *packet = current_packet(); raw_send(packet, 16); skip_byte(); continue; } } }