cc1000.c

adhoc信息节点程序源代码（点对多点）——for atmega128

/*
****************************************************************************                        
*                        
*              宁波中科集成电路设计中心  版权所有 Copyright 2005
*
*文件名：  cc1000.h
*程序员：
*主要内容：cc1000通信相关
*完成日期：2005.3.25
****************************************************************************
*/

#include "cc1000.h"
#include "fun.h"
#include "os.h"



static const prog_uchar CC1K_LPL_PreambleLength[7 * 2] = { 
0, 28, 0, 94, 0, 250, 0x01, 0x73, 0x01, 0xEA, 0x04, 0xBC, 0x0A, 0x5E };

static const prog_uchar CC1K_LPL_ValidPrecursor[7] = { 5, 2, 2, 2, 2, 2, 2 };

static const prog_uchar CC1K_LPL_SleepTime[7 * 2] = { 
0, 0, 0, 20, 0, 85, 0, 135, 0, 185, 0x01, 0xE5, 0x04, 0x3D };

static const prog_uchar CC1K_LPL_SleepPreamble[7] = { 0, 8, 8, 8, 8, 8, 8 };

static const prog_uchar CC1K_LPL_SquelchInit[7] = { 
0xAE, 0xEF, 0xEF, 0xEF, 0xEF, 0xEF, 0xEF };


uint32_t CC1000ControlM_gCurrentChannel;
uint8_t  CC1000ControlM_gCurrentParameters[31];

enum {
  CC1000ControlM_IF = 150000, 
  CC1000ControlM_FREQ_MIN = 4194304, 
  CC1000ControlM_FREQ_MAX = 16751615
};

const uint32_t CC1000ControlM_FRefTbl[9] = { 2457600, 
2106514, 
1843200, 
1638400, 
1474560, 
1340509, 
1228800, 
1134277, 
1053257 };

const uint16_t CC1000ControlM_CorTbl[9] = { 1213, 
1416, 
1618, 
1820, 
2022, 
2224, 
2427, 
2629, 
2831 };

const uint16_t CC1000ControlM_FSepTbl[9] = { 0x1AA, 
0x1F1, 
0x238, 
0x280, 
0x2C7, 
0x30E, 
0x355, 
0x39C, 
0x3E3 };


bool CC1000ControlGetLOStatus(void)							// 得到CC1000的LO状态
{
	return CC1000ControlM_gCurrentParameters[0x1e];
}

result_t CC1000ControlSelectLock(uint8_t Value)				// 设置CC1000的PLL
{
	CC1000ControlM_gCurrentParameters[0xd] = Value << 4;
	return CC1000HPLWrite(0x0D, Value << 4);
}

result_t CC1000ControlChipconCal(void)
{
	CC1000HPLWrite(0x0B, 0x00);
	CC1000HPLWrite(0x42, 0x3f);
	
	CC1000HPLWrite(0x00, (
		1 << 4) | (1 << 0));
	
	CC1000HPLWrite(0x0E, ((
		1 << 7) | (
		1 << 5)) | (6 << 0));
	
	while ((CC1000HPLRead(0x0E) & (1 << 3)) == 0) ;
	
	CC1000HPLWrite(0x0E, (
		1 << 5) | (6 << 0));
	
	CC1000HPLWrite(0x00, (((
		1 << 7) | (1 << 6)) | (1 << 5)) | (
		1 << 0));
	
	CC1000HPLWrite(0x09, CC1000ControlM_gCurrentParameters[29]);
	CC1000HPLWrite(0x0B, 0x00);
	
	CC1000HPLWrite(0x0E, ((
		1 << 7) | (
		1 << 5)) | (6 << 0));
	
	while ((CC1000HPLRead(0x0E) & (1 << 3)) == 0) ;
	
	CC1000HPLWrite(0x0E, (
		1 << 5) | (6 << 0));
	
	return SUCCESS;
}

void CC1000ControlCC1000SetFreq(void)
{
	uint8_t i;
	
	for (i = 1; i < 0x0d; i++) {
		CC1000HPLWrite(i, CC1000ControlM_gCurrentParameters[i]);
    }
	
	
	CC1000HPLWrite(0x12, CC1000ControlM_gCurrentParameters[0x12]);
	
	CC1000ControlChipconCal();
	
	return;
}

uint32_t CC1000ControlComputeFreq(uint32_t desiredFreq)
{
  uint32_t ActualChannel = 0;
  uint32_t RXFreq = 0;
  uint32_t TXFreq = 0;
  int32_t Offset = 0x7fffffff;
  uint16_t FSep = 0;
  uint8_t RefDiv = 0;
  uint8_t i;

  for (i = 0; i < 9; i++) {

      uint32_t NRef = desiredFreq + CC1000ControlM_IF;
      uint32_t FRef = CC1000ControlM_FRefTbl[i];
      uint32_t Channel = 0;
      uint32_t RXCalc = 0;
      uint32_t TXCalc = 0;
      int32_t diff;

      NRef = ((desiredFreq + CC1000ControlM_IF) << 2) / FRef;
      if (NRef & 0x1) {
          NRef++;
        }

      if (NRef & 0x2) {
          RXCalc = 16384 >> 1;
          Channel = FRef >> 1;
        }

      NRef >>= 2;

      RXCalc += NRef * 16384 - 8192;
      if (RXCalc < CC1000ControlM_FREQ_MIN || RXCalc > CC1000ControlM_FREQ_MAX) {
        continue;
        }
      TXCalc = RXCalc - CC1000ControlM_CorTbl[i];
      if (TXCalc < CC1000ControlM_FREQ_MIN || TXCalc > CC1000ControlM_FREQ_MAX) {
        continue;
        }
      Channel += NRef * FRef;
      Channel -= CC1000ControlM_IF;

      diff = Channel - desiredFreq;
      if (diff < 0) {
        diff = 0 - diff;
        }
      if (diff < Offset) {
          RXFreq = RXCalc;
          TXFreq = TXCalc;
          ActualChannel = Channel;
          FSep = CC1000ControlM_FSepTbl[i];
          RefDiv = i + 6;
          Offset = diff;
        }
    }

  if (RefDiv != 0) {

      CC1000ControlM_gCurrentParameters[0x3] = (uint8_t )(RXFreq & 0xFF);
      CC1000ControlM_gCurrentParameters[0x2] = (uint8_t )((RXFreq >> 8) & 0xFF);
      CC1000ControlM_gCurrentParameters[0x1] = (uint8_t )((RXFreq >> 16) & 0xFF);

      CC1000ControlM_gCurrentParameters[0x6] = (uint8_t )(TXFreq & 0xFF);
      CC1000ControlM_gCurrentParameters[0x5] = (uint8_t )((TXFreq >> 8) & 0xFF);
      CC1000ControlM_gCurrentParameters[0x4] = (uint8_t )((TXFreq >> 16) & 0xFF);

      CC1000ControlM_gCurrentParameters[0x8] = (uint8_t )(FSep & 0xFF);
      CC1000ControlM_gCurrentParameters[0x7] = (uint8_t )((FSep >> 8) & 0xFF);

      if (ActualChannel < 500000000) {
          if (ActualChannel < 400000000) {
              CC1000ControlM_gCurrentParameters[0x9] = (8 << 4) | (1 << 2);
              CC1000ControlM_gCurrentParameters[0x1d] = (9 << 4) | (1 << 0);
            }
          else {
              CC1000ControlM_gCurrentParameters[0x9] = (4 << 4) | (1 << 2);
              CC1000ControlM_gCurrentParameters[0x1d] = (8 << 4) | (1 << 0);
            }
          CC1000ControlM_gCurrentParameters[0xa] = 1 << 1;
          CC1000ControlM_gCurrentParameters[0x12] = 7 << 4;
        }
      else {
          CC1000ControlM_gCurrentParameters[0x9] = (8 << 4) | (3 << 2);
          CC1000ControlM_gCurrentParameters[0x1d] = (15 << 4) | (3 << 0);
          CC1000ControlM_gCurrentParameters[0xa] = ((1 << 5) | (2 << 3)) | (
          1 << 1);
          CC1000ControlM_gCurrentParameters[0x12] = 2 << 4;
        }
      CC1000ControlM_gCurrentParameters[0xc] = RefDiv << 3;
    }
  CC1000ControlM_gCurrentChannel = ActualChannel;
  return ActualChannel;
}

uint32_t CC1000ControlTuneManual(uint32_t DesiredFreq)
{
	uint32_t actualFreq;
	
	actualFreq = CC1000ControlComputeFreq(DesiredFreq);
	
	CC1000ControlCC1000SetFreq();
	
	return actualFreq;
}

void CC1000ControlCC1000SetModem(void)
{
	CC1000HPLWrite(0x0F, CC1000ControlM_gCurrentParameters[0x0f]);
	CC1000HPLWrite(0x10, CC1000ControlM_gCurrentParameters[0x10]);
	CC1000HPLWrite(0x11, CC1000ControlM_gCurrentParameters[0x11]);
	return;
}

result_t CC1000HPLInit(void)
{
	OSH_MAKE_CC_CHP_OUT_INPUT();
	OSH_MAKE_CC_PALE_OUTPUT();
	OSH_MAKE_CC_PCLK_OUTPUT();
	OSH_MAKE_CC_PDATA_OUTPUT();
	OSH_SET_CC_PALE_PIN();
	OSH_SET_CC_PDATA_PIN();
	OSH_SET_CC_PCLK_PIN();
	return SUCCESS;
}

result_t CC1000ControlStdControlInit(void)
{
	CC1000HPLInit();
	CC1000HPLWrite(0x00, (((
		1 << 5) | (1 << 4)) | (
		1 << 3)) | (1 << 1));
	CC1000HPLWrite(0x00, ((((
		1 << 5) | (1 << 4)) | (
		1 << 3)) | (1 << 1)) | (
		1 << 0));
	OSH_uwait(2000);
	
	//  CC1000ControlM_gCurrentParameters[0xb] = (8 << 4) | (0 << 0);
	CC1000ControlM_gCurrentParameters[0xb] = 0xF0;
	CC1000HPLWrite(0x0B, CC1000ControlM_gCurrentParameters[0xb]);
	
	CC1000ControlM_gCurrentParameters[0xd] = 9 << 4;
	CC1000HPLWrite(4, CC1000ControlM_gCurrentParameters[0xd]);
	
	CC1000ControlM_gCurrentParameters[0xf] = 0;
	
	CC1000ControlM_gCurrentParameters[0x10] = (((3 << 5) | (1 << 3)) | (
		3 << 1)) | (1 << 0);
	
	CC1000ControlM_gCurrentParameters[0x11] = ((5 << 4) | (1 << 2)) | (
		1 << 0);
	
	CC1000ControlCC1000SetModem();
	
	CC1000ControlM_gCurrentParameters[0x13] = 1 << 0;
	CC1000HPLWrite(0x13, CC1000ControlM_gCurrentParameters[0x13]);
	
	CC1000ControlM_gCurrentParameters[0x1e] = TRUE;
	
	CC1000ControlTuneManual(433300000);//914998000
	
	return SUCCESS;
}


result_t CC1000ControlBIASOn(void)
{
	CC1000HPLWrite(0x00, (((
		1 << 5) | (1 << 4)) | (
		1 << 3)) | (
		1 << 0));
	
	OSH_uwait(200);
	return SUCCESS;
}

result_t CC1000ControlStdControlStart(void)
{
	
	CC1000HPLWrite(0x00, ((((
		1 << 5) | (1 << 4)) | (
		1 << 3)) | (1 << 1)) | (
		1 << 0));
	
	OSH_uwait(2000);
	return SUCCESS;
}

result_t CC1000ControlTxMode(void)
{
	CC1000HPLWrite(0x00, (((
		1 << 7) | (1 << 6)) | (1 << 5)) | (
		1 << 0));
	
	CC1000HPLWrite(0x09, CC1000ControlM_gCurrentParameters[29]);
	OSH_uwait(250);
	CC1000HPLWrite(0x0B, CC1000ControlM_gCurrentParameters[0xb]);
	OSH_uwait(20);
	return SUCCESS;
}

result_t CC1000ControlRxMode(void)
{
	CC1000HPLWrite(0x00, (
		1 << 4) | (1 << 0));
	
	CC1000HPLWrite(0x09, CC1000ControlM_gCurrentParameters[0x09]);
	CC1000HPLWrite(0x0B, 0x00);
	OSH_uwait(250);
	return SUCCESS;
}

result_t CC1000ControlStdControlStop(void)
{
	CC1000HPLWrite(0x0B, 0x00);
	CC1000HPLWrite(0x00, (((((
		1 << 5) | (1 << 4)) | (
		1 << 3)) | (1 << 2)) | (1 << 1)) | (
		1 << 0));
	
	return SUCCESS;
}

result_t CC1000HPLWrite(uint8_t addr, uint8_t data)
{
	char cnt = 0;
	
	addr <<= 1;
	OSH_CLR_CC_PALE_PIN();
	for (cnt = 0; cnt < 7; cnt++) 
    {
		if (addr & 0x80) {
			OSH_SET_CC_PDATA_PIN();
        }
		else {
			OSH_CLR_CC_PDATA_PIN();
        }
		OSH_CLR_CC_PCLK_PIN();
		OSH_SET_CC_PCLK_PIN();
		addr <<= 1;
    }
	OSH_SET_CC_PDATA_PIN();
	OSH_CLR_CC_PCLK_PIN();
	OSH_SET_CC_PCLK_PIN();
	
	OSH_SET_CC_PALE_PIN();
	
	for (cnt = 0; cnt < 8; cnt++) 
    {
		if (data & 0x80) {
			OSH_SET_CC_PDATA_PIN();
        }
		else {
			OSH_CLR_CC_PDATA_PIN();
        }
		OSH_CLR_CC_PCLK_PIN();
		OSH_SET_CC_PCLK_PIN();
		data <<= 1;
    }
	OSH_SET_CC_PALE_PIN();
	OSH_SET_CC_PDATA_PIN();
	OSH_SET_CC_PCLK_PIN();
	return SUCCESS;
}

uint8_t CC1000HPLRead(uint8_t addr)
{
	int cnt;
	uint8_t din;
	uint8_t data = 0;
	
	addr <<= 1;
	OSH_CLR_CC_PALE_PIN();
	for (cnt = 0; cnt < 7; cnt++) 
    {
		if (addr & 0x80) {
			OSH_SET_CC_PDATA_PIN();
        }
		else {
			OSH_CLR_CC_PDATA_PIN();
        }
		OSH_CLR_CC_PCLK_PIN();
		OSH_SET_CC_PCLK_PIN();
		addr <<= 1;
    }
	OSH_CLR_CC_PDATA_PIN();
	OSH_CLR_CC_PCLK_PIN();
	OSH_SET_CC_PCLK_PIN();
	
	OSH_MAKE_CC_PDATA_INPUT();
	OSH_SET_CC_PALE_PIN();
	
	
	for (cnt = 7; cnt >= 0; cnt--) 
    {
		OSH_CLR_CC_PCLK_PIN();
		din = OSH_READ_CC_PDATA_PIN();
		if (din) {
			data = (data << 1) | 0x01;
        }
		else {
			data = (data << 1) & 0xfe;
        }
		OSH_SET_CC_PCLK_PIN();
    }
	
	OSH_SET_CC_PALE_PIN();
	OSH_MAKE_CC_PDATA_OUTPUT();
	OSH_SET_CC_PDATA_PIN();
	
	return data;
}