leddim.c

用keil C 写的读写CS5460及校准的程式

    }
    ZW_RF_POWERLEVEL_SET(currentPower);  /* Back to previous setting */
    SendTestReport();
  }
}


/*=======================   PowerLevelTimerCancel   ==========================
**    Cancels PowerLevel timer
**
**    This is an application function example
**
**--------------------------------------------------------------------------*/
void
PowerLevelTimerCancel( void )
{
  ZW_TIMER_CANCEL(timerPowerLevelHandle);
  timerPowerLevelHandle = 0;
}


/*===============================   StartTest   ==============================
**    Timer callback which maked sure that the RF transmit powerlevel is set
**    back to normalPower after the designated time period.
**
**    This is an application function example
**
**--------------------------------------------------------------------------*/
void
PowerLevelTimeout( void )
{
  if (!--timerPowerLevelSec)
  {
    ZW_RF_POWERLEVEL_SET(normalPower);  /* Reset powerlevel to normalPower */
    PowerLevelTimerCancel();
  }
}


/*===============================   StartTest   ==============================
**    Start the powerlevel test run
**
**    This is an application function example
**
**--------------------------------------------------------------------------*/
void
StartTest(void)
{
  testState = ZW_TEST_INPROGRESS;
  currentPower = ZW_RF_POWERLEVEL_GET();  /* Get current (normalPower) */
  ZW_RF_POWERLEVEL_SET(testPowerLevel);
  ZW_SEND_TEST_FRAME(testNodeID, testPowerLevel, SendTestDone);
}
#endif


#ifdef METADATA_DUT
void
SendMetaTestReportComplete(
  BYTE bStatus)
{
  if (metadocount && !metarecount)
  {
    metarecount = TRUE;
    timestamp = tickTime;
  }
}


void
SendMetaTestReport(
  BYTE sourceNode)
{
  txBuf.ZW_ManufacturerProprietary2ByteFrame.cmdClass = COMMAND_CLASS_MANUFACTURER_PROPRIETARY;
  txBuf.ZW_ManufacturerProprietary2ByteFrame.manufacturerId1 = 0x00;
  txBuf.ZW_ManufacturerProprietary2ByteFrame.manufacturerId2 = 0x00;
  txBuf.ZW_ManufacturerProprietary2ByteFrame.value1 = 0x03;
  txBuf.ZW_ManufacturerProprietary2ByteFrame.value2 = 0x81;
  *((&txBuf.ZW_ManufacturerProprietary2ByteFrame.value2) + 1) = (BYTE)*((BYTE*)&timespan);
  *((&txBuf.ZW_ManufacturerProprietary2ByteFrame.value2) + 2) = (BYTE)*(&timespan);
  *((&txBuf.ZW_ManufacturerProprietary2ByteFrame.value2) + 3) = (BYTE)*((BYTE*)&metaframecount);
  *((&txBuf.ZW_ManufacturerProprietary2ByteFrame.value2) + 4) = (BYTE)*(&metaframecount);
  if (metarecount)
  {
    *((&txBuf.ZW_ManufacturerProprietary2ByteFrame.value2) + 5) = (BYTE)*((BYTE*)&metaframerecount);
    *((&txBuf.ZW_ManufacturerProprietary2ByteFrame.value2) + 6) = (BYTE)*(&metaframerecount);
  }
  ZW_SEND_DATA(sourceNode, (BYTE *)&txBuf, sizeof(txBuf.ZW_ManufacturerProprietary2ByteFrame)+((metarecount) ? 6 : 4), txOption, SendMetaTestReportComplete);
#if 0
  txBuf.ZW_MetaDataReportFrame.cmdClass = COMMAND_CLASS_META_DATA;
  txBuf.ZW_MetaDataReportFrame.cmd      = META_DATA_REPORT;
  /* We use the MetaData report to report our findings */
  txBuf.ZW_MetaDataReportFrame.lastAndReportNo1 = (BYTE)*((BYTE*)&timespan);
  txBuf.ZW_MetaDataReportFrame.reportNo2 = (BYTE)*(&timespan);
  txBuf.ZW_MetaDataReportFrame.data1 = (BYTE)*((BYTE*)&metaframecount);
  *((&txBuf.ZW_MetaDataReportFrame.data1) + 1) = (BYTE)*(&metaframecount);
  if (metarecount)
  {
    *((&txBuf.ZW_MetaDataReportFrame.data1) + 2) = (BYTE)*((BYTE*)&metaframerecount);
    *((&txBuf.ZW_MetaDataReportFrame.data1) + 3) = (BYTE)*(&metaframerecount);
  }
  ZW_SEND_DATA(sourceNode, (BYTE *)&txBuf, sizeof(txBuf.ZW_MetaDataReportFrame)+((metarecount) ? 3 : 1), txOption, SendMetaTestReportComplete);
#endif
}
#endif


/*========================   ApplicationCommandHandler   ====================
**    Handling of a received application commands and requests
**
**    This is an application function example
**
**--------------------------------------------------------------------------*/
void                              /*RET Nothing                  */
ApplicationCommandHandler(
  BYTE  rxStatus,                 /* IN Frame header info */
  BYTE  sourceNode,               /* IN Command sender Node ID */
  ZW_APPLICATION_TX_BUFFER *pCmd, /* IN Payload from the received frame, the union */
                                  /*    should be used to access the fields */
  BYTE   cmdLength)               /* IN Number of command bytes including the command */
{
  BYTE classcmd = pCmd->ZW_Common.cmdClass;
  BYTE cmd = pCmd->ZW_Common.cmd;
  BYTE param1 = *((BYTE*)pCmd + OFFSET_PARAM_1);
  BYTE param2 = *((BYTE*)pCmd + OFFSET_PARAM_2);
#if defined(ZW020x) || defined(ZW030x)
  BYTE param3 = *((BYTE*)pCmd + OFFSET_PARAM_3);
  BYTE param4 = *((BYTE*)pCmd + OFFSET_PARAM_4);
#endif
  BYTE status = dimmerNodeStatus.status;
#ifdef METADATA_DUT
  BYTE frametype = rxStatus & RECEIVE_STATUS_TYPE_MASK;
#endif
 	txOption = ((rxStatus & RECEIVE_STATUS_LOW_POWER) ?
 	            TRANSMIT_OPTION_LOW_POWER : 0) | TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_EXPLORE;

  if ((classcmd == COMMAND_CLASS_SWITCH_MULTILEVEL) ||
      (classcmd == COMMAND_CLASS_BASIC))
  {
    /* Single switch command */
    switch(cmd)
    {
      /* Start dimming */
      case SWITCH_MULTILEVEL_START_LEVEL_CHANGE:
        DIMStart(param2, (param1 & (M_DS_UP_DOWN | M_DS_ROLLOVER)));
        break;

      /* Stop dimming */
      case SWITCH_MULTILEVEL_STOP_LEVEL_CHANGE:
        DIMStop(TRUE);
        break;

      /* Controller wants the level */
      case SWITCH_MULTILEVEL_GET:
        {
          BYTE level = (status & M_DS_ON_OFF) ? dimmerNodeStatus.level : SWITCHED_OFF;
          SendReport(sourceNode, classcmd, level);
        }
        break;

      /* Jump to the specified level param1 */
      case SWITCH_MULTILEVEL_SET:
        if (param1 == SWITCHED_ON)
        {
          SetLightLevel(CURRENT_LEVEL, LEVEL_DONTCARE);
        }
        else if (param1<100) /* Check for valid level */
        {
          SetLightLevel(LEVEL, param1);
        }
        break;
    } /* switch */
  } /* if */
  else if (classcmd == COMMAND_CLASS_SWITCH_ALL)
  {
    switch(cmd)
    {
      case SWITCH_ALL_ON:
        if ((ignoreAllOnOff != SWITCH_ALL_EXCLUDE_ON_OFF) && (ignoreAllOnOff != SWITCH_ALL_EXCLUDE_ONLY_ON))
        {
          SetLightLevel(ON, LEVEL_DONTCARE);
        }
        break;

      case SWITCH_ALL_OFF:
#ifdef METADATA_DUT
        if (frametype == RECEIVE_STATUS_TYPE_BROAD)
        {
          /* We received the broadcasted "ALL OFF" - start counting and sampling */
          timestamp = tickTime;
          metarecount = FALSE;  /* This is the initial metadata frame count */
          metadocount = TRUE; /* Now we count the received metadata frames */
          metaframecount = 0; /* Initially no frames received */
          metaframerecount = 0; /* Initially no frames received */
        }
        else if (metadocount && !metarecount && (frametype == RECEIVE_STATUS_TYPE_SINGLE))
        {
          timespan = tickTime - timestamp;
          metaDataReportNode = sourceNode;
#if 1
          SendMetaTestReportComplete(TRUE);
#else
          SendMetaTestReport(sourceNode);
#endif
        }
#endif
        if ((ignoreAllOnOff != SWITCH_ALL_EXCLUDE_ON_OFF) && (ignoreAllOnOff != SWITCH_ALL_EXCLUDE_ONLY_OFF))
        {
          SetLightLevel(OFF, LEVEL_DONTCARE);
        }
        break;

      case SWITCH_ALL_SET:
        ignoreAllOnOff = param1;
        /* Store it in the EEPROM */
        ZW_MEM_PUT_BYTE(EEOFFSET_IGNORE_ALL_ON_OFF, ignoreAllOnOff);
        break;

      case SWITCH_ALL_GET:
        SendReport(sourceNode, COMMAND_CLASS_SWITCH_ALL, ignoreAllOnOff);
        break;

        default:
        break;

    } /* switch */
  } /* else if == COMMAND_CLASS_SWITCH_ALL */

//
// commandClass= COMMAND_CLASS_METER
//command= METER_REPORT
//7 bit->Reserved 6,5 bit-> Rate TYpe 00,4,3,2,1 Bit->Meter Type =0x01
//7 6 5 bit ->Precision=3, 4 3 Bit->Scale=0x00,2,1,0 Size = 4 .
// new Value 4 bytes
// Last Value 4 Byes.
//

//else if (classcmd ==COMMAND_CLASS_METER_PULSE)

else if ((classcmd ==COMMAND_CLASS_METER)||(classcmd ==COMMAND_CLASS_METER_PULSE)||(classcmd ==COMMAND_CLASS_BATTERY))
{
	LED_ON(2);

	if((cmd== METER_GET )||(cmd== METER_PULSE_GET)||(cmd==BATTERY_GET))
	{
		User_RF_Send_ZW_Data(G_KWH_Power);
	}
	LED_OFF(2);
}
 else if(classcmd==COMMAND_CLASS_CONFIGURATION)
{
	if(cmd== CONFIGURATION_SET )
	{
		LED_ON(2);
		if(pCmd->ZW_ConfigurationSet4byteFrame.parameterNumber==1)
		G_KWH_Power=0;
		G_SUM_KWH_Power=0;
		LED_OFF(2);
	}
}
 
#if defined(ZW020x) || defined(ZW030x)
  else if (classcmd == COMMAND_CLASS_POWERLEVEL)
  {
    switch (cmd)
    {
      case POWERLEVEL_SET:
        if (param2 || (param1 == normalPower))  /* Only if timeout defined or powerlevel is normalPower */
        {
          param1 = ZW_RF_POWERLEVEL_SET(param1);  /* Set powerlevel according to command */
          if (timerPowerLevelHandle)
          {
            PowerLevelTimerCancel();
            timerPowerLevelSec = 0;
          }
          if (param1 != normalPower)  /* If normalPower then no timer is started */
          {
            timerPowerLevelSec = param2;
            timerPowerLevelHandle = ZW_TIMER_START(PowerLevelTimeout, TIMER_ONE_SECOND, FOREVER);
          }
        }
        break;

      case POWERLEVEL_GET:
        txBuf.ZW_PowerlevelReportFrame.cmdClass = COMMAND_CLASS_POWERLEVEL;
        txBuf.ZW_PowerlevelReportFrame.cmd = POWERLEVEL_REPORT;
        txBuf.ZW_PowerlevelReportFrame.powerLevel = ZW_RF_POWERLEVEL_GET();
        txBuf.ZW_PowerlevelReportFrame.timeout = timerPowerLevelSec;
        ZW_SEND_DATA(sourceNode, (BYTE *)&txBuf, sizeof(txBuf.ZW_PowerlevelReportFrame), txOption, NULL);
        break;

      case POWERLEVEL_TEST_NODE_SET:
        if (testState != ZW_TEST_INPROGRESS)
        {
          testSourceNodeID = sourceNode;
          testNodeID = param1;
          testPowerLevel = param2;
          testFrameCount = (WORD)((WORD)param3 << 8) + param4;
          testFrameSuccessCount = 0;
          if (testFrameCount)
          {
            StartTest();
          }
          else
          {
            testState = ZW_TEST_FAILED;
            SendTestReport();
          }
        }
        break;

      case POWERLEVEL_TEST_NODE_GET:
        SendTestReport();
        break;
        default:
        break;

    } /* switch */
  } /* else if == COMMAND_CLASS_POWERLEVEL */
  else if (classcmd == COMMAND_CLASS_MANUFACTURER_SPECIFIC)
  {
    switch (cmd)
    {
      case MANUFACTURER_SPECIFIC_GET:
        txBuf.ZW_ManufacturerSpecificReportFrame.cmdClass = COMMAND_CLASS_MANUFACTURER_SPECIFIC;
        txBuf.ZW_ManufacturerSpecificReportFrame.cmd = MANUFACTURER_SPECIFIC_REPORT;
        txBuf.ZW_ManufacturerSpecificReportFrame.manufacturerId1 = 0x00; // Zensys manufacturer ID
        txBuf.ZW_ManufacturerSpecificReportFrame.manufacturerId2 = 0x00;
        txBuf.ZW_ManufacturerSpecificReportFrame.productTypeId1 = 0x00; // Assigned by manufacturer
        txBuf.ZW_ManufacturerSpecificReportFrame.productTypeId2 = 0x00;
        txBuf.ZW_ManufacturerSpecificReportFrame.productId1 = 0x00; // Assigned by manufacturer
        txBuf.ZW_ManufacturerSpecificReportFrame.productId2 = 0x00;
        ZW_SEND_DATA(sourceNode, (BYTE *)&txBuf, sizeof(txBuf.ZW_ManufacturerSpecificReportFrame), txOption, NULL);
        break;
    }
  }
  else if (classcmd == COMMAND_CLASS_VERSION)
  {
    switch (cmd)
    {
      case VERSION_GET:
        txBuf.ZW_VersionReportFrame.cmdClass = COMMAND_CLASS_VERSION;
        txBuf.ZW_VersionReportFrame.cmd = VERSION_REPORT;
        txBuf.ZW_VersionReportFrame.zWaveLibraryType = ZW_TYPE_LIBRARY();
        txBuf.ZW_VersionReportFrame.zWaveProtocolVersion = ZW_VERSION_MAJOR;
        txBuf.ZW_VersionReportFrame.zWaveProtocolSubVersion = ZW_VERSION_MINOR;
        txBuf.ZW_VersionReportFrame.applicationVersion = LED_DIM_VERSION;
        txBuf.ZW_VersionReportFrame.applicationSubVersion = LED_DIM_REVISION;
        ZW_SEND_DATA(sourceNode, (BYTE *)&txBuf, sizeof(txBuf.ZW_VersionReportFrame), txOption, NULL);
        break;

      case VERSION_COMMAND_CLASS_GET:
        txBuf.ZW_VersionCommandClassReportFrame.cmdClass = COMMAND_CLASS_VERSION;
        txBuf.ZW_VersionCommandClassReportFrame.cmd = VERSION_COMMAND_CLASS_REPORT;
        txBuf.ZW_VersionCommandClassReportFrame.requestedCommandClass = param1;
        switch (param1)
        {
          case COMMAND_CLASS_BASIC:
            txBuf.ZW_VersionCommandClassReportFrame.commandClassVersion = BASIC_VERSION;
            break;

          case COMMAND_CLASS_SWITCH_MULTILEVEL:
            txBuf.ZW_VersionCommandClassReportFrame.commandClassVersion = SWITCH_MULTILEVEL_VERSION;
            break;

          case COMMAND_CLASS_SWITCH_ALL:
            txBuf.ZW_VersionCommandClassReportFrame.commandClassVersion = SWITCH_ALL_VERSION;
            break;

          case COMMAND_CLASS_MANUFACTURER_SPECIFIC:
            txBuf.ZW_VersionCommandClassReportFrame.commandClassVersion = MANUFACTURER_SPECIFIC_VERSION;
            break;

          case COMMAND_CLASS_VERSION:
            txBuf.ZW_VersionCommandClassReportFrame.commandClassVersion = VERSION_VERSION;
            break;

          case COMMAND_CLASS_PROTECTION:
            txBuf.ZW_VersionCommandClassReportFrame.commandClassVersion = PROTECTION_VERSION;
            break;

          case COMMAND_CLASS_POWERLEVEL:
            txBuf.ZW_VersionCommandClassReportFrame.commandClassVersion = POWERLEVEL_VERSION;
            break;

          default:
            txBuf.ZW_VersionCommandClassReportFrame.commandClassVersion = UNKNOWN_VERSION;
            break;
        }
        ZW_SEND_DATA(sourceNode, (BYTE *)&txBuf, sizeof(txBuf.ZW_VersionCommandClassReportFrame), txOption, NULL);
        break;
    }
  }
#ifdef METADATA_DUT
  else if (classcmd == COMMAND_CLASS_MANUFACTURER_PROPRIETARY)
  {
    cmd = pCmd->ZW_ManufacturerProprietary2ByteFrame.value1;