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;
}
}
}
