Si4705 und C8051F321 kommunizieren nicht

//-----------------------------------------------------------------------------

// F320_FM_RadioMain.c

//-----------------------------------------------------------------------------

// Copyright 2006 Silicon Laboratories, Inc.

// http://www.silabs.com

//

// Program Description:

//

// This is the main project module.  It initializes all system hardware, and 

// then enables interrupts.  All further processing is done in the various

// interrupt handlers.

//

// Linker options are used to absolutely locate code to specific locations.

//

// The linker option can be viewed from the Tool Chain Integration window

// Project -> Tool Chain Integration -> Linker (tab)

//

// FID:            32X000042

// Target:         C8051F320

// Tool chain:     KEIL C51 7.0.0.1

//                 Silicon Laboratories IDE version 2.3

// Command Line:   See Readme.txt

// Project Name:   F320_FM_Radio

//

// Release 1.1

//    -Changed Oscillator_Init to start clock multiplier correctly (DM)

//    -16 JAN 2006

//

// Release 1.0

//    -Initial Revision (DM)

//    -05 AUG 2005

//

//-----------------------------------------------------------------------------

// Includes

//-----------------------------------------------------------------------------

#include "c8051f320.h"                 // SFR declarations

#include "F320_FM_RadioMain.h"         // Main project header

#include "F320_Si470x_Interface.h"     // Si470x interface header

#include "io.h"

#define IO3W    0

#define IO2W    1

#define CTS     0x80

#define GET_REV 0x10

#define POWER_UP                      0x01

#define POWER_UP_IN_FUNC_FMRX         0x00

#define POWER_UP_IN_FUNC_AMRX         0x01

#define POWER_UP_IN_FUNC_FMTX         0x02

#define POWER_UP_IN_FUNC_WBRX         0x03

#define POWER_UP_IN_FUNC_QUERY        0x0F

#define POWER_UP_IN_PATCH             0x20

#define POWER_UP_IN_GPO2OEN           0x40

#define POWER_UP_IN_CTSIEN            0x80

#define POWER_UP_IN_OPMODE_RX_ANALOG  0x05

#define POWER_UP_IN_OPMODE_TX_ANALOG  0x50

#define GET_INT_STATUS 0x14

#define POWERUP_TIME 110

u8 io_mode = IO3W;

u8  idata cmd[8];

u8  idata rsp[15];

void si47xx_getPartInformation();

//-----------------------------------------------------------------------------

// main

//

// Return Value : None

// Parameters   : None

//

// Main program routine.

//

//-----------------------------------------------------------------------------

void main (void)

{

  int j=0;

  data WORD Temp;

  data WORD Temp2;

   PCA0MD &= ~0x40;                    // Disable Watchdog timer

   VDM0CN |= 0x80;                     // Enable the VDD Monitor

   // Configure comparator0 and crystal drive

   Crystal_Init ();

   // Initialize SPI0, should be before crossbar enable

   SPI0_Init ();                               

   Timer0_2_Init ();                   // Initialize timers

   PCA0_Init ();                       // Initialize PCA module (USB)

   Port_Init ();                       // Initialize crossbar and GPIO

   // Select VDD Monitor as a Reset Source

   RSTSRC = 0x02; 

  si47xx_getPartInformation();

   EA = 1;                             // Global Interrupt enable

   while (1);                          // Spin forever

}

//-----------------------------------------------------------------------------

// Initialization Subroutines

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

// Oscillator_Init

//-----------------------------------------------------------------------------

//

// Return Value : None

// Parameters   : None

//

// This function initializes the clock multiplier and selects it as the system

// clock.

//

//-----------------------------------------------------------------------------

void Oscillator_Init (void)

{

   // Configure internal oscillator for its maximum frequency and enable

   // missing clock detector

   OSCICN |= 0x03;

   // Select internal oscillator as input to clock multiplier

   CLKMUL = 0x00;                        

   CLKMUL |= 0x80;                     // Enable clock multiplier

   Delay_Main ();                      // Delay for clock multiplier

   CLKMUL |= 0xC0;                     // Initialize the clock multiplier

   while (!(CLKMUL & 0x20));           // Wait for multiplier to lock

   CLKSEL = SYS_4X_DIV_2;              // Select 24 MHz clock as sysclock

}

//-----------------------------------------------------------------------------

// Crystal_Init

//-----------------------------------------------------------------------------

//

// Return Value : None

// Parameters   : None

//

// This function starts the crystal drive circuit and configures the comparator

// to operate as a clock buffer for Si470x.

//

//-----------------------------------------------------------------------------

void Crystal_Init (void)

{

   // Turn on crystal drive circuit for 32.768 kHz crystal

   OSCXCN = 0x61;

   CPT0CN = 0x85;                      // Turn on comparator 0, 5 mV hysteresis

   CPT0MX = 0x00;                      // Negative = P1.1, Positive = P1.0

   CPT0MD = 0x00;                      // Response time = 100 ns

}

//-----------------------------------------------------------------------------

// SPI0_Init

//-----------------------------------------------------------------------------

//

// Return Value : None

// Parameters   : None

//

// This function configures the SPI for Si470x.

//

//-----------------------------------------------------------------------------

void SPI0_Init (void)

{

   // Clock idle high, Data centered on 2nd edge, SPI master

   SPICFG = 0x70;

   SPI0CN = 0x83;                      // Enable SPI, 3-wire mode selected

   // Configure SPI clock rate for 2.4 MHz (Maximux 2.5 MHz for Si470x)

   SPICKR = ((SYSCLK / (2400000*2)) - 1);

}

//-----------------------------------------------------------------------------

// Port_Init

//-----------------------------------------------------------------------------

//

// Return Value : None

// Parameters   : None

//

// This function configures the Crossbar and GPIO ports.

//

// P0.2  analog               XTAL1

// P0.3  analog               XTAL2

//

// P1.0  analog               COMPARATOR POSITIVE INPUT

// P1.1  analog               COMPARATOR NEGATIVE INPUT

// P1.2  digital  push-pull   Si 4701 RESET

// P1.3  digital  push-pull   SEN_BAR

// P1.4  digital  push-pull   SCLK

// P1.5  digital  open-drain  MISO

// P1.6  digital  push-pull   MOSI

// P1.7  digital  push-pull   RCLK/COMPARATOR OUTPUT

//

// P2.0  analog               RIGHT AUDIO CHANNEL

// P2.1  analog               LEFT AUDIO CHANNEL

// P2.3  digital  push-pull   GREEN LED/PCA OUTPUT

//

// P3.0  digital  push-pull   RED LED

//

//-----------------------------------------------------------------------------

void Port_Init (void)

{

   P0MDIN = 0x03;                      // Port 0 pins 2-7 analog

   P1MDIN = 0xFC;                      // Port 1 pins 0, 1 analog

   P2MDIN = 0x0C;                      // Port 2 pins 0, 1, 4-7 analog

   P3MDIN = 0x01;                      // Port 3 all digital

   P0MDOUT = 0x00;                     // Port 0 pins set open-drain

   P1MDOUT = 0xDC;                     // Port 1 pins 2-4, 6, 7 set push-pull

   P2MDOUT = 0x0C;                     // Port 2 pins 2, 3 set push-pull

   P3MDOUT = 0x01;                     // Port 3 pin 1 set push-pull

   P0SKIP = 0xFF;                      // Port 0 skip pins 0-7

   P1SKIP = 0x0F;                      // Port 1 skip pins 0-3

   P2SKIP = 0xF7;                      // Port 2 skip pins 0, 1, 2, 4-7

   P0 = 0x02;                          // Port 0 pins 1 start high

   P1 = 0xE3;                          // Port 1 pins 0, 1, 5-7 start high

   P2 = 0x03;                          // Port 2 pins 0, 1 start high

   P3 = 0x00;                          // Port 3 starts low

   XBR0 = 0x22;                        // Comparator0, SPI enabled

   // Enable Crossbar, Weak Pull-ups on, 2 PCA modules are on

   XBR1 = 0x42;

}

//-----------------------------------------------------------------------------

// Timer0_2_Init

//-----------------------------------------------------------------------------

//

// Return Value : None

// Parameters   : None

//

// Initializes timer 2 used for ADC conversion start, and timer 0 used for PCA.

//

//-----------------------------------------------------------------------------

void Timer0_2_Init (void)

{

   CKCON = 0x02;                       // Prescale bits set to system clock/48

   CKCON &= ~0x04;                     // Timer0 uses prescaler defined clock

   TMOD = 0x02;                        // Timer0 set to mode 2

   TH0 = (-(SYSCLK/48/30000));         // PCA frequency = 30 kHz

   TR0 = ON;                           // Start timer 0

   TMR2CN = 0x00;                      // Stop Timer2; Clear TF2;

   CKCON |= 0x10;                      // Timer2 clocked based on system clock

   TMR2RL = (-(SYSCLK/192000));        // Initialize reload value for 192000 Hz

   TMR2 = 0xFFFF;                      // Set to reload immediately

   ET2 = 1;                            // Enable Timer2 interrupts

   PT2 = ON;                           // Set interrupt to high priority

}

//-----------------------------------------------------------------------------

// ADC0_Init

//-----------------------------------------------------------------------------

//

// Return Value : None

// Parameters   : None

//

// Configure ADC for single ended conversions on timer 2 overflows.

//

//-----------------------------------------------------------------------------

void ADC0_Init (void)

{

   // Disable internal voltage reference VREF, use VDD instead for ADC

   REF0CN = 0x0A;

   AMX0N = 0x1F;                       // Single ended mode (negative = gnd)

   ADC0CF = 0x3C;                      // SAR clock 3 MHz, left adjusted output

   // Converion on timer 2 overflow with low power tracking mode off

   ADC0CN = 0x82;

}

//-----------------------------------------------------------------------------

// PCA_Init

//-----------------------------------------------------------------------------

//

// Return Value : None

// Parameters   : None

//

// Initializes USB0, enable transceiver and USB0 interrupts.

//

//-----------------------------------------------------------------------------

void PCA0_Init (void)

{

   PCA0CPM0 = 0x42;                    // PCA module 0 in 8-bit PWM Mode

   PCA0CPM1 = 0x42;                    // PCA module 1 in 8-bit PWM Mode

   PCA0CPM2 = 0x00;                    // PCA module 2 currently unused

   PCA0CPM3 = 0x00;                    // PCA module 3 currently unused

   PCA0CPM4 = 0x00;                    // PCA module 4 currently unused

   // PCA module 0 starts with minimum duty cycle for all pulses

   PCA0CPL0 = 0xFF;

   PCA0CPH0 = 0xFF;

   // PCA module 1 starts with minimum duty cycle for all pulses

   PCA0CPL1 = 0xFF;

   PCA0CPH1 = 0xFF;

   // PCA timer uses timer 0 overflows and runs when CPU is idle

   PCA0MD = 0x04;

   PCA0CN = 0x40;                      // PCA timer running, interrupts cleared

}

//-----------------------------------------------------------------------------

// Delay_Main

//-----------------------------------------------------------------------------

//

// Return Value : None

// Parameters   : None

//

// Used for a 500 microsecond pause during hardware configuration.

// There are two identical versions of this routine, one for the main program

// and another for the USB interrupt.  This version is for the main program.

// (assuming 24 MHz system clock)

//

//-----------------------------------------------------------------------------

void Delay_Main (void)

{

   data volatile int x;

   for (x = 0;x < 500;x)

      x++;

}

//-----------------------------------------------------------------------------

// End Of Basicfunctions

//-----------------------------------------------------------------------------

void wait_us(u16 us)

{

    u16 j;

    j = 65535u - 24 * us;

    TL0 = j;         // Load Timer 0 low byte

    TH0 = j >> 8;    // Load Timer 0 high byte

    TR0 = 1;         // Enable Timer 0

    TF0 = 0;         // Clear Timer 0 Overflow flag

    while(TF0 != 1); // Wait for Timer 0 to overflow

    TR0 = 0;         // Disable Timer 0

    TF0 = 0;         // Clear Timer 0 Overflow Flag

}

void wait_ns(u16 ns)

{

    u8 i;

    for ( i = 1; i <= ns / 32; i++ )

    ;

}

void wait_ms(u16 ms)

{

    int i;

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

        wait_us(1000);

    }

}

void si47xx_lowWrite(u8 number_bytes, u8 idata *data_out)

{

    if(io_mode == IO3W)

    {

        io3w_write(number_bytes, data_out);

    }

    else // IO2W

    {

        io2w_write(number_bytes, data_out);

    }

}

void si47xx_lowRead(u8 number_bytes, u8 idata *data_in)

{

    if(io_mode == IO3W)

    {

        io3w_read(number_bytes, data_in);

    }

    else // IO2W

    {

        io2w_read(number_bytes, data_in);

    }

}

u8 si47xx_readStatus()

{

    u8 status;

    si47xx_lowRead(1, &status);

    return status;

}

void si47xx_waitForCTS()

{

  int temp=0;

    u16 i=1000;

    // Loop until CTS is found or stop due to the counter running out.

    while (--i && !(si47xx_readStatus() & CTS))

    {

        wait_us(500);

    }

  temp=1;

  temp=2;

    // If the i is equal to 0 then something must have happened.

    // It is recommended that the controller do some type of error

    // handling in this case.

}

//-----------------------------------------------------------------------------

// Sends a command to the part and returns the reply bytes

//-----------------------------------------------------------------------------

void si47xx_command(u8 cmd_size, u8 idata *cmd, u8 reply_size, u8 idata *reply)

{

    // It is always a good idea to check for cts prior to sending a command to

    // the part.

    si47xx_waitForCTS();

    // Write the command to the part

    si47xx_lowWrite(cmd_size, cmd);

    // Wait for CTS after sending the command

    si47xx_waitForCTS();

    // If the calling function would like to have results then read them.

    if(reply_size)

    {

        si47xx_lowRead(reply_size, reply);

    }

}

void si47xx_getPartInformation(void)

{

  data WORD Temp;

  data WORD Temp2;

  u8 partNumber;

  char fwMajor;

  char fwMinor;

  u16  patchID;

  char cmpMajor;

  char cmpMinor;

  char chipRev;

  char status=0xab;

  cmd[0]=0x0;

  cmd[1]=0x0;

  cmd[2]=0x0;

  cmd[3]=0x0;

  cmd[4]=0x0;

  cmd[5]=0x0;

  cmd[6]=0x0;

  cmd[7]=0x0;

  rsp[0]=0xee;

  rsp[1]=0xee;

  rsp[2]=0xee;

  rsp[3]=0xee;

  rsp[4]=0xee;

  rsp[5]=0xee;

  rsp[6]=0xee;

  rsp[7]=0xee;

  rsp[8]=0xee;

  rsp[9]=0xee;

  rsp[10]=0xee;

  rsp[11]=0xee;

  rsp[12]=0xee;

  rsp[13]=0xee;

  rsp[14]=0xee;

  Delay_Main ();

   // Wait for crystal to stabilize, make sure crystal has been running 1 ms

   while ((OSCXCN & 0x80) == 0);              

   // Make sure crystal frequency is stable

   for (Temp.i = 0; Temp.i < 200; Temp.i++) 

     Delay_Main ();

   RADIO_RESET = ON;                   // Bring radio out of reset

   SEN_bar = ON;  

  CONTROL_READ (POWERCONFIG, Temp);

   Temp.i &= ~DISABLE_PC;

   Temp.i |= ENABLE_PC;

   CONTROL_WRITE (POWERCONFIG, Temp);  // Enable radio

   for (Temp.i = 0; Temp.i < 1000; Temp.i++) Delay_Main ();

  // NOTE:  This routine should only be called when the part is powered up.

  // If you wish to retrieve some of the part information without fully

  // powering up the part call the POWER_UP command on the part with the

  // FUNC_DEBUG flag.

  // Put the ID for the command in the first byte.

  cmd[0] = GET_REV;

  // Invoke the command

  si47xx_command(1, cmd, 9, rsp);

  // Now take the result and put in the variables we have declared

  // Status is in the first element of the array so skip that.

  partNumber = rsp[1];

  fwMajor  = (char)rsp[2];

  fwMinor  = (char)rsp[3];

  patchID  = (u16)(rsp[4] << 8) | (u16)rsp[5];

  cmpMajor = (char)rsp[6];

  cmpMinor = (char)rsp[7];

  chipRev  = (char)rsp[8];

}