AVRFreaks.net

void APL_TaskHandler(void)
{
  switch (appState)
  {
    // Node has initial state
    case APP_INITING_STATE:
      simpleDescriptor.AppDeviceId = CPU_TO_LE16(1);
      simpleDescriptor.AppProfileId = CPU_TO_LE16(1);
      simpleDescriptor.endpoint = END_POINT;
      simpleDescriptor.AppDeviceVersion = 1;

      BSP_OpenLeds();
      endpointParams.simpleDescriptor = &simpleDescriptor;

        // All other states mean Router
        appDeviceType = DEVICE_TYPE_ROUTER;
        endpointParams.APS_DataInd = NULL;

      CS_WriteParameter(CS_DEVICE_TYPE_ID, &appDeviceType);
      appInitUARTManager();  // Init UART manager

      // Configure and start network starting timer
      startingNetworkTimer.interval = APP_TIMER_STARTING_NETWORK;
      startingNetworkTimer.mode     = TIMER_REPEAT_MODE;
      startingNetworkTimer.callback = startingNetworkTimerFired;
      HAL_StartAppTimer(&startingNetworkTimer);

      appState = APP_NETWORK_STARTING_STATE; // Switch state
      SYS_PostTask(APL_TASK_ID);
      break;

    case APP_NETWORK_STARTING_STATE:
      {
        // Configure network start parameters
        networkParams.ZDO_StartNetworkConf = ZDO_StartNetworkConf;

        // Start network
        ZDO_StartNetworkReq(&networkParams);
        break;
      }

    // Node is in network
    case APP_IN_NETWORK_STATE:

      appRouterTaskHandler();
      break;

    // Node is out of network
    case APP_NO_NETWORK_STATE:
      break;

    default:
      break;
  }
}

#ifndef _CONFIGURATION_H_
#define _CONFIGURATION_H_

//-----------------------------------------------
// Disables board-specific peripherals support
//-----------------------------------------------
//#define APP_DISABLE_BSP 1
#define APP_DISABLE_BSP 0

//-----------------------------------------------
// Includes board-specific peripherals support in application.
//-----------------------------------------------
#include <BoardConfig.h>

//-----------------------------------------------
// Atmel communication interfaces identifiers.
// Supported interfaces are platform and application dependent.
//-----------------------------------------------
#define APP_INTERFACE_USART 0x01
#define APP_INTERFACE_VCP 0x02
#define APP_INTERFACE_SPI 0x03
#define APP_INTERFACE_UART 0x04
#define APP_INTERFACE_USBFIFO 0x05

//-----------------------------------------------
// Atmel external memory identifiers.
// Supported memory is platform and application dependent.
//-----------------------------------------------
#define AT25F2048  0x01
#define AT45DB041  0x02
#define AT25DF041A 0x03

// Enables or disables request of APS Acknowledgement for outgoing frames.
#define APP_USE_APS_ACK 0
//#define APP_USE_APS_ACK 1

// Device type detection (for the boards without DIP switches)
//#define APP_DEVICE_TYPE DEV_TYPE_COORDINATOR
//Device is Router
#define APP_DEVICE_TYPE DEV_TYPE_ROUTER

// Period of sending throughput value to USART (ms)
#define APP_TIMER_TRACK_PERIOD 1000

// Packet transmission start delay (ms)
#define APP_TIMER_DELAY_PERIOD 1000

//-----------------------------------------------
//BOARD_MESHBEAN
//-----------------------------------------------
#ifdef BOARD_MESHBEAN
  // Enable this option if target board belongs to MNZB-EVBx family
  #define BSP_MNZB_EVB_SUPPORT 0
  //#define BSP_MNZB_EVB_SUPPORT 1
 
  // Defines primary serial interface type to be used by application.
  #define APP_INTERFACE APP_INTERFACE_USART
 
  // Defines USART interface name to be used by application.
  #define APP_USART_CHANNEL USART_CHANNEL_1
#endif

  // 32-bit mask of channels to be scanned before network is started. Channels that
  // should be used are marked with logical 1 at corresponding bit location.
  //  Valid channel numbers for 2.4 GHz band are 0x0b - 0x1a
  //  Valid channel numbers for 900 MHz band are 0x00 - 0x0a
  //
  //  Notes:
  //  1. for small amount of enabled channels it is more convinient to specify list
  // of channels in the form of '(1ul << 0x0b)'
  //  2. For 900 MHz band you also need to specify channel page
  //
  //  Value range: 32-bit values:
  //  Valid channel numbers for 2.4 GHz band are 0x0b - 0x1a
  //  Valid channel numbers for 900 MHz band are 0x00 - 0x0a
  //
  //  C-type: uint32_t
  //  Can be set: at any time before network start
  //  Persistent: Yes
  #define CS_CHANNEL_MASK (1L<<0x0f)

// The parameter specifies the predefined extended PANID of the network to be
// formed (for the coordinator) or joined (for a router or an end device). For a
// router or an end device the parameter can equal 0 allowing them to join the
// first suitable network that they discover.
//
//  Value range: All 64-bit values except for 0xFFFFFFFFFFFFFFFFLL; specify a value
// in the 0x123456789ABCDEFLL format.
//  C-type: ExtPanId_t (equal to uint64_t)
//  Can be set: at any time before network start
//  Persistent: Yes
#define CS_EXT_PANID 0xAAAAAAAAAAAAAAAALL

// 64-bit Unique Identifier (UID) determining the device extended address. If this
// value is 0 stack will try to read hardware UID from external UID or EEPROM chip.
// at startup. Location of hardware UID is platform dependend and it may not be
// available on all platforms. If the latter case then UID value must be provided
// by user via this parameter. This parameter must be unique for each device in a
// network.
//
//  Value range: any 64-bit value except for broadcast extended addresses
//  C-type: ExtAddr_t
//  Can be set: at any time before network start
//  Persistent: Yes
#define CS_UID 0x0123456789012377LL

// The maximum number of direct children that a given device (the coordinator or a
// router) can have.
//
//  The parameter is only enabled for routers and the coordinator. An end device
// can not have children. If an actual number of children reaches a parameter's
// value, the node will have not been able to accept any more children joining the
// network. The parameter can be set to 0 on a router thus preventing it from
// accepting any children and can help form a desired network topology. For
// example, if the parameter is set to 0 on all routers, then the coordinator will
// be the only device that can have children and the network will have star
// topology.
//
//  Value range: from 0 to CS_NEIB_TABLE_SIZE
//  C-type: uint8_t
//  Can be set: at compile time only
//  Persistent: No
#define CS_MAX_CHILDREN_AMOUNT 2

// The maximum number of routers among the direct children of the device
//
//  The parameter determines how many routers the device can have as children. Note
// that the maximum number of end devices is equal to CS_MAX_CHILDREN_AMOUNT -
// CS_MAX_CHILDREN_ROUTER_AMOUNT.
//
//  Value range: from 0 to CS_MAX_CHILDREN_AMOUNT
//  C-type: uint8_t
//  Can be set: at compile time only
//  Persistent: No
#define CS_MAX_CHILDREN_ROUTER_AMOUNT 2

// Network depht limits amount of hops that packet may travel in the network.
// Actual maximum number of hops is network depth multiplied by 2.
//
//  The parameter determines the maximum depth of a network tree formed by
// child-parent relationships between nodes.
//
//  While joining the network the node receives beacon responses from potential
// parents containing their actual network depth and declines those which show
// values not less than the maximum network depth on the joining device. A
// potential parent will also reject a beacon from the joining device and will not
// sent a response if the joining device shows the network depth greater than it is
// allowed on the potential parent. This logic is enabled if the parameter value is
// not greater than 15. If its value is greater than 15, then device does not
// perform any checkings of the network depth, neither when joining a network nor
// when accepting other nodes as children. This allows forming long chains of
// devices across considerable distances.
//
//  The stack also uses the parameter to calculate several timeouts. Besides, the
// parameter determines the maximum radius of a data packet, that is, the maximum
// number of hops that a packet may travel, which is calculated by the following
// formula:
//
//  maximum radius = 2 * MIN(2 * maxNetworkDepth, 255)
//
//
//  These uses of the parameter do not change if its value is greater than 15.
// Therefore to enable transmitting data over long chains of devices, the parameter
// should be set to a real desired network depth, rather than to an accidental
// value over 15.
//
//  The parameter should be the same on all devices in the network.
//
//  Value range: from 0 to 255
//  C-type: uint8_t
//  Can be set: at compile time only
//  Persistent: No
#define CS_MAX_NETWORK_DEPTH 2

PROJECT_NAME = MeshBean
CONFIG_NAME = All_ZigBit_Atmega1281_Rf230B_8Mhz_Gcc

#undef _TEMPERATURE_SENSOR_
#undef _LIGHT_SENSOR_
#undef _BATTERY_SENSOR_
#undef _SLIDERS_
#undef _BUTTONS_
#undef _LCD_
#define OMIT_READING_SENSORS

#define CS_UID 0x01LL

- after KEEP (*(.init8)) was added
*(.init9)
KEEP (*(.init9))

- deleted DISCARD section:
/DISCARD/ :
{
  *(.init9)
  *(.fini*)
}

old:
   text      data       bss       dec       hex   filename
   5276      4096      2490     11862      2e56   All_ZigBit_Atmega1281_Rf230B_8Mhz_Gcc/Exe/Blink.elf
new:
   text      data       bss       dec       hex   filename
  94750      4256      4257    103263     1935f   All_ZigBit_Atmega1281_Rf230B_8Mhz_Gcc/Exe/Blink.elf

      // Disabling the JTAG - must be executed twice within 4 clock cycles
      MCUCR |=(1<<JTD);
      MCUCR |=(1<<JTD);
      
      Uint16   tempVal;
      char   i;
      tempStr[0] = 0;
      tempResults[0] = 0;      
      
      for(i=0;i<8;i++)
      {
         mibSrv.adcConf = 1<<i;
         adcOpen(mibSrv.adcConf);
         adcStart(i);
         while (!adcGet(&tempVal));
         adcClose();
         utoa(tempVal,tempStr,10);
         strcat(tempResults,tempStr);
         if(i<3)
            strcat(tempResults,",");
         tempStr[0] = 0;
      }
      
      
      
      // Parameter write out
      pParam->subParams[0].str = tempResults;
      resCode = SN_RES_CODE_OK;

void adcOpen(Uint8 channel)
{
  adcParam.bufferPointer = &sample;
  adcParam.callback = adcCalback;
  adcParam.voltageReference = AREF;
  adcParam.resolution = RESOLUTION_10_BIT;
  adcParam.sampleRate = ADC_4800SPS;
  adcParam.selectionsAmount = 2;
  HAL_OpenAdc(&adcParam);
  adcState = IDLE;
  adcMask = channel;
}
void adcClose(void)
{
  adcMask = 0;
  HAL_CloseAdc();
}
void adcStart(Uint8 channel)
{
  volatile Uint8 i = (1 << channel);
  HAL_AdcChannelNumber_t adcChannel = HAL_ADC_CHANNEL0;
  if(0 != (adcMask & i))
  {
    adcState = BUSY;
    switch (channel)
    {
     
     case 0:
      adcChannel = HAL_ADC_CHANNEL0;
      break;
     // :ajkalos}
     case 1:
        adcChannel = HAL_ADC_CHANNEL1;
        break;
      case 2:
        adcChannel = HAL_ADC_CHANNEL2;
        break;
      case 3:
        adcChannel = HAL_ADC_CHANNEL3;
        break;
     
      case 4:
        adcChannel = HAL_ADC_CHANNEL4;
        break;
     case 5:
        adcChannel = HAL_ADC_CHANNEL5;
        break;
     case 6:
        adcChannel = HAL_ADC_CHANNEL6;
        break;
     case 7:
        adcChannel = HAL_ADC_CHANNEL7;
        break;
    
      default:
        adcChannel = -1;//HAL_ADC_CHANNEL0;
    }
    HAL_ReadAdc(adcChannel);
  }
}

if (HAL_ADC_CHANNEL7 >= channel) // instead HAL_ADC_CHANNEL3 >= channel
  {
    DIDR0 = (1 << channel);
  }

if (((channel > HAL_ADC_CHANNEL7) && (channel < HAL_ADC_DIFF_CHANNEL0)) || (channel > HAL_ADC_DIFF_CHANNEL7))  // instead channel > HAL_ADC_CHANNEL3
    return -1;