void *
_slang_realloc(void *oldBuffer, GLuint oldSize, GLuint newSize)
{
#if USE_MALLOC_FREE
return _mesa_realloc(oldBuffer, oldSize, newSize);
#else
GET_CURRENT_CONTEXT(ctx);
slang_mempool *pool = (slang_mempool *) ctx->Shader.MemPool;
if (newSize < oldSize) {
return oldBuffer;
}
else {
const GLuint copySize = (oldSize < newSize) ? oldSize : newSize;
void *newBuffer = _slang_alloc(newSize);
if (oldBuffer)
ASSERT(is_valid_address(pool, oldBuffer));
if (newBuffer && oldBuffer && copySize > 0)
_mesa_memcpy(newBuffer, oldBuffer, copySize);
return newBuffer;
}
#endif
}
void flash_inside_write(void* address,void* data,long length) {
char old_data[2]={0};
int old_data_int=0;
long the_last=length-1;
if (!is_valid_address(address)) return;
FLASH_Unlock();
if ((long)address%2!=0) {
flash_inside_read((void*)((long)address-1),old_data,2);
old_data[1]=*(char*)data;
memcpy(&old_data_int,old_data,sizeof(int));
FLASH_ProgramHalfWord((uint32_t)(FLASH_INSIDE_ADDRESS_START+(long)address-1),old_data_int);
--length;
}
for (;length>1;length-=2)
FLASH_ProgramHalfWord((uint32_t)(FLASH_INSIDE_ADDRESS_START+(long)address+length-2),*(uint16_t*)((long)data+length-2));
if (length) {
flash_inside_read((void*)((long)address+the_last),old_data,2);
old_data[0]=*(char*)((long)data+the_last);
memcpy(&old_data_int,old_data,sizeof(int));
FLASH_ProgramHalfWord((uint32_t)(FLASH_INSIDE_ADDRESS_START+(long)address+the_last),old_data_int);
}
FLASH_Lock();
FLASH_ClearFlag(FLASH_FLAG_BSY|FLASH_FLAG_EOP|FLASH_FLAG_PGERR|FLASH_FLAG_WRPRTERR);
}
/*---------------------------------------------------------------------*/
void sg2d_line( const struct rect *_rect, u8 color )
{
// struct gra_info _info;
// get_info( &_info );
u32 length = (_rect->width >= _rect->height) ? _rect->width : _rect->height;
f32 _posx = _rect->posx;
f32 _posy = _rect->posy;
f32 stepx = (f32)_rect->width / length;
f32 stepy = (f32)_rect->height / length;
u8 *addr = get_addr( _posy, _posx);
u16 i = 0;
// putn_col( (u32)_posx, 16*10, 16*1, 3 );
// putn_col( (u32)_posy, 16*10, 16*2, 3 );
// putn_col( (u32)stepx*100, 16*5, 16*1, 5 );
// putn_col( (u32)stepy*100, 16*5, 16*2, 5 );
for( ; i < length; ++i ) {
if( is_valid_address(addr+i) ) {
*addr = color;
}
_posx += stepx;
_posy += stepy;
addr = get_addr( _posy, _posx);
}
// putn_col( (u32)_posx, 16*22, 16*1, 3 );
// putn_col( (u32)_posy, 16*22, 16*2, 3 );
}
// check if the stack is valid
void stack_address_check(void* esp)
{
if(!is_valid_address(esp) || (int*)esp >= ((int*)PHYS_BASE - 2))
{
thread_current()->exit_status = -1;
process_terminate();
}
}
/*---------------------------------------------------------------------*/
void sg2d_move_pixel( u32 dstx, u32 dsty, const struct rect *src, u8 src_color )
{
// S_ASSERT( 0, "error" );
u32 x, y;
u8 *dst_addr, *src_addr;
for( y = 0; y < src->height; ++y ) {
for( x = 0; x < src->width; ++x ) {
dst_addr = get_addr((dsty+y), (dstx+x));
src_addr = get_addr((src->posy+y), (src->posx+x));
if( is_valid_address(src_addr) ) {
if( is_valid_address(dst_addr) ) {
*dst_addr = *src_addr;//src_color;//COLOR_BLUE;//*src_addr;
}
*src_addr = src_color;
}
}
}
}
// check for a range of address for validity
// the address should be below PHYS_BASE and
// should be mapped in the page_dir
// Range: [start, start+size-1]
//
// return 0/1 if invalid or valid
// * does not teminate the process
// * It checks at the page boundary only
int user_add_range_check(char* start, int size)
{
unsigned ptr;
for(ptr = (unsigned)start; ptr < (unsigned)(start+size);
ptr = ptr + (PGSIZE - ptr % PGSIZE)) // jump to last entry of a page
if(!is_valid_address((void*)ptr))
return 0;
return 1;
}
/**
* Don't actually free memory, but mark it (for debugging).
*/
void
_slang_free(void *addr)
{
#if USE_MALLOC_FREE
_mesa_free(addr);
#else
if (addr) {
GET_CURRENT_CONTEXT(ctx);
slang_mempool *pool = (slang_mempool *) ctx->Shader.MemPool;
ASSERT(is_valid_address(pool, addr));
}
#endif
}
static void recovery_xdata_block(struct hmfs_sb_info *sbi, seg_t src_segno,
int src_off, struct hmfs_summary *src_sum)
{
struct gc_move_arg arg;
struct hmfs_node *last = NULL, *this = NULL;
struct hmfs_cm_info *cm_i = CM_I(sbi);
block_t addr_in_par;
bool modify_vb = false;
int x_tag;
prepare_move_argument(&arg, sbi, src_segno, src_off, src_sum,
TYPE_DATA);
while (1) {
this = __get_node(sbi, arg.cp_i, arg.nid);
if (IS_ERR(this))
break;
if (this == last)
goto next;
x_tag = le64_to_cpu(XATTR_HDR(arg.src)->h_magic);
addr_in_par = XBLOCK_ADDR(this, x_tag);
if (addr_in_par != arg.src_addr && is_valid_address(sbi, addr_in_par)) {
break;
}
if (addr_in_par != arg.src_addr) {
hmfs_memcpy_atomic(JUMP(this, x_tag), &arg.src_addr, 8);
if (!modify_vb) {
arg.dest_sum = get_summary_by_addr(sbi, addr_in_par);
clear_summary_valid_bit(arg.dest_sum);
modify_vb = true;
}
}
last = this;
next:
if (arg.cp_i == cm_i->last_cp_i)
break;
arg.cp_i = get_next_checkpoint_info(sbi, arg.cp_i);
}
}
static void recovery_node_block(struct hmfs_sb_info *sbi, seg_t src_segno,
unsigned int src_off, struct hmfs_summary *src_sum)
{
struct hmfs_nat_block *last = NULL, *this = NULL;
struct gc_move_arg args;
block_t addr_in_par;
bool modify_vb = false;
prepare_move_argument(&args, sbi, src_segno, src_off, src_sum, TYPE_NODE);
while (1) {
this = get_nat_entry_block(sbi, args.cp_i->version, args.nid);
if (IS_ERR(this))
break;
if (this == last)
goto next;
addr_in_par = le64_to_cpu(this->entries[args.ofs_in_node].block_addr);
/* Src node has been COW or removed */
if (addr_in_par != args.src_addr && is_valid_address(sbi, addr_in_par)) {
break;
}
if (addr_in_par != args.src_addr) {
hmfs_memcpy_atomic(&this->entries[args.ofs_in_node].block_addr,
&args.src_addr, 8);
if (!modify_vb) {
args.dest_sum = get_summary_by_addr(sbi, addr_in_par);
clear_summary_valid_bit(args.dest_sum);
modify_vb = true;
}
}
last = this;
next:
if (args.cp_i == CM_I(sbi)->last_cp_i)
break;
args.cp_i = get_next_checkpoint_info(sbi, args.cp_i);
}
}
/*---------------------------------------------------------------------*/
void sg2d_fill_pixel( const struct rect *_rect, u8 color )
{
u32 screen_ofsx = 0;//_info.screen_width >> 1;
u32 screen_ofsy = 0;//_info.screen_height >> 1;
u8 *addr = NULL;
u32 y,x;
// vector2_t pos, base;
for( y = 0; y < _rect->height; ++y ) {
// base.y = _rect->posy + y;
for( x = 0; x < _rect->width; ++x ) {
// base.x = _rect->posx + x;
// rotate( &pos, &base, rot );
addr = get_addr( (_rect->posy+y), (_rect->posx+x) );
if( is_valid_address(addr) ) {
*addr = color;
}
}
}
}
RF24Network::RF24Network( RF24& _radio ): radio(_radio), frame_size(MAX_FRAME_SIZE)
#else
RF24Network::RF24Network( RF24& _radio, RF24& _radio1 ): radio(_radio), radio1(_radio1),frame_size(MAX_FRAME_SIZE)
#endif
{
}
#elif !defined (DUAL_HEAD_RADIO)
RF24Network::RF24Network( RF24& _radio ): radio(_radio), next_frame(frame_queue)
{
}
#else
RF24Network::RF24Network( RF24& _radio, RF24& _radio1 ): radio(_radio), radio1(_radio1), next_frame(frame_queue)
{
}
#endif
/******************************************************************/
void RF24Network::begin(uint8_t _channel, uint16_t _node_address )
{
if (! is_valid_address(_node_address) )
return;
node_address = _node_address;
if ( ! radio.isValid() ){
return;
}
//radio.stopListening();
// Set up the radio the way we want it to look
radio.setChannel(_channel);
radio.enableDynamicAck();
radio.enableDynamicPayloads();
// Use different retry periods to reduce data collisions
uint8_t retryVar = (((node_address % 6)+1) *2) + 3;
radio.setRetries(retryVar, 5);
txTimeout = 25;
routeTimeout = txTimeout*9; // Adjust for max delay per node
#if defined (DUAL_HEAD_RADIO)
radio1.setChannel(_channel);
radio1.enableDynamicAck();
radio1.enableDynamicPayloads();
#endif
// Setup our address helper cache
setup_address();
// Open up all listening pipes
uint8_t i = 6;
while (i--){
radio.openReadingPipe(i,pipe_address(_node_address,i));
}
radio.startListening();
}
/******************************************************************/
#if defined ENABLE_NETWORK_STATS
void RF24Network::failures(uint32_t *_fails, uint32_t *_ok){
*_fails = nFails;
*_ok = nOK;
}
uint8_t RF24Network::update(void)
{
// if there is data ready
uint8_t pipe_num;
uint8_t returnVal = 0;
while ( radio.isValid() && radio.available(&pipe_num) )
{
if( (frame_size = radio.getDynamicPayloadSize() ) < sizeof(RF24NetworkHeader)){
delay(10);
continue;
}
// Dump the payloads until we've gotten everything
// Fetch the payload, and see if this was the last one.
//radio.read( frame_buffer, sizeof(frame_buffer) );
radio.read( frame_buffer, frame_size );
// Read the beginning of the frame as the header
//RF24NetworkHeader& header = reinterpret_cast<RF24NetworkHeader&>(frame_buffer);
RF24NetworkHeader *header = (RF24NetworkHeader*)(&frame_buffer);
#if defined (RF24_LINUX)
IF_SERIAL_DEBUG(printf_P("%u: MAC Received on %u %s\n\r",millis(),pipe_num,header->toString()));
if (frame_size) {
IF_SERIAL_DEBUG_FRAGMENTATION_L2(printf("%u: FRG Rcv frame size %i\n",millis(),frame_size););
IF_SERIAL_DEBUG_FRAGMENTATION_L2(printf("%u: FRG Rcv frame ",millis()); const char* charPtr = reinterpret_cast<const char*>(frame_buffer); for (size_t i = 0; i < frame_size; i++) { printf("%02X ", charPtr[i]); }; printf("\n\r"));
}
#else
IF_SERIAL_DEBUG(printf_P(PSTR("%lu: MAC Received on %u %s\n\r"),millis(),pipe_num,header->toString()));
IF_SERIAL_DEBUG(const uint16_t* i = reinterpret_cast<const uint16_t*>(frame_buffer + sizeof(RF24NetworkHeader));printf_P(PSTR("%lu: NET message %04x\n\r"),millis(),*i));
#endif
// Throw it away if it's not a valid address
if ( !is_valid_address(header->to_node) ){
continue;
}
/* #if defined (RF24_LINUX)
RF24NetworkFrame frame = RF24NetworkFrame(*header,frame_buffer+sizeof(RF24NetworkHeader),frame_size-sizeof(RF24NetworkHeader));
#else
RF24NetworkFrame frame = RF24NetworkFrame(*header,frame_size-sizeof(RF24NetworkHeader));
frame.message_buffer = frame_buffer+sizeof(RF24NetworkHeader);
#endif*/
uint8_t returnVal = header->type;
//printf("got\n");
// Is this for us?
if ( header->to_node == node_address ){
if(header->type == NETWORK_PING){
continue;
}
if(header->type == NETWORK_ADDR_RESPONSE ){
uint16_t requester = frame_buffer[8];
requester |= frame_buffer[9] << 8;
if(requester != node_address){
header->to_node = requester;
write(header->to_node,USER_TX_TO_PHYSICAL_ADDRESS);
delay(15);
write(header->to_node,USER_TX_TO_PHYSICAL_ADDRESS);
//printf("Fwd add response to 0%o\n",requester);
continue;
}
}
if(header->type == NETWORK_REQ_ADDRESS && node_address){
//printf("Fwd add req to 0\n");
header->from_node = node_address;
header->to_node = 0;
write(header->to_node,TX_NORMAL);
continue;
}
if( (returnSysMsgs && header->type > 127) || header->type == NETWORK_ACK ){
IF_SERIAL_DEBUG_ROUTING( printf_P(PSTR("%lu MAC: System payload rcvd %d\n"),millis(),returnVal); );
//if( (header->type < 148 || header->type > 150) && header->type != NETWORK_MORE_FRAGMENTS_NACK && header->type != EXTERNAL_DATA_TYPE && header->type!= NETWORK_LAST_FRAGMENT){
if( header->type != NETWORK_FIRST_FRAGMENT && header->type != NETWORK_MORE_FRAGMENTS && header->type != NETWORK_MORE_FRAGMENTS_NACK && header->type != EXTERNAL_DATA_TYPE && header->type!= NETWORK_LAST_FRAGMENT){
return returnVal;
}
}
/* Safely (avoiding SIGSEGV / SIGBUS) scan the entire valid address
space and pass the addresses and values of all addressible,
defined, aligned words to notify_word. This is the basis for the
leak detector. Returns the number of calls made to notify_word.
Addresses are validated 3 ways. First we enquire whether (addr >>
16) denotes a 64k chunk in use, by asking is_valid_64k_chunk(). If
so, we decide for ourselves whether each x86-level (4 K) page in
the chunk is safe to inspect. If yes, we enquire with
is_valid_address() whether or not each of the 1024 word-locations
on the page is valid. Only if so are that address and its contents
passed to notify_word.
This is all to avoid duplication of this machinery between the
memcheck and addrcheck skins.
*/
static
UInt vg_scan_all_valid_memory ( Bool is_valid_64k_chunk ( UInt ),
Bool is_valid_address ( Addr ),
void (*notify_word)( Addr, UInt ) )
{
/* All volatile, because some gccs seem paranoid about longjmp(). */
volatile Bool anyValid;
volatile Addr pageBase, addr;
volatile UInt res, numPages, page, primaryMapNo;
volatile UInt page_first_word, nWordsNotified;
vki_ksigaction sigbus_saved;
vki_ksigaction sigbus_new;
vki_ksigaction sigsegv_saved;
vki_ksigaction sigsegv_new;
vki_ksigset_t blockmask_saved;
vki_ksigset_t unblockmask_new;
/* Temporarily install a new sigsegv and sigbus handler, and make
sure SIGBUS, SIGSEGV and SIGTERM are unblocked. (Perhaps the
first two can never be blocked anyway?) */
sigbus_new.ksa_handler = vg_scan_all_valid_memory_sighandler;
sigbus_new.ksa_flags = VKI_SA_ONSTACK | VKI_SA_RESTART;
sigbus_new.ksa_restorer = NULL;
res = VG_(ksigemptyset)( &sigbus_new.ksa_mask );
sk_assert(res == 0);
sigsegv_new.ksa_handler = vg_scan_all_valid_memory_sighandler;
sigsegv_new.ksa_flags = VKI_SA_ONSTACK | VKI_SA_RESTART;
sigsegv_new.ksa_restorer = NULL;
res = VG_(ksigemptyset)( &sigsegv_new.ksa_mask );
sk_assert(res == 0+0);
res = VG_(ksigemptyset)( &unblockmask_new );
res |= VG_(ksigaddset)( &unblockmask_new, VKI_SIGBUS );
res |= VG_(ksigaddset)( &unblockmask_new, VKI_SIGSEGV );
res |= VG_(ksigaddset)( &unblockmask_new, VKI_SIGTERM );
sk_assert(res == 0+0+0);
res = VG_(ksigaction)( VKI_SIGBUS, &sigbus_new, &sigbus_saved );
sk_assert(res == 0+0+0+0);
res = VG_(ksigaction)( VKI_SIGSEGV, &sigsegv_new, &sigsegv_saved );
sk_assert(res == 0+0+0+0+0);
res = VG_(ksigprocmask)( VKI_SIG_UNBLOCK, &unblockmask_new, &blockmask_saved );
sk_assert(res == 0+0+0+0+0+0);
/* The signal handlers are installed. Actually do the memory scan. */
numPages = 1 << (32-VKI_BYTES_PER_PAGE_BITS);
sk_assert(numPages == 1048576);
sk_assert(4096 == (1 << VKI_BYTES_PER_PAGE_BITS));
nWordsNotified = 0;
for (page = 0; page < numPages; page++) {
/* Base address of this 4k page. */
pageBase = page << VKI_BYTES_PER_PAGE_BITS;
/* Skip if this page is in an unused 64k chunk. */
primaryMapNo = pageBase >> 16;
if (!is_valid_64k_chunk(primaryMapNo))
continue;
/* Next, establish whether or not we want to consider any
locations on this page. We need to do so before actually
prodding it, because prodding it when in fact it is not
needed can cause a page fault which under some rare
circumstances can cause the kernel to extend the stack
segment all the way down to here, which is seriously bad.
Hence: */
anyValid = False;
for (addr = pageBase; addr < pageBase+VKI_BYTES_PER_PAGE; addr += 4) {
if (is_valid_address(addr)) {
anyValid = True;
break;
}
}
if (!anyValid)
continue; /* nothing interesting here .. move to the next page */
/* Ok, we have to prod cautiously at the page and see if it
explodes or not. */
if (__builtin_setjmp(memscan_jmpbuf) == 0) {
/* try this ... */
page_first_word = * (volatile UInt*)pageBase;
/* we get here if we didn't get a fault */
/* Scan the page */
for (addr = pageBase; addr < pageBase+VKI_BYTES_PER_PAGE; addr += 4) {
if (is_valid_address(addr)) {
nWordsNotified++;
notify_word ( addr, *(UInt*)addr );
}
}
} else {
/* We get here if reading the first word of the page caused a
fault, which in turn caused the signal handler to longjmp.
Ignore this page. */
if (0)
VG_(printf)(
"vg_scan_all_valid_memory_sighandler: ignoring page at %p\n",
(void*)pageBase
);
}
}
/* Restore signal state to whatever it was before. */
res = VG_(ksigaction)( VKI_SIGBUS, &sigbus_saved, NULL );
sk_assert(res == 0 +0);
res = VG_(ksigaction)( VKI_SIGSEGV, &sigsegv_saved, NULL );
sk_assert(res == 0 +0 +0);
res = VG_(ksigprocmask)( VKI_SIG_SETMASK, &blockmask_saved, NULL );
sk_assert(res == 0 +0 +0 +0);
return nWordsNotified;
}
static void recovery_data_block(struct hmfs_sb_info *sbi, seg_t src_segno,
int src_off, struct hmfs_summary *src_sum)
{
struct gc_move_arg args;
struct hmfs_node *last = NULL, *this = NULL;
struct hmfs_summary *par_sum;
struct hmfs_cm_info *cm_i = CM_I(sbi);
bool modify_vb = false;
block_t addr_in_par;
int par_type;
prepare_move_argument(&args, sbi, src_segno, src_off, src_sum,
TYPE_DATA);
while (1) {
this = __get_node(sbi, args.cp_i, args.nid);
par_sum = get_summary_by_addr(sbi, L_ADDR(sbi, this));
if (IS_ERR(this)) {
/* the node(args.nid) has been deleted */
break;
}
if (this == last)
goto next;
par_type = get_summary_type(par_sum);
if (par_type == SUM_TYPE_INODE) {
addr_in_par = le64_to_cpu(this->i.i_addr[args.ofs_in_node]);
} else {
addr_in_par = le64_to_cpu(this->dn.addr[args.ofs_in_node]);
}
/*
* In recovery, the address stored in parent node would be
* arg.src_addr or an invalid address. Because GC might terminate
* in the loop change this address.
* Condition addr_in_par != args.src_addr is not sufficient
* to terminate recovery. For example, we delete a node in a
* checkpoint and reuse it later. And address in reused node
* is not equal to args.src_addr but we could not modify it.
* Luckly, the child block in that node is valid and we could
* judge this case by the value of address.
*/
if (addr_in_par != args.src_addr && is_valid_address(sbi, addr_in_par))
break;
if (addr_in_par != args.src_addr) {
/* Recover address in parent node */
if (par_type == SUM_TYPE_INODE) {
hmfs_memcpy_atomic(&this->i.i_addr[args.ofs_in_node],
&args.src_addr, 8);
} else {
hmfs_memcpy_atomic(&this->dn.addr[args.ofs_in_node],
&args.src_addr, 8);
}
if (!modify_vb) {
args.dest_sum = get_summary_by_addr(sbi, addr_in_par);
clear_summary_valid_bit(args.dest_sum);
modify_vb = true;
}
}
last = this;
next:
if (args.cp_i == cm_i->last_cp_i)
break;
args.cp_i = get_next_checkpoint_info(sbi, args.cp_i);
}
}
static void recovery_nat_block(struct hmfs_sb_info *sbi, seg_t src_segno, int src_off,
struct hmfs_summary *src_sum)
{
void *last = NULL, *this = NULL;
struct hmfs_checkpoint *hmfs_cp = NULL;
struct hmfs_nat_node *nat_node = NULL;
struct gc_move_arg args;
bool modify_vb = false;
nid_t par_nid;
block_t addr_in_par;
prepare_move_argument(&args, sbi, src_segno, src_off, src_sum, TYPE_NODE);
while (1) {
if (IS_NAT_ROOT(args.nid))
this = args.cp_i->cp;
else {
par_nid = MAKE_NAT_NODE_NID(GET_NAT_NODE_HEIGHT(args.nid) - 1,
GET_NAT_NODE_OFS(args.nid));
this = get_nat_node(sbi, args.cp_i->version, par_nid);
}
hmfs_bug_on(sbi, !this);
if (this == last)
goto next;
if (IS_NAT_ROOT(args.nid)) {
hmfs_cp = HMFS_CHECKPOINT(this);
addr_in_par = le64_to_cpu(hmfs_cp->nat_addr);
} else {
nat_node = HMFS_NAT_NODE(this);
addr_in_par = le64_to_cpu(nat_node->addr[args.ofs_in_node]);
}
if (addr_in_par != args.src_addr && is_valid_address(sbi, addr_in_par)) {
break;
}
if (addr_in_par != args.src_addr) {
if (IS_NAT_ROOT(args.nid)) {
hmfs_memcpy_atomic(&hmfs_cp->nat_addr, &args.src_addr, 8);
} else {
hmfs_memcpy_atomic(&nat_node->addr[args.ofs_in_node],
&args.src_addr, 8);
}
if (!modify_vb) {
args.dest_sum = get_summary_by_addr(sbi, addr_in_par);
clear_summary_valid_bit(args.dest_sum);
modify_vb = true;
}
}
last = this;
next:
if (args.cp_i == CM_I(sbi)->last_cp_i)
break;
args.cp_i = get_next_checkpoint_info(sbi, args.cp_i);
}
}
uint8_t RF24Network::update(void)
{
// if there is data ready
uint8_t pipe_num;
uint8_t returnVal = 0;
// If bypass is enabled, continue although incoming user data may be dropped
// Allows system payloads to be read while user cache is full
// Incoming Hold prevents data from being read from the radio, preventing incoming payloads from being acked
#if !defined (RF24_LINUX)
if(!(networkFlags & FLAG_BYPASS_HOLDS)){
if( (networkFlags & FLAG_HOLD_INCOMING) || (next_frame-frame_queue) + 34 > MAIN_BUFFER_SIZE ){
if(!available()){
networkFlags &= ~FLAG_HOLD_INCOMING;
}else{
return 0;
}
}
}
#endif
while ( radio.isValid() && radio.available(&pipe_num) ){
#if defined (ENABLE_DYNAMIC_PAYLOADS)
if( (frame_size = radio.getDynamicPayloadSize() ) < sizeof(RF24NetworkHeader)){
delay(10);
continue;
}
#else
frame_size=32;
#endif
// Dump the payloads until we've gotten everything
// Fetch the payload, and see if this was the last one.
radio.read( frame_buffer, frame_size );
// Read the beginning of the frame as the header
RF24NetworkHeader *header = (RF24NetworkHeader*)(&frame_buffer);
#if defined (RF24_LINUX)
IF_SERIAL_DEBUG(printf_P("%u: MAC Received on %u %s\n\r",millis(),pipe_num,header->toString()));
if (frame_size) {
IF_SERIAL_DEBUG_FRAGMENTATION_L2(printf("%u: FRG Rcv frame size %i\n",millis(),frame_size););
IF_SERIAL_DEBUG_FRAGMENTATION_L2(printf("%u: FRG Rcv frame ",millis()); const char* charPtr = reinterpret_cast<const char*>(frame_buffer); for (uint16_t i = 0; i < frame_size; i++) { printf("%02X ", charPtr[i]); }; printf("\n\r"));
}
#else
IF_SERIAL_DEBUG(printf_P(PSTR("%lu: MAC Received on %u %s\n\r"),millis(),pipe_num,header->toString()));
IF_SERIAL_DEBUG(const uint16_t* i = reinterpret_cast<const uint16_t*>(frame_buffer + sizeof(RF24NetworkHeader));printf_P(PSTR("%lu: NET message %04x\n\r"),millis(),*i));
#endif
// Throw it away if it's not a valid address
if ( !is_valid_address(header->to_node) ){
continue;
}
uint8_t returnVal = header->type;
// Is this for us?
if ( header->to_node == node_address ){
if(header->type == NETWORK_PING){
continue;
}
if(header->type == NETWORK_ADDR_RESPONSE ){
uint16_t requester = 04444;
if(requester != node_address){
header->to_node = requester;
write(header->to_node,USER_TX_TO_PHYSICAL_ADDRESS);
delay(10);
write(header->to_node,USER_TX_TO_PHYSICAL_ADDRESS);
//printf("Fwd add response to 0%o\n",requester);
continue;
}
}
if(header->type == NETWORK_REQ_ADDRESS && node_address){
//printf("Fwd add req to 0\n");
header->from_node = node_address;
header->to_node = 0;
write(header->to_node,TX_NORMAL);
continue;
}
if( (returnSysMsgs && header->type > 127) || header->type == NETWORK_ACK ){
IF_SERIAL_DEBUG_ROUTING( printf_P(PSTR("%lu MAC: System payload rcvd %d\n"),millis(),returnVal); );
//if( (header->type < 148 || header->type > 150) && header->type != NETWORK_MORE_FRAGMENTS_NACK && header->type != EXTERNAL_DATA_TYPE && header->type!= NETWORK_LAST_FRAGMENT){
if( header->type != NETWORK_FIRST_FRAGMENT && header->type != NETWORK_MORE_FRAGMENTS && header->type != NETWORK_MORE_FRAGMENTS_NACK && header->type != EXTERNAL_DATA_TYPE && header->type!= NETWORK_LAST_FRAGMENT){
return returnVal;
}
}
RF24Network::RF24Network( RF24& _radio ): radio(_radio), frame_size(MAX_FRAME_SIZE)
#else
RF24Network::RF24Network( RF24& _radio, RF24& _radio1 ): radio(_radio), radio1(_radio1),frame_size(MAX_FRAME_SIZE)
#endif
{
}
#elif !defined (DUAL_HEAD_RADIO)
RF24Network::RF24Network( RF24& _radio ): radio(_radio), next_frame(frame_queue)
{
#if !defined ( DISABLE_FRAGMENTATION )
frag_queue.message_buffer=&frag_queue_message_buffer[0];
frag_ptr = &frag_queue;
#endif
}
#else
RF24Network::RF24Network( RF24& _radio, RF24& _radio1 ): radio(_radio), radio1(_radio1), next_frame(frame_queue)
{
#if !defined ( DISABLE_FRAGMENTATION )
frag_queue.message_buffer=&frag_queue_message_buffer[0];
frag_ptr = &frag_queue;
#endif
}
#endif
/******************************************************************/
void RF24Network::begin(uint8_t _channel, uint16_t _node_address )
{
if (! is_valid_address(_node_address) )
return;
node_address = _node_address;
if ( ! radio.isValid() ){
return;
}
// Set up the radio the way we want it to look
if(_channel != USE_CURRENT_CHANNEL){
radio.setChannel(_channel);
}
//radio.enableDynamicAck();
radio.setAutoAck(0,0);
#if defined (ENABLE_DYNAMIC_PAYLOADS)
radio.enableDynamicPayloads();
#endif
// Use different retry periods to reduce data collisions
uint8_t retryVar = (((node_address % 6)+1) *2) + 3;
radio.setRetries(retryVar, 5); // max about 85ms per attempt
txTimeout = 25;
routeTimeout = txTimeout*3; // Adjust for max delay per node within a single chain
#if defined (DUAL_HEAD_RADIO)
radio1.setChannel(_channel);
radio1.enableDynamicAck();
radio1.enableDynamicPayloads();
#endif
// Setup our address helper cache
setup_address();
// Open up all listening pipes
uint8_t i = 6;
while (i--){
radio.openReadingPipe(i,pipe_address(_node_address,i));
}
radio.startListening();
}
/******************************************************************/
#if defined ENABLE_NETWORK_STATS
void RF24Network::failures(uint32_t *_fails, uint32_t *_ok){
*_fails = nFails;
*_ok = nOK;
}
void flash_inside_read(void* address,void* data,long length) {
if (!is_valid_address(address)) return;
while (length--)
*(char*)((long)data+length)=*(char*)(FLASH_INSIDE_ADDRESS_START+(long)address+length);
}
