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