macm.nc.svn-base

802.15.4协议的实现

		post create_gts_request();
		printfUART("SEND GTS REQUEST \n", "");
	}
	*/
	//printfUART("ENTERING SLOT: %i Final slot: %i \n", number_bb,final_CAP_slot);
	
	if (number_bb >= final_CAP_slot )
	{
		printfUART("FINAL SLOT \n", "");
		atomic{
		
			if(number_bb == s_GTSss || number_bb == r_GTSss )
			{
			
				//printfUART("s_GTSss: %u r_GTSss: %u\n", s_GTSss,r_GTSss);
				if(number_bb == s_GTSss)
				{	
					printfUART("MY SEND SLOT \n", "");
					//send start slot
					trx_status = PHY_TX_ON;
					post set_trx();
					on_s_GTS =1;
					s_GTS_length --;
					if (s_GTS_length != 0 )
					{
						s_GTSss++;
					}
					if (gts_buffer_count > 0 )
					{
						//printfUART("HAVE DATA TO SEND\n", "");
						//call PD_DATA.request(gts_frame_to_send->length,gts_frame_to_send);
						//post send_gts_frame();
					}
					
					
				}
				else			
				{
					printfUART("MY RECEIVE SLOT \n", "");
					//number_bb == r_GTSss: //receive start slot
					on_r_GTS =1;
					trx_status = PHY_RX_ON;
					post set_trx();
					r_GTS_length --;
					if (r_GTS_length != 0 )
					{
						r_GTSss++;
					}
				}				
			}
			else
			{
				//idle
				on_s_GTS=0;
				on_r_GTS=0;
				trx_status = PHY_TRX_OFF;
				post set_trx();
			}
		}
	}
	
	atomic{
	
		if( csma_locate_backoff_boundary == 1 )
		{
			csma_locate_backoff_boundary=0;
			
			post start_csma_ca_slotted();
		}
		if( csma_cca_backoff_boundary == 1 )
			post perform_csma_ca_slotted();
	}


	if (gts_buffer_count > 0 && number_bb == s_GTSss - 1 )
	{
		atomic{
		
			gts_index_to_send =transmit_gts_buffer_element(0,s_GTSss);
		
			gts_frame_to_send = (MPDU *) gts_buffer_list[gts_index_to_send].frame;
		}
		printfUART("gts_index_to_send%i\n", gts_index_to_send);
		
	}

	//printfUART("%i - %i\n", number_bb,number_b);
	
	//printfUART("BB%i\n", number_bb);
	
return SUCCESS;
}

task void send_gts_frame()
{
	atomic send_frame(gts_frame_to_send->length,(uint8_t *) gts_frame_to_send,TYPE_DATA,0);
}

/*******************Timer BACKOFF PERIOD******************/
async event result_t TimerAsync.b_fired()
{

	//CSMA/CA
	atomic{
		
		if(csma_delay == 1 )
		{
			if (delay_backoff_period == 0)
			{
				if(csma_slotted == 0)
				{
					post perform_csma_ca_unslotted();
				}
				else
				{
					//CSMA/CA SLOTTED
					csma_delay=0;
					csma_cca_backoff_boundary=1;
				}
			}
			delay_backoff_period--;
		}
	}

	number_b++;

return SUCCESS;
}


task void set_trx()
{
	atomic call PLME_SET_TRX_STATE.request(trx_status);//PHY_RX_ON
	return;
}

task void create_data()
{
	create_data_frame(SHORT_ADDRESS, 0x0000, 0x00, SHORT_ADDRESS, 0x0000, 0x00, 10, msdu_pay,1,set_txoptions(1,0,1,0),0,0);
	
return;
}





task void signal_loss()
{
	atomic signal MLME_SYNC_LOSS.indication(beacon_loss_reason); //MAC_BEACON_LOSS
	return;
}

/*******************T_scan_duration**************************/ 
event result_t T_scan_duration.fired() 
{
	uint8_t channel_to_scan;
	
	printfUART("T_scan_duration.fired\n", "");

	channel_to_scan= pow(2,current_scanning);
		
	while ( (channels_to_scan & channel_to_scan ) == 0x00 )
	{
		channel_to_scan++;
		if (current_scanning == 16 )
				return SUCCESS;
	}
	current_scanning++;
	
	switch(scan_type)
	{
		//ED SCAN only FFD			
		case 0x00: 	call PLME_SET.request(PHYCURRENTCHANNEL, original_channel + current_scanning);  //change the channel
					call PLME_ED.request();
					break;
		//active scan only FFD
		case 0x01:
					break;
		//passive scan
		case 0x02:	
					break;
		//orphan scan
		case 0x03:
					break;
	
		default:
					break;
	}
	
	//end of scan
	if (current_scanning == 16 )
	{
		//signal upper layer
		scanning_channels = 0;
		
			switch(scan_type)
			{
				//ED SCAN only FFD												//total number of scans
				case 0x00: 	signal MLME_SCAN.confirm(MAC_SUCCESS,scan_type, 0x00, scan_count -1 , scanned_values, 0x00);
							
							break;
				//active scan only FFD
				case 0x01:
							break;
				//passive scan
				case 0x02:	
							break;
				//orphan scan
				case 0x03:
							break;
			
				default:
							break;
			}
	}
	return SUCCESS;
  }


/*******************T_ResponseWaitTime**************************/
event result_t T_ResponseWaitTime.fired()
{
	printfUART("T_ResponseWaitTime.fired\n", "");

	if (associating == 1)
	{
		printfUART("association failed\n", "");
		associating=0;
		signal MLME_ASSOCIATE.confirm(0x0000,MAC_NO_DATA);
		
	}

	return SUCCESS;
}

/***************TEST TIMER***************/
event result_t T_cca.fired()
{
	//uint32_t SrcAddr[2];
	//uint32_t DstAddr[2];
		//call Leds.redToggle();
		
		//post create_data();
		
		//atomic mac_PIB.macShortAddress = TOS_LOCAL_ADDRESS;
		
//		create_gts_request_cmd(set_gts_characteristics(1, GTS_RX_ONLY, 0));

//uint32_t t;
   // clearCCA = TOSH_READ_CC_CCA_PIN();
	
		//call PLME_ED.request();
	
	//t= TOSH_READ_CC_SFD_PIN();


	//create_beacon_request_cmd();
	//create_disassociation_notification_cmd(MAC_PAN_DEVICE_LEAVE);

	//create_gts_request_cmd();
 
	//create_disassociation_notification_cmd(MAC_PAN_DEVICE_LEAVE);
 
	return SUCCESS;
}

//TEST
task void test_send_data()
{

	uint32_t SrcAddr[2];
	uint32_t DstAddr[2];

	SrcAddr[0]= 0x00000000;
	SrcAddr[1]= 0x00000001;
	
	DstAddr[0]= 0x00000000;
	DstAddr[1]= 0x00000002;
	
	//TEST data send
	//uint8_t SrcAddrMode, uint16_t SrcPANId, uint32_t SrcAddr[], uint8_t DstAddrMode, uint16_t DestPANId, uint32_t DstAddr[], uint8_t msduLength, uint8_t msdu[],uint8_t msduHandle, uint8_t TxOptions)
	create_data_frame(SHORT_ADDRESS, 0x0000, SrcAddr, LONG_ADDRESS, 0x0000, DstAddr, 10, msdu_pay,1,set_txoptions(1,0,1,0),0,0);
	//END TEST
return;
}


/*******************T_ackwait**************************/
event result_t T_ackwait.fired()
{
	//printfUART("T_ackwait.fired \n", "");
	ack_wait=0;
	if (ack_received == 1)
	{
		printfUART("Ack SUCCESS \n", "");
	}
	else
	{
		printfUART("ACK FAIL \n", "");
		
		if (associating == 1)
		{
			//try again
			association_retries--;
			if (association_retries==0)
			{
				printfUART("association failed \n", "");
				associating=0;
				signal MLME_ASSOCIATE.confirm(0x0000,MAC_NO_ACK);
			}
			else
			{
				printfUART("ASSOCIATION RETRY association_retries: %i\n", association_retries);
				
				create_association_request_cmd(a_CoordAddrMode,a_CoordPANId,a_CoordAddress);
			}
		}
	}
	
	return SUCCESS;
}

/*****************************************************************************************************/
/*****************************************************************************************************/
/*****************************************************************************************************/
/************************		BUILD FRAMES FUNCTIONS   			**********************************/
/*****************************************************************************************************/ 
/*****************************************************************************************************/
/*****************************************************************************************************/


task void create_beacon()
{
	int i;
	uint8_t packet_length = 25;
	int data_count;
	
	uint8_t gts_directions=0x00;
	
	atomic{
		
		beacon_addr_short *mac_beacon_addr_short_ptr;
		mac_beacon_addr_short_ptr = (beacon_addr_short*) &mac_txmpdu.data[0];
	
		//call PLME_SET_TRX_STATE.request(PHY_TX_ON);
		
		mac_txmpdu_ptr->length = 15;
		mac_txmpdu_ptr->frame_control = set_frame_control(TYPE_BEACON,0,0,0,1,SHORT_ADDRESS,SHORT_ADDRESS);
		mac_txmpdu_ptr->seq_num = mac_PIB.macBSN;
		mac_PIB.macBSN++;
		 
		mac_beacon_addr_short_ptr->source_PAN_identifier = mac_PIB.macPANId;
		mac_beacon_addr_short_ptr->destination_address = 0xffff;
		mac_beacon_addr_short_ptr->source_address = mac_PIB.macShortAddress;
		mac_beacon_addr_short_ptr->superframe_specification = set_superframe_specification(mac_PIB.macBeaconOrder,(uint8_t)mac_PIB.macSuperframeOrder,final_CAP_slot,0,1,0);
		
		mac_txmpdu_ptr->data[8] = set_gts_specification(GTS_descriptor_count,mac_PIB.macGTSPermit);
		
		mac_txmpdu_ptr->data[9] = set_pending_address_specification(short_addr_pending,long_addr_pending);
		
		data_count = 9;
		packet_length = 15;
		
		//BUILDING the GTS DESCRIPTORS
		if( GTS_descriptor_count > 0 )
		{
			data_count++;
					
			for(i=0; i< 7 ; i++)
			{
				if( GTS_db[i].gts_id != 0x00 && GTS_db[i].DevAddressType != 0x0000) 
				{
					
					mac_txmpdu_ptr->data[data_count] = GTS_db[i].DevAddressType;
					//printfUART("B gts %i\n", (GTS_db[i].DevAddressType >> 8 ) ); 
					
					data_count++;
					mac_txmpdu_ptr->data[data_count] = (GTS_db[i].DevAddressType >> 8 );
					//printfUART("B gts %i\n",  GTS_db[i].DevAddressType ); 
					
					data_count++;
					
					mac_txmpdu_ptr->data[data_count] = set_gts_descriptor(i,GTS_db[i].length);
					data_count++;
					//printfUART("B gts %i\n", set_gts_descriptor(GTS_db[i].starting_slot,GTS_db[i].length) ); 
					
					packet_length = packet_length +3;
					
					if ( GTS_db[i].direction == 1 )
					{
						gts_directions = gts_directions | (1 << i); 
					}
					else
					{
						gts_directions = gts_directions | (0 << i); 
					}
					
					//printfUART("dir %i\n", gts_directions); 
				}
			}
			
			mac_txmpdu_ptr->data[9] = gts_directions;
		
			//BUILDING the NULL GTS DESCRIPTORS
			if ( GTS_null_descriptor_count > 0 )
			{
				for(i=0; i< 7 ; i++)
				{
					if( GTS_null_db[i].DevAddressType != 0x0000) 
					{
						mac_txmpdu_ptr->data[data_count] = GTS_null_db[i].DevAddressType;
						//printfUART("B gts %i\n", (GTS_db[i].DevAddressType >> 8 ) ); 
						data_count++;
						mac_txmpdu_ptr->data[data_count] = (GTS_null_db[i].DevAddressType >> 8 );
						//printfUART("B gts %i\n",  GTS_db[i].DevAddressType ); 
						data_count++;
						mac_txmpdu_ptr->data[data_count] = 0x00;
						data_count++;
						//printfUART("B gts %i\n", set_gts_descriptor(GTS_db[i].starting_slot,GTS_db[i].length) ); 
						packet_length = packet_length +3;
					}
				}
			}
	
			//resetting the GTS specification field
			mac_txmpdu_ptr->data[8] = set_gts_specification(GTS_descriptor_count + GTS_null_descriptor_count,mac_PIB.macGTSPermit);
		
			mac_txmpdu_ptr->data[data_count] = set_pending_address_specification(short_addr_pending,long_addr_pending);
			packet_length++;
		}
		
		
		
		mac_txmpdu_ptr->length = packet_length;
		
		
		send_beacon_length = packet_length;
		
		send_beacon_frame_ptr = (uint8_t*)mac_txmpdu_ptr;
		
		}
		//send_frame(mac_txmpdu_ptr->length,(uint8_t*)mac_txmpdu_ptr,TYPE_BEACON,0);
		//call PD_DATA.request(16,(uint8_t*)mac_txmpdu_ptr);
}


void create_association_response_cmd(uint32_t DeviceAddress[],uint16_t shortaddress, uint8_t status)
{

atomic{
	cmd_association_response *mac_association_response;
	

	//creation of a pointer to the association response structure
	mac_association_response = (cmd_association_response*) &mac_txmpdu.data;									
	
	mac_txmpdu_ptr->length = 29;
	mac_txmpdu_ptr->frame_control = set_frame_control(TYPE_CMD,0,0,1,0,LONG_ADDRESS,LONG_ADDRESS);
	mac_txmpdu_ptr->seq_num = mac_PIB.macDSN;
	mac_PIB.macDSN++;
	
	mac_association_response->destination_PAN_identifier = mac_PIB.macPANId;

	mac_association_response->destination_address0 = DeviceAddress[0];
	mac_association_response->destination_address1 = DeviceAddress[1];
	
	mac_association_response->source_PAN_identifier = mac_PIB.macPANId;
	
	mac_association_response->source_address0 = aExtendedAddress0;
	mac_association_response->source_address1 = aExtendedAddress1;

	mac_association_response->command_frame_identifier = CMD_ASSOCIATION_RESPONSE;
	
	mac_association_response->short_address = shortaddress;

	mac_association_response->association_status = status;


	printfUART("ASS RESP S: %i\n",shortaddress); 
	

	add_ind_queue(LONG_ADDRESS,DeviceAddress,(uint8_t*)mac_txmpdu_ptr);
	
	}
	
	return;

}