static int excrate_init(struct excrate *e, const char *script,
const char *search, struct listing *storage)
{
pid_t pid;
fprintf(stderr, "External scan '%s'...\n", search);
pid = fork_pipe_nb(&e->fd, script, "scan", search, NULL);
if (pid == -1)
return -1;
e->pid = pid;
e->pe = NULL;
e->terminated = false;
e->refcount = 0;
rb_reset(&e->rb);
listing_init(&e->listing);
e->storage = storage;
event_init(&e->completion);
e->search = search;
list_add(&e->excrates, &excrates);
rig_post_excrate(e);
return 0;
}
ring_buffer* rb_create(size_t size, size_t elem_size)
{
ring_buffer* rb = malloc(sizeof(ring_buffer));
rb->buffer = malloc(size * elem_size);
rb->size = size;
rb_reset(rb);
return rb;
}
int
main(int ac, char **av)
{
rb_t buffer;
rb_reset(&buffer);
//d_s(&buffer, "T40484269E72E;T40484369001F;");
d_s(&buffer, "T40484269E743001F;T404847690118;");
FHT_compress(&buffer);
p(&buffer);
}
static void
rf_router_send(uint8_t addAddr)
{
#ifdef RFR_DEBUG
if(RFR_Buffer.buf[5] == 'T') nr_t++;
else if(RFR_Buffer.buf[5] == 'F') nr_f++;
else if(RFR_Buffer.buf[5] == 'E') nr_e++;
else if(RFR_Buffer.buf[5] == 'K') nr_k++;
else if(RFR_Buffer.buf[5] == 'H') nr_h++;
else nr_r++;
#endif
uint8_t buf[7], l = 1;
buf[0] = RF_ROUTER_PROTO_ID;
if(addAddr) {
tohex(rf_router_target, buf+1);
tohex(rf_router_myid, buf+3),
buf[5] = 'U';
l = 6;
}
rf_router_ping(); // 15ms
ccInitChip(EE_FASTRF_CFG); // 1.6ms
my_delay_ms(3); // 3ms: Found by trial and error
CC1100_ASSERT;
cc1100_sendbyte(CC1100_WRITE_BURST | CC1100_TXFIFO);
#ifdef RFR_USBECHO
uint8_t nbuf = RFR_Buffer.nbytes;
#endif
cc1100_sendbyte(RFR_Buffer.nbytes+l);
for(uint8_t i = 0; i < l; i++)
cc1100_sendbyte(buf[i]);
while(RFR_Buffer.nbytes)
cc1100_sendbyte(rb_get(&RFR_Buffer));
CC1100_DEASSERT;
ccTX();
rb_reset(&RFR_Buffer); // needed by FHT_compress
// Wait for the data to be sent
uint8_t maxwait = 20; // max 20ms
while((cc1100_readReg(CC1100_TXBYTES) & 0x7f) && maxwait--)
my_delay_ms(1);
set_txrestore();
#ifdef RFR_USBECHO
#warning RFR USB DEBUGGING IS ACTIVE
uint8_t odc = display_channel;
display_channel = DISPLAY_USB;
DC('.'); DU(nbuf, 2); DNL();
display_channel = odc;
#endif
}
void test_rb_insertion_function(int num_bytes_to_insert,
int (*insertion_fn)(ring_buffer *, uint8),
const char insertion_fn_name[]) {
SerialUSB.println("resetting ring buffer.");
rb_reset(rb);
print_rb_contents();
SerialUSB.print(insertion_fn_name);
SerialUSB.print("-ing ");
SerialUSB.print(num_bytes_to_insert);
SerialUSB.println(" bytes.");
for (uint8 i = 1; i <= num_bytes_to_insert; i++)
insertion_fn(rb, i);
uint16 count = rb_full_count(rb);
SerialUSB.print("rb_full_count(rb) = ");
SerialUSB.println(count);
print_rb_contents();
}
void
rf_router_func(char *in)
{
if(in[1] == 0) { // u: display id and router
DH2(rf_router_myid);
DH2(rf_router_target);
DNL();
#ifdef RFR_DEBUG
} else if(in[1] == 'd') { // ud: Debug
DH((uint16_t)ticks, 4); DC('.');
DH2(rf_router_sendtime);
DNL();
} else if(in[1] == 's') { // us: Statistics
DH(nr_t,1); DC('.');
DH(nr_f,1); DC('.');
DH(nr_e,1); DC('.');
DH(nr_k,1); DC('.');
DH(nr_h,1); DC('.');
DH(nr_r,1); DC('.');
DH(nr_plus,1);
DNL();
#endif
} else if(in[1] == 'i') { // uiXXYY: set own id to XX and router id to YY
fromhex(in+2, &rf_router_myid, 1);
ewb(EE_RF_ROUTER_ID, rf_router_myid);
fromhex(in+4, &rf_router_target, 1);
ewb(EE_RF_ROUTER_ROUTER, rf_router_target);
} else { // uYYDATA: send data to node with id YY
rb_reset(&RFR_Buffer);
while(*++in)
rb_put(&RFR_Buffer, *in);
rf_router_send(0);
}
}
int usb_ioctl(int request, void *ctl)
{
switch(request)
{
case I_USB_CLEAR:
if (!rxfifo)
{
return 0;
}
rb_reset(rxfifo);
return 1;
case I_USB_CONNECTED:
*((U8 *)ctl) = is_usb_connected(usb_attr);
break;
case I_USB_GETATTR:
if (usb_attr)
{
*((usb_attr_t **)ctl) = usb_attr;
}
else
{
return 0;
}
break;
case I_USB_SETATTR:
if (ctl == NULL)
{
return 0;
}
usb_attr = (usb_attr_t *)ctl;
return usb_configure(usb_attr);
default:
return 0;
}
return 1;
}
//------------------------------------------------------------------------------
/// Application entry point. Configures the DBGU, PIT, TC0, LEDs and buttons
/// and makes LED\#1 blink in its infinite loop, using the Wait function.
/// \return Unused (ANSI-C compatibility).
//------------------------------------------------------------------------------
int main(void)
{
// DBGU configuration
TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
TRACE_INFO_WP("\n\r");
TRACE_INFO("Getting new Started Project --\n\r");
TRACE_INFO("%s\n\r", BOARD_NAME);
TRACE_INFO("Compiled: %s %s --\n\r", __DATE__, __TIME__);
//Configure Reset Controller
AT91C_BASE_RSTC->RSTC_RMR= 0xa5<<24;
// Configure EMAC PINS
PIO_Configure(emacRstPins, PIO_LISTSIZE(emacRstPins));
// Execute reset
RSTC_SetExtResetLength(0xd);
RSTC_ExtReset();
// Wait for end hardware reset
while (!RSTC_GetNrstLevel());
TRACE_INFO("init Flash\n\r");
flash_init();
TRACE_INFO("init Timer\n\r");
// Configure timer 0
ticks=0;
extern void ISR_Timer0();
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC0);
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKDIS;
AT91C_BASE_TC0->TC_IDR = 0xFFFFFFFF;
AT91C_BASE_TC0->TC_SR;
AT91C_BASE_TC0->TC_CMR = AT91C_TC_CLKS_TIMER_DIV5_CLOCK | AT91C_TC_CPCTRG;
AT91C_BASE_TC0->TC_RC = 375;
AT91C_BASE_TC0->TC_IER = AT91C_TC_CPCS;
AIC_ConfigureIT(AT91C_ID_TC0, AT91C_AIC_PRIOR_LOWEST, ISR_Timer0);
AIC_EnableIT(AT91C_ID_TC0);
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
// Configure timer 1
extern void ISR_Timer1();
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC1);
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKDIS; //Stop clock
AT91C_BASE_TC1->TC_IDR = 0xFFFFFFFF; //Disable Interrupts
AT91C_BASE_TC1->TC_SR; //Read Status register
AT91C_BASE_TC1->TC_CMR = AT91C_TC_CLKS_TIMER_DIV4_CLOCK | AT91C_TC_CPCTRG; // Timer1: 2,666us = 48MHz/128
AT91C_BASE_TC1->TC_RC = 0xffff;
AT91C_BASE_TC1->TC_IER = AT91C_TC_CPCS;
AIC_ConfigureIT(AT91C_ID_TC1, 1, ISR_Timer1);
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
led_init();
TRACE_INFO("init EEprom\n\r");
eeprom_init();
rb_reset(&TTY_Rx_Buffer);
rb_reset(&TTY_Tx_Buffer);
input_handle_func = analyze_ttydata;
LED_OFF();
LED2_OFF();
LED3_OFF();
spi_init();
fht_init();
tx_init();
#ifdef HAS_ETHERNET
ethernet_init();
#endif
TRACE_INFO("init USB\n\r");
CDCDSerialDriver_Initialize();
USBD_Connect();
wdt_enable(WDTO_2S);
fastrf_on=0;
display_channel = DISPLAY_USB;
TRACE_INFO("init Complete\n\r");
checkFrequency();
// Main loop
while (1) {
CDC_Task();
Minute_Task();
RfAnalyze_Task();
#ifdef HAS_FASTRF
FastRF_Task();
#endif
#ifdef HAS_RF_ROUTER
rf_router_task();
#endif
#ifdef HAS_ASKSIN
rf_asksin_task();
#endif
#ifdef HAS_MORITZ
rf_moritz_task();
#endif
#ifdef HAS_RWE
rf_rwe_task();
#endif
#ifdef HAS_MBUS
rf_mbus_task();
#endif
#ifdef HAS_MAICO
rf_maico_task();
#endif
#ifdef HAS_ETHERNET
Ethernet_Task();
#endif
#ifdef DBGU_UNIT_IN
if(DBGU_IsRxReady()){
unsigned char volatile * const ram = (unsigned char *) AT91C_ISRAM;
unsigned char x;
x=DBGU_GetChar();
switch(x) {
case 'd':
puts("USB disconnect\n\r");
USBD_Disconnect();
break;
case 'c':
USBD_Connect();
puts("USB Connect\n\r");
break;
case 'r':
//Configure Reset Controller
AT91C_BASE_RSTC->RSTC_RMR=AT91C_RSTC_URSTEN | 0xa5<<24;
break;
case 'S':
USBD_Disconnect();
my_delay_ms(250);
my_delay_ms(250);
//Reset
*ram = 0xaa;
AT91C_BASE_RSTC->RSTC_RCR = AT91C_RSTC_PROCRST | AT91C_RSTC_PERRST | AT91C_RSTC_EXTRST | 0xA5<<24;
while (1);
break;
default:
rb_put(&TTY_Tx_Buffer, x);
}
}
#endif
if (USBD_GetState() == USBD_STATE_CONFIGURED) {
if( USBState == STATE_IDLE ) {
CDCDSerialDriver_Read(usbBuffer,
DATABUFFERSIZE,
(TransferCallback) UsbDataReceived,
0);
LED3_ON();
USBState=STATE_RX;
}
}
if( USBState == STATE_SUSPEND ) {
TRACE_INFO("suspend !\n\r");
USBState = STATE_IDLE;
}
if( USBState == STATE_RESUME ) {
TRACE_INFO("resume !\n\r");
USBState = STATE_IDLE;
}
}
}
void usb_reset_tx()
{
APP_Rx_ptr_in = 0;
rb_reset(txfifo);
}
void usb_reset_rx()
{
rb_reset(rxfifo);
}
//=============================================================================
int main(int argc, char *argv[])
{
if(argc<2)
{
fprintf(stderr,"need number\n");
exit(1);
}
int rb_size_request=atoi(argv[1]);
fprintf(stderr,"\n==creating new ringbuffer of size %d\n",rb_size_request);
rb_t *rb=rb_new(rb_size_request);
if(rb==NULL)
{
fprintf(stderr,"ringbuffer with size 0?\n");
exit(1);
}
rb_debug(rb);
fprintf(stderr,"\n==write full + 1\n");
int i;
for(i=0;i<rb_size_request+1;i++)
{
char put[1]={i};
int wrote=rb_write(rb,put,1);
rb_debug(rb);
}
fprintf(stderr,"\n==peek full + 1\n");
char pull[rb_size_request];
int peeked=rb_peek(rb,pull,rb_size_request+1);
rb_debug(rb);
fprintf(stderr,"\n==read full + 1\n");
for(i=0;i<rb_size_request+1;i++)
{
char pull[1];
int read=rb_read(rb,pull,1);
rb_debug(rb);
}
fprintf(stderr,"\n==write full\n");
for(i=0;i<rb_size_request;i++)
{
char put[1]={i};
int wrote=rb_write(rb,put,1);
rb_debug(rb);
}
rb_print_regions(rb);
fprintf(stderr,"\n==advance read pointer 1\n");
rb_advance_read_index(rb,1);
rb_debug(rb);
fprintf(stderr,"\n==drop\n");
rb_drop(rb);
rb_debug(rb);
rb_print_regions(rb);
fprintf(stderr,"\n==write 1\n");
char put[1]={'a'};
int wrote=rb_write(rb,put,1);
rb_debug(rb);
rb_print_regions(rb);
fprintf(stderr,"\n==read 1\n");
char put2[1];
int read=rb_read(rb,put2,1);
rb_debug(rb);
rb_print_regions(rb);
fprintf(stderr,"\n==write 4\n");
char put3[4]={'a','b','c','d'};
wrote=rb_write(rb,put3,4);
rb_debug(rb);
rb_print_regions(rb);
int advanced;
int k;
for(k=0;k<20;k++)
{
fprintf(stderr,"\n==advance write 3\n");
advanced=rb_advance_write_index(rb,3);
rb_debug(rb);
rb_print_regions(rb);
fprintf(stderr,"\n==advance read 2\n");
advanced=rb_advance_read_index(rb,2);
rb_debug(rb);
rb_print_regions(rb);
}
for(k=0;k<20;k++)
{
fprintf(stderr,"\n==advance read 3\n");
advanced=rb_advance_read_index(rb,2);
rb_debug(rb);
rb_print_regions(rb);
fprintf(stderr,"\n==advance write 2\n");
advanced=rb_advance_write_index(rb,3);
rb_debug(rb);
rb_print_regions(rb);
}
rb_region_t d;
rb_get_next_write_region(rb,&d);
fprintf(stderr,"\n==got next write buffer, can write %" PRId64 "\n",d.size);
fprintf(stderr,"\n==drop\n");
rb_drop(rb);
rb_debug(rb);
rb_print_regions(rb);
rb_get_next_write_region(rb,&d);
fprintf(stderr,"\n==got next write buffer, can write %" PRId64 "\n",d.size);
d.buffer[0]='x';
fprintf(stderr,"\n==advance write 4\n");
advanced=rb_advance_write_index(rb,4);
rb_debug(rb);
rb_print_regions(rb);
rb_get_next_read_region(rb,&d);
fprintf(stderr,"\n==got next read buffer, can read %" PRId64 "\n",d.size);
fprintf(stderr,"\n==advance read 4\n");
rb_advance_read_index(rb,4);
rb_debug(rb);
rb_print_regions(rb);
rb_get_next_read_region(rb,&d);
fprintf(stderr,"\n==got next read buffer, can read %" PRId64 "\n",d.size);
d.buffer[0]='x';
fprintf(stderr,"\n==advance read 1\n");
advanced=rb_advance_read_index(rb,1);
rb_debug(rb);
rb_print_regions(rb);
fprintf(stderr,"\n==reset\n");
rb_reset(rb);
rb_debug(rb);
fprintf(stderr,"\n==free\n");
rb_free(rb);
rb_debug(rb);
return 0;
}//end main
void
rf_router_task(void)
{
if(rf_router_status == RF_ROUTER_INACTIVE)
return;
uint8_t hsec = (uint8_t)ticks;
if(rf_router_status == RF_ROUTER_GOT_DATA) {
uint8_t len = cc1100_readReg(CC1100_RXFIFO);
uint8_t proto = 0;
if(len > 5) {
rb_reset(&TTY_Rx_Buffer);
CC1100_ASSERT;
cc1100_sendbyte( CC1100_READ_BURST | CC1100_RXFIFO );
proto = cc1100_sendbyte(0);
while(--len)
rb_put(&TTY_Rx_Buffer, cc1100_sendbyte(0));
CC1100_DEASSERT;
}
set_txrestore();
rf_router_status = RF_ROUTER_INACTIVE;
if(proto == RF_ROUTER_PROTO_ID) {
uint8_t id;
if(fromhex(TTY_Rx_Buffer.buf, &id, 1) == 1 && // it is for us
id == rf_router_myid) {
if(TTY_Rx_Buffer.buf[4] == 'U') { // "Display" the data
while(TTY_Rx_Buffer.nbytes) // downlink: RFR->CUL
DC(rb_get(&TTY_Rx_Buffer));
DNL();
} else { // uplink: CUL->RFR
TTY_Rx_Buffer.nbytes -= 4; // Skip dest/src bytes
TTY_Rx_Buffer.getoff = 4;
rb_put(&TTY_Rx_Buffer, '\n');
input_handle_func(DISPLAY_RFROUTER); // execute the command
}
} else {
rb_reset(&TTY_Rx_Buffer);
}
}
} else if(rf_router_status == RF_ROUTER_DATA_WAIT) {
uint8_t diff = hsec - rf_router_hsec;
if(diff > 7) { // 3 (delay above) + 3 ( ((4+64)*8)/250kBaud )
set_txrestore();
rf_router_status = RF_ROUTER_INACTIVE;
}
} else if(rf_router_status == RF_ROUTER_SYNC_RCVD) {
ccInitChip(EE_FASTRF_CFG);
ccRX();
rf_router_status = RF_ROUTER_DATA_WAIT;
rf_router_hsec = hsec;
}
}
