The latest updates to Windows 10 and Windows 7 have caused reported issues with Silicon Labs' Toolstick adapters, 8-bit debug adapters, and 32-bit debug adapters.
The reported behavior is that the debug adapters do not enumerate properly. Affected devices will not show up in the Windows Device Manager. Example bug reports are linked below.
If you are running into these issues you can try to roll back the above updates. However note that Microsoft places some restrictions on rolling back an update. For more information about rolling back a windows update and Microsoft's restrictions on uninstalling updates click the links below.
I am using 24LC512 EEPROM with C8051F340 development kit to accomplish memory write/read. The software example uses 24LC02 chip that needs single byte memory WORD ADDRESS. 24LC512 uses two byte memory address. After going through AN141 and EEPROM documentation and related I2C software examples, I modified the code to work with two byte memory address. It gives no error, runs the code both for write and read memory but returns wrong data value when read from EEPROM in following part of code. The return value in temp_char variable is always FF.
// Write the value 0xAA to location 0x25 in the EEPROM
EEPROM_ByteWrite(0x25, 0xAA);
// Read the value at location 0x25 in the EEPROM
temp_char = EEPROM_ByteRead(0x25);
// Check that the data was read properly
if (temp_char != 0xAA)
{
error_flag = 1;
}
After much debugging I cant figure out the problem.
The complete code is following.
//-----------------------------------------------------------------------------
// F34x_SMBus_EEPROM.c
//-----------------------------------------------------------------------------
// Copyright 2014 Silicon Laboratories, Inc.
// http://developer.silabs.com/legal/version/v11/Silicon_Labs_Software_License_Agreement.txt
//
// Program Description:
//
// This example demonstrates how the C8051F34x SMBus interface can communicate
// with a 256 byte I2C Serial EEPROM (Microchip 24LC02B).
// - Interrupt-driven SMBus implementation
// - Only master states defined (no slave or arbitration)
// - Timer1 used as SMBus clock source
// - Timer2 used by SMBus for SCL low timeout detection
// - SCL frequency defined by <SMB_FREQUENCY> constant
// - Pinout:
// P0.0 -> SDA (SMBus)
// P0.1 -> SCL (SMBus)
//
// P2.2 -> LED
//
// all other port pins unused
//
// How To Test:
//
// 1) Ensure shorting blocks are place on the following:
// - J19: Power - P1_PWR or SER_PWR
// - J7: +3VD - VDD
// - J12: P2.2 - P2.2_LED
// 2) Connect the USB Debug Adapter to J9. If P1_PWR power is selected on J19,
// connect the 9V power adapter to P1.
// 3) Compile and download code to a 'F340 device on a C8051F340-TB development
// board selecting Run -> Debug from the menus, clicking the Debug button in
// the quick menu, or pressing F11.
// 4) Connect the device to a to a 24LC02B serial EEPROM (see the EEPROM
// datasheet for the pinout information).
// 5) Run the code by selecting Run -> Resume from the menus, clicking the
// Resume button in the quick menu, or pressing F8:
// a) the test will indicate proper communication with the EEPROM by
// turning on the LED at the end the end of the test
// b) the test can also be verified by running to the if statements
// in main and checking the sent and received values by adding
// the variables to the Watch Window
//
// Target: C8051F340
// Tool chain: Simplicity Studio / Keil C51 9.51
// Command Line: None
//
// Release 1.1 (BL)
// - Updated Description / How to Test
// - Replaced C51 code with compiler agnostic code
// - 08 JAN 2014
//
// Release 1.0
// -Initial Revision (TP)
// -30 MAR 2006
//
//-----------------------------------------------------------------------------
// Includes and Device-Specific Parameters
//-----------------------------------------------------------------------------
#include <SI_C8051F340_Register_Enums.h>
//-----------------------------------------------------------------------------
// Global CONSTANTS
//-----------------------------------------------------------------------------
// System clock frequency in Hz
#define SYSCLK 12000000
#define SMB_FREQUENCY 100000 // Target SCL clock rate
// This example supports between 10kHz
// and 100kHz
// Device addresses (7 bits, lsb is a don't care)
#define EEPROM_ADDR 0xA0 // Device address for slave target
// Note: This address is specified
// in the Microchip 24LC02B
// datasheet.
// SMBus Buffer Size
#define SMB_BUFF_SIZE 0x08 // Defines the maximum number of bytes
// that can be sent or received in a
// single transfer
// Status vector - top 4 bits only
#define SMB_MTSTA 0xE0 // (MT) start transmitted
#define SMB_MTDB 0xC0 // (MT) data byte transmitted
#define SMB_MRDB 0x80 // (MR) data byte received
// End status vector definition
//-----------------------------------------------------------------------------
// Global VARIABLES
//-----------------------------------------------------------------------------
U8* pSMB_DATA_IN; // Global pointer for SMBus data
// All receive data is written here
U8 SMB_SINGLEBYTE_OUT; // Global holder for single byte writes.
U8* pSMB_DATA_OUT; // Global pointer for SMBus data.
// All transmit data is read from here
U8 SMB_DATA_LEN; // Global holder for number of bytes
// to send or receive in the current
// SMBus transfer.
U8 WORD_ADDR[2]; // Global holder for the EEPROM word
// address that will be accessed in
// the next transfer
U8 TARGET; // Target SMBus slave address
U8 sent_byte_counter;
U8 rec_byte_counter;
bit SMB_BUSY = 0; // Software flag to indicate when the
// EEPROM_ByteRead() or
// EEPROM_ByteWrite()
// functions have claimed the SMBus
bit SMB_RW; // Software flag to indicate the
// direction of the current transfer
bit SMB_SENDWORDADDR; // When set, this flag causes the ISR
// to send the 8-bit <WORD_ADDR>
// after sending the slave address.
bit SMB_RANDOMREAD; // When set, this flag causes the ISR
// to send a START signal after sending
// the word address.
// For the 24LC02B EEPROM, a random read
// (a read from a particular address in
// memory) starts as a write then
// changes to a read after the repeated
// start is sent. The ISR handles this
// switchover if the <SMB_RANDOMREAD>
// bit is set.
bit SMB_ACKPOLL; // When set, this flag causes the ISR
// to send a repeated START until the
// slave has acknowledged its address
// 16-bit SFR declarations
SBIT(SDA, SFR_P0, 0); // SW1 ='0' means switch pressed
SBIT(SCL, SFR_P0, 1); // SW2 ='0' means switch pressed
SBIT(LED, SFR_P2, 2); // LED='1' means ON
//-----------------------------------------------------------------------------
// Function PROTOTYPES
//-----------------------------------------------------------------------------
INTERRUPT_PROTO(Timer3_ISR, TIMER3_IRQn);
INTERRUPT_PROTO(SMBus_ISR, SMBUS0_IRQn);
//-----------------------------------------------------------------------------
// SiLabs_Startup() Routine
// ----------------------------------------------------------------------------
// This function is called immediately after reset, before the initialization
// code is run in SILABS_STARTUP.A51 (which runs before main() ). This is a
// useful place to disable the watchdog timer, which is enable by default
// and may trigger before main() in some instances.
//-----------------------------------------------------------------------------
void SiLabs_Startup (void)
{
PCA0MD &= ~0x40; // WDTE = 0 (disable watchdog timer)
}
//-----------------------------------------------------------------------------
// MAIN Routine
//-----------------------------------------------------------------------------
//
// Main routine performs all configuration tasks, then loops forever sending
// and receiving SMBus data to the slave EEPROM.
void main (void)
{
char in_buff[8] = {0}; // Incoming data buffer
char out_buff[8] = "ABCDEFG"; // Outgoing data buffer
U8 temp_char; // Temporary variable
bit error_flag = 0; // Flag for checking EEPROM contents
U8 i; // Temporary counter variable
// Set internal oscillator to highest
// setting of 24500000 (or 12000000 for 'F320)
OSCICN |= 0x03;
// If slave is holding SDA low because of an improper SMBus reset or error
while(!SDA)
{
// Provide clock pulses to allow the slave to advance out
// of its current state. This will allow it to release SDA.
XBR1 = 0x40; // Enable Crossbar
SCL = 0; // Drive the clock low
for(i = 0; i < 255; i++); // Hold the clock low
SCL = 1; // Release the clock
while(!SCL); // Wait for open-drain
// clock output to rise
for(i = 0; i < 10; i++); // Hold the clock high
XBR1 = 0x00; // Disable Crossbar
}
Port_Init (); // Initialize Crossbar and GPIO
LED = 0; // Turn off the LED before the test
// starts
Timer1_Init (); // Configure Timer1 for use as SMBus
// clock source
Timer3_Init (); // Configure Timer3 for use with SMBus
// low timeout detect
SMBus_Init (); // Configure and enable SMBus
EIE1 |= 0x01; // Enable the SMBus interrupt
IE_EA = 1; // Global interrupt enable
// Read and write some bytes to the EEPROM and check for proper
// communication
// Write the value 0xAA to location 0x25 in the EEPROM
EEPROM_ByteWrite(0x25, 0xAA);
// Read the value at location 0x25 in the EEPROM
temp_char = EEPROM_ByteRead(0x25);
// Check that the data was read properly
if (temp_char != 0xAA)
{
error_flag = 1;
}
// // Write the value 0xBB to location 0x25 in the EEPROM
// EEPROM_ByteWrite(0x25, 0xBB);
//
// // Write the value 0xCC to location 0x38 in the EEPROM
// EEPROM_ByteWrite(0x38, 0xCC);
//
// // Read the value at location 0x25 in the EEPROM
// temp_char = EEPROM_ByteRead(0x25);
//
// // Check that the data was read properly
// if (temp_char != 0xBB)
// {
// error_flag = 1;
// }
//
// // Read the value at location 0x38 in the EEPROM
// temp_char = EEPROM_ByteRead(0x38);
//
// // Check that the data was read properly
// if (temp_char != 0xCC)
// {
// error_flag = 1;
// }
//
// // Store the outgoing data buffer at EEPROM address 0x50
// EEPROM_WriteArray(0x50, out_buff, sizeof(out_buff));
//
// // Fill the incoming data buffer with data starting at EEPROM address 0x50
// EEPROM_ReadArray(in_buff, 0x50, sizeof(in_buff));
//
// // Check that the data that came from the EEPROM is the same as what was
// // sent
// for (i = 0; i < sizeof(in_buff); i++)
// {
// if (in_buff[i] != out_buff[i])
// {
// error_flag = 1;
// }
// }
// Indicate communication is good
if (error_flag == 0)
{
// LED = ON indicates that the test passed
LED = 1;
}
//-----------------------------------------------------------------------------
// PORT_Init
//-----------------------------------------------------------------------------
//
// Return Value : None
// Parameters : None
//
// Configure the Crossbar and GPIO ports.
//
// P0.0 digital open-drain SMBus SDA
// P0.1 digital open-drain SMBus SCL
//
// P2.2 digital push-pull LED
//
// all other port pins unused
//
// Note: If the SMBus is moved, the SCL and SDA sbit declarations must also
// be adjusted.
//
void PORT_Init (void)
{
P0MDOUT = 0x00; // All P0 pins open-drain output
P2MDOUT |= 0x04; // Make the LED (P2.2) a push-pull
// output
//-----------------------------------------------------------------------------
// SMBus Interrupt Service Routine (ISR)
//-----------------------------------------------------------------------------
//
// SMBus ISR state machine
// - Master only implementation - no slave or arbitration states defined
// - All incoming data is written starting at the global pointer <pSMB_DATA_IN>
// - All outgoing data is read from the global pointer <pSMB_DATA_OUT>
//
INTERRUPT(SMBus_ISR, SMBUS0_IRQn)
{
bit FAIL = 0; // Used by the ISR to flag failed
// transfers
static char i; // Used by the ISR to count the
// number of data bytes sent or
// received
switch (SMB0CN & 0xF0) // Status vector
{
// Master Transmitter/Receiver: START condition transmitted.
case SMB_MTSTA:
SMB0DAT = TARGET; // Load address of the target slave
SMB0DAT &= 0xFE; // Clear the LSB of the address for the
// R/W bit
SMB0DAT |= SMB_RW; // Load R/W bit
SMB0CN_STA = 0; // Manually clear START bit
i = 0; // Reset data byte counter
rec_byte_counter = 1; // Reset the counter
sent_byte_counter = 1; // Reset the counter
break;
// Master Transmitter: Data byte (or Slave Address) transmitted
case SMB_MTDB:
if (SMB0CN_ACK) // Slave Address or Data Byte
{ // Acknowledged?
if (SEND_START)
{
SMB0CN_STA = 1;
SEND_START = 0;
break;
}
if(SMB_SENDWORDADDR) // Are we sending the word address?
{
if (sent_byte_counter <= 2)
{
SMB0DAT = WORD_ADDR[sent_byte_counter-1]; // Send word address
sent_byte_counter++;
}
else
{
SMB_SENDWORDADDR = 0; // Clear flag
sent_byte_counter=1;
if (SMB_RANDOMREAD)
{
SEND_START = 1; // Send a START after the next SMB0CN_ACK cycle
SMB_RW = READ;
}
}
break;
}
if (SMB_RW==WRITE) // Is this transfer a WRITE?
{
if (i < SMB_DATA_LEN) // Is there data to send?
{
// send data byte
SMB0DAT = *pSMB_DATA_OUT;
// increment data out pointer
pSMB_DATA_OUT++;
// increment number of bytes sent
i++;
}
else
{
SMB0CN_STO = 1; // Set SMB0CN_STO to terminte transfer
SMB_BUSY = 0; // Clear software busy flag
}
}
else {} // If this transfer is a READ,
// then take no action. Slave
// address was transmitted. A
// separate 'case' is defined
// for data byte recieved.
}
else // If slave NACK,
{
if(SMB_ACKPOLL)
{
SMB0CN_STA = 1; // Restart transfer
}
else
{
FAIL = 1; // Indicate failed transfer
} // and handle at end of ISR
}
break;
// Master Receiver: byte received
case SMB_MRDB:
if ( i < SMB_DATA_LEN ) // Is there any data remaining?
{
*pSMB_DATA_IN = SMB0DAT; // Store received byte
pSMB_DATA_IN++; // Increment data in pointer
i++; // Increment number of bytes received
SMB0CN_ACK = 1; // Set SMB0CN_ACK bit (may be cleared later
// in the code)
}
if (i == SMB_DATA_LEN) // This is the last byte
{
SMB_BUSY = 0; // Free SMBus interface
SMB0CN_ACK = 0; // Send NACK to indicate last byte
// of this transfer
SMB0CN_STO = 1; // Send STOP to terminate transfer
}
break;
default:
FAIL = 1; // Indicate failed transfer
// and handle at end of ISR
break;
}
if (FAIL) // If the transfer failed,
{
SMB0CF &= ~0x80; // Reset communication
SMB0CF |= 0x80;
SMB0CN_STA = 0;
SMB0CN_STO = 0;
SMB0CN_ACK = 0;
SMB_BUSY = 0; // Free SMBus
FAIL = 0;
}
SMB0CN_SI = 0; // Clear interrupt flag
}
//-----------------------------------------------------------------------------
// Timer3 Interrupt Service Routine (ISR)
//-----------------------------------------------------------------------------
//
// A Timer3 interrupt indicates an SMBus SCL low timeout.
// The SMBus is disabled and re-enabled if a timeout occurs.
//
INTERRUPT(Timer3_ISR, TIMER3_IRQn)
{
SMB0CF &= ~0x80; // Disable SMBus
SMB0CF |= 0x80; // Re-enable SMBus
TMR3CN &= ~0x80; // Clear Timer3 interrupt-pending flag
SMB_BUSY = 0; // Free bus
}
//-----------------------------------------------------------------------------
// Support Functions
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// EEPROM_ByteWrite ()
//-----------------------------------------------------------------------------
//
// Return Value : None
// Parameters :
// 1) U8 addr - address to write in the EEPROM
// range is full range of character: 0 to 255
//
// 2) U8 dat - data to write to the address <addr> in the EEPROM
// range is full range of character: 0 to 255
//
// This function writes the value in <dat> to location <addr> in the EEPROM
// then polls the EEPROM until the write is complete.
//
void EEPROM_ByteWrite(U8 addr, U8 dat)
{
while (SMB_BUSY); // Wait for SMBus to be free.
SMB_BUSY = 1; // Claim SMBus (set to busy)
// Set SMBus ISR parameters
TARGET = EEPROM_ADDR; // Set target slave address
SMB_RW = WRITE; // Mark next transfer as a write
SMB_SENDWORDADDR = 1; // Send Word Address after Slave Address
SMB_RANDOMREAD = 0; // Do not send a START signal after
// the word address
SMB_ACKPOLL = 1; // Enable Acknowledge Polling (The ISR
// will automatically restart the
// transfer if the slave does not
// acknowledge its address.
// Specify the Outgoing Data
WORD_ADDR[0] = 0x00; // Set the target address in the
WORD_ADDR[1] = addr; // Set the target address in the
// EEPROM's internal memory space
SMB_SINGLEBYTE_OUT = dat; // Store <dat> (local variable) in a
// global variable so the ISR can read
// it after this function exits
// The outgoing data pointer points to the <dat> variable
pSMB_DATA_OUT = &SMB_SINGLEBYTE_OUT;
SMB_DATA_LEN = 1;
// SMB_DATA_LEN = 1; // Specify to ISR that the next transfer
// will contain one data byte
// Initiate SMBus Transfer
SMB0CN_STA = 1;
}
//-----------------------------------------------------------------------------
// EEPROM_WriteArray ()
//-----------------------------------------------------------------------------
//
// Return Value : None
// Parameters :
// 1) U8 dest_addr - beginning address to write to in the EEPROM
// range is full range of character: 0 to 255
//
// 2) U8* src_addr - pointer to the array of data to be written
// range is full range of character: 0 to 255
//
// 3) U8 len - length of the array to be written to the EEPROM
// range is full range of character: 0 to 255
//
// Writes <len> data bytes to the EEPROM slave specified by the <EEPROM_ADDR>
// constant.
//
void EEPROM_WriteArray(U8 dest_addr, U8* src_addr,
U8 len)
{
U8 i;
U8* pData = (U8*) src_addr;
for( i = 0; i < len; i++ ){
EEPROM_ByteWrite(dest_addr++, *pData++);
}
}
//-----------------------------------------------------------------------------
// EEPROM_ByteRead ()
//-----------------------------------------------------------------------------
//
// Return Value :
// 1) U8 data - data read from address <addr> in the EEPROM
// range is full range of character: 0 to 255
//
// Parameters :
// 1) U8 addr - address to read data from the EEPROM
// range is full range of character: 0 to 255
//
// This function returns a single byte from location <addr> in the EEPROM then
// polls the <SMB_BUSY> flag until the read is complete.
//
U8 EEPROM_ByteRead(U8 addr)
{
U8 retval; // Holds the return value
while (SMB_BUSY); // Wait for SMBus to be free.
SMB_BUSY = 1; // Claim SMBus (set to busy)
// Set SMBus ISR parameters
TARGET = EEPROM_ADDR; // Set target slave address
SMB_RW = WRITE; // A random read starts as a write
// then changes to a read after
// the repeated start is sent. The
// ISR handles this switchover if
// the <SMB_RANDOMREAD> bit is set.
SMB_SENDWORDADDR = 1; // Send Word Address after Slave Address
SMB_RANDOMREAD = 1; // Send a START after the word address
SMB_ACKPOLL = 1; // Enable Acknowledge Polling
// Specify the Incoming Data
WORD_ADDR[0] = 0x00; // Set the target address in the
WORD_ADDR[1] = addr; // Set the target address in the
// EEPROM's internal memory space
pSMB_DATA_IN = &retval; // The incoming data pointer points to
// the <retval> variable.
SMB_DATA_LEN = 1; // Specify to ISR that the next transfer
// will contain one data byte
// Initiate SMBus Transfer
SMB0CN_STA = 1;
while(SMB_BUSY); // Wait until data is read
return retval;
}
//-----------------------------------------------------------------------------
// EEPROM_ReadArray ()
//-----------------------------------------------------------------------------
//
// Return Value : None
// Parameters :
// 1) U8* dest_addr - pointer to the array that will be filled
// with the data from the EEPROM
// range is full range of character: 0 to 255
//
// 2) U8 src_addr - beginning address to read data from the EEPROM
// range is full range of character: 0 to 255
//
// 3) U8 len - length of the array to be read from the EEPROM
// range is full range of character: 0 to 255
//
// Reads up to 256 data bytes from the EEPROM slave specified by the
// <EEPROM_ADDR> constant.
//
void EEPROM_ReadArray (U8* dest_addr, U8 src_addr,
U8 len)
{
while (SMB_BUSY); // Wait for SMBus to be free.
SMB_BUSY = 1; // Claim SMBus (set to busy)
// Set SMBus ISR parameters
TARGET = EEPROM_ADDR; // Set target slave address
SMB_RW = WRITE; // A random read starts as a write
// then changes to a read after
// the repeated start is sent. The
// ISR handles this switchover if
// the <SMB_RANDOMREAD> bit is set.
SMB_SENDWORDADDR = 1; // Send Word Address after Slave Address
SMB_RANDOMREAD = 1; // Send a START after the word address
SMB_ACKPOLL = 1; // Enable Acknowledge Polling
// Specify the Incoming Data
WORD_ADDR[0] = 0x00; // Set the target address in the
WORD_ADDR[1] = src_addr; // Set the target address in the
// EEPROM's internal memory space
// Set the the incoming data pointer
pSMB_DATA_IN = (U8*) dest_addr;
SMB_DATA_LEN = len; // Specify to ISR that the next transfer
// will contain <len> data bytes
// Initiate SMBus Transfer
SMB0CN_STA = 1;
while(SMB_BUSY); // Wait until data is read
}
//-----------------------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------------------
We would like to input an analog voltage to the EFM8 starter kit board, pass it through the ADC, send the digital signal serially to the BGX board, which is then sent via bluetooth to a phone.
We are trying to use the temperature sensor example as a baseline to understand the basics on how to do this, but it seems more complicated than we thought.
We have disabled the temperature sensor in REF0CN and set the ADC0MX register to accept input from P1.0.
We think this should allow us to input an analog signal into P1.0, and receive the digitized voltage values on the cellphone. We are able to see values that change with the voltage, but they are way off of what we are actually inputting to the pin. Is there an easier way to display the real voltage values out of the ADC?
Attached is a zip file of our code. We've added comments to clarify what we're trying to do.
How to connect the Development kit type 'C8051F340DK' to Simplicity Studio 4? I tried entering the product name and registering the kit serial number but Simplicity studio 4 wouldn't recognize my development kit.
I develop C8051F340 for many years in MS Windows. Now I will transfer Windows's application software to Linux, the software include USB interface,which was developped with USBXpress SDK in windows. I try to search solution in forum, nothing found about F340 USB. So how can I transfer F340 USB software from Windows OS to Linux.
C2_PROG_Erase_Device 217 Write Command 0xDE
[ 26.454218] C2_write_cmd 311 start
[ 26.454431] write command 0xde
[ 26.454539] poll in busy ar value 0
[ 26.454576] C2_write_cmd 315 return ret 0 end
[ 26.724820] 333333333333 device_read 189
111111 buf.data0 0
write command 0xDE retrun 0
[ 26.815056] C2_read_data 332 start
[ 26.815232] ar value 0
[ 26.825178] ar value 0
[ 26.835116] ar value 0
[ 26.845054] ar value 0
[ 26.854990] ar value 0
[ 26.864926] ar value 0
[ 26.874861] ar value 0
[ 26.884797] ar value 0
[ 26.894734] ar value 0
[ 26.904670] ar value 0
[ 26.914605] ar value 0
[ 26.924540] ar value 0
[ 26.934477] ar value 0
[ 26.944414] ar value 0
[ 26.954352] ar value 0
[ 26.964286] ar value 0
[ 26.974222] ar value 0
[ 26.984157] ar value 0
[ 26.994093] ar value 0
[ 27.004028] ar value 0
[ 27.013963] ar value 0
[ 27.023899] ar value 0
[ 27.033833] ar value 0
[ 27.043769] ar value 0
[ 27.053706] ar value 0
[ 27.063640] ar value 0
[ 27.073577] ar value 0
[ 27.083511] ar value 0
[ 27.093447] ar value 0
[ 27.103381] ar value 0
[ 27.113317] ar value 0
[ 27.123254] ar value 0
[ 27.133189] ar value 0
[ 27.143125] ar value 0
[ 27.153061] ar value 0
[ 27.162997] ar value 0
[ 27.172932] ar value 0
[ 27.182867] ar value 0
[ 27.192803] ar value 0
[ 27.202738] ar value 0
[ 27.212675] ar value 0
[ 27.222609] ar value 0
[ 27.232544] ar value 0
[ 27.242479] ar value 0
[ 27.252415] ar value 0
[ 27.262350] ar value 0
[ 27.272285] ar value 0
[ 27.282220] ar value 0
[ 27.292155] ar value 0
[ 27.302090] ar value 0
[ 27.312026] ar value 0
[ 27.321961] ar value 0
[ 27.331897] ar value 0
[ 27.341831] ar value 0
[ 27.351767] ar value 0
[ 27.361702] ar value 0
[ 27.371637] ar value 0
[ 27.381572] ar value 0
[ 27.391507] ar value 0
[ 27.401442] ar value 0
[ 27.411377] ar value 0
[ 27.421311] ar value 0
[ 27.431248] ar value 0
[ 27.441182] ar value 0
[ 27.451119] ar value 0
[ 27.461053] ar value 0
[ 27.470990] ar value 0
[ 27.480925] ar value 0
[ 27.490859] ar value 0
[ 27.500795] ar value 0
[ 27.510730] ar value 0
[ 27.520666] ar value 0
[ 27.530602] ar value 0
[ 27.540537] ar value 0
[ 27.550472] ar value 0
[ 27.560407] ar value 0
[ 27.570343] ar value 0
[ 27.580277] ar value 0
[ 27.590214] ar value 0
[ 27.600148] ar value 0
[ 27.610083] ar value 0
[ 27.620019] ar value 0
[ 27.629954] ar value 0
[ 27.639889] ar value 0
[ 27.649824] ar value 0
[ 27.659760] ar value 0
[ 27.669695] ar value 0
[ 27.679630] ar value 0
[ 27.689566] ar value 0
[ 27.699501] ar value 0
[ 27.709437] ar value 0
[ 27.719371] ar value 0
[ 27.729307] ar value 0
[ 27.739242] ar value 0
[ 27.749177] ar value 0
[ 27.759112] ar value 0
[ 27.769048] ar value 0
[ 27.778984] ar value 0
[ 27.788920] ar value 0
[ 27.798855] ar value 0
[ 27.808790] ar value 0
[ 27.818725] ar value 0
[ 27.828662] ar value 0
[ 27.838596] ar value 0
[ 27.848532] ar value 0
[ 27.858467] ar value 0
[ 27.868401] ar value 0
[ 27.878336] ar value 0
[ 27.888271] ar value 0
[ 27.898207] ar value 0
[ 27.908143] ar value 0
[ 27.918078] ar value 0
[ 27.928013] ar value 0
[ 27.937947] ar value 0
[ 27.947884] ar value 0
[ 27.957818] ar value 0
[ 27.967754] ar value 0
[ 27.977689] ar value 0
[ 27.987626] ar value 0
[ 27.997560] ar value 0
[ 27.997586] poll out ready timeout
[ 27.997618] C2_read_data 336 C2_POLL_OUTREADY_TIMEOUT
[ 27.998265] [sched_delayed] sched: RT throttling activated
C2_PROG_WriteCommad(0xDE) timeout
int C2_PROG_Erase_Device(void)
{
int fpdat = 0xB4;
int ret;
printf("%s %d Write AR\n",__FUNCTION__,__LINE__);
ret = C2_PROG_WriteAR(fpdat);
if (ret == S_ERROR)
{
printf("%s %d failde\n",__FUNCTION__,__LINE__);
return S_ERROR;
}
WRTIE_COMMAND_03:
usleep(9000);
printf("%s %d Write Command 0x03\n",__FUNCTION__,__LINE__);
ret = C2_PROG_WriteCommad(0x03);
if (ret == S_ERROR)
{
printf("%s %d failde\n",__FUNCTION__,__LINE__);
return S_ERROR;
}
usleep(9000);
printf("%s %d Write Command READ DATA\n",__FUNCTION__,__LINE__);
ret = C2_PROG_ReadData();
if (ret == 0x0D)
{
printf("C2_PROG_WriteCommad(0x03) success \n");
}
if (ret != 0x0D)
{
printf("C2_PROG_WriteCommad(0x03) timeout \n");
goto WRTIE_COMMAND_03;
}
WRTIE_COMMAND_DE:
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
printf("%s %d Write Command 0xDE\n",__FUNCTION__,__LINE__);
ret = C2_PROG_WriteCommad(0xDE);
printf("write command 0xDE retrun %d\n",ret);
if (ret == 0x07)
{
printf("command 0xDE busy\n");
goto WRTIE_COMMAND_DE;
}
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
ret = C2_PROG_ReadData();
if (ret == 0x0D)
{
printf("C2_PROG_WriteCommad(0xDE) success \n");
}
if (ret != 0x0D)
{
printf("C2_PROG_WriteCommad(0xDE) timeout \n");
goto WRTIE_COMMAND_DE;
}
WRTIE_COMMAND_AD:
printf("%s %d Write Command 0xAD\n",__FUNCTION__,__LINE__);
// Write 0x00
usleep(9000);
ret = C2_PROG_WriteCommad(0xAD);
if (ret == S_ERROR)
{
printf("%s %d failde\n",__FUNCTION__,__LINE__);
return S_ERROR;
}
printf("%s %d \n",__FUNCTION__,__LINE__);
usleep(9000);
ret = C2_PROG_ReadData();
if (ret != 0x0D)
{
printf("C2_PROG_WriteCommad(0xAD) success \n");
}
if (ret != 5)
{
printf("C2_PROG_WriteCommad(0xAD) timeout \n");
goto WRTIE_COMMAND_AD;
}
usleep(9000);
WRTIE_COMMAND_A5:
ret = C2_PROG_WriteCommad(0xA5);
if (ret == S_ERROR)
{
printf("%s %d failde\n",__FUNCTION__,__LINE__);
return S_ERROR;
}
printf("%s %d \n",__FUNCTION__,__LINE__);
usleep(9000);
ret = C2_PROG_ReadData();
if (ret == 0x0D)
{
printf("C2_PROG_WriteCommad(0xA5) success \n");
}
if (ret != 0X0D)
{
printf("C2_PROG_WriteCommad(0xA5) timeout \n");
goto WRTIE_COMMAND_A5;
}
printf("%s %d \n",__FUNCTION__,__LINE__);
}
0x03指令通过log确认可以执行成功，执行到0xDE指令时，POLL IN BUYS 一直返回忙碌状态，无法继续执行
执行此指令之前，已经对cpu 进行halt的动作
int C2_PROG_Init_Chip(void)
{
int ret;
ret = C2_PROG_Check();
if (ret == S_ERROR)
{
printf("programmer does not answer\n");
return S_ERROR;
}
ret = C2_PROG_Halt();
if (ret == S_ERROR)
{
printf("failed to halt chip \n");
return S_ERROR;
}
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
ret = C2_PROG_WriteAR(0x00);
if (ret == S_ERROR)
{
printf("failed to select device id register \n");
return S_ERROR;
}
ret = C2_PROG_ReadDR();
if (ret == S_ERROR)
{
printf("failed to read chip id \n");
return S_ERROR;
}
printf("chip ID %d found\n",ret);
if (ret == 22)
{
printf("EFM8SB2 DEVICES ID FOUND\n");
}
// init the EFM8SB2 (see AN127)
ret = C2_PROG_WriteDirect(0xA7, 0x00);
if (ret == S_ERROR)
{
printf("chip init failed - osc 0xA7 \n");
return S_ERROR;
}
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
ret = C2_PROG_WriteDirect(0xB2, 0x8F);
if (ret == S_ERROR)
{
printf("chip init failed - osc 0xB2 \n");
return S_ERROR;
}
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
ret = C2_PROG_WriteDirect(0xA9, 0x00);
if (ret == S_ERROR)
{
printf("chip init failed - osc 0xA9 \n");
return S_ERROR;
}
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
usleep(9000);
}
Hello everyone, newbie here, I am trying to program a specific combination of logic gates involving 3 different inputs: A, B and C. to make the following circuit:
so this should be: T=AB'+BC'.
in the Configurator I can set the input pins for both A and B, but not for C:
why is this so? is it a limitation of my MCU? can i still somehow make that logic circuit in my MCU?
Hi, I am using the FlashUtilCL.exe command line programmer to program EFM8BB10F8G-A-QFN20 MCUs using a USB EC3 debugger. I have found the documentation a bit unclear in some parts so have some questions.
1. The command line readme is dated 2011 but the utildll.exe release notes have updates up to 2017. Is there a newer readme for the command line programmer?
2. Does the downloadusb command include a verify function?
3. When the command succeeds should there be a return code shown? I get no return code for success and if there is an error I get a text description of the error.
4. I have found that if I run the downloadusb command with the lock option I can still run the verifyusb command with no errors. Is this correct?
Hey everybody,
we are part of the MFi program and develop an iPhone accessory via the lightning interface. A 8-bit Si Labs MCU should be part of our accessory. Is there any iAP2 software/firmware template we can use to develop our accessory after purchasing the MCUs (Universal Bee Family)?
Forum
Informational Thread: Toolstick and Debug Adapter Issues After Recent Win10 and Win7 Updates.
EDIT: See additional discussion in the Studio forum thread
https://www.silabs.com/community/software/simplicity-studio/forum.topic.html/informational_thread-kgyL
The latest updates to Windows 10 and Windows 7 have caused reported issues with Silicon Labs' Toolstick adapters, 8-bit debug adapters, and 32-bit debug adapters.
The updates in question are:
KB4487044 (Win10 ver 1809)
KB4487017 (Win10 ver 1803)
KB4486563 (Win7)
The reported behavior is that the debug adapters do not enumerate properly. Affected devices will not show up in the Windows Device Manager. Example bug reports are linked below.
1 2 3
If you are running into these issues you can try to roll back the above updates. However note that Microsoft places some restrictions on rolling back an update. For more information about rolling back a windows update and Microsoft's restrictions on uninstalling updates click the links below.
Windows Patching Information
Windows 10 Update FAQ
If you are able to roll back these updates but still experience issues, please submit a support ticket here.
Silicon Labs is in contact with Microsoft and we are working to resolve the issue. Updates will be posted here.
EEPROM write/read problem using I2C
I am using 24LC512 EEPROM with C8051F340 development kit to accomplish memory write/read. The software example uses 24LC02 chip that needs single byte memory WORD ADDRESS. 24LC512 uses two byte memory address. After going through AN141 and EEPROM documentation and related I2C software examples, I modified the code to work with two byte memory address. It gives no error, runs the code both for write and read memory but returns wrong data value when read from EEPROM in following part of code. The return value in temp_char variable is always FF.
// Write the value 0xAA to location 0x25 in the EEPROM
EEPROM_ByteWrite(0x25, 0xAA);
// Read the value at location 0x25 in the EEPROM
temp_char = EEPROM_ByteRead(0x25);
// Check that the data was read properly
if (temp_char != 0xAA)
{
error_flag = 1;
}
After much debugging I cant figure out the problem.
The complete code is following.
//-----------------------------------------------------------------------------
// F34x_SMBus_EEPROM.c
//-----------------------------------------------------------------------------
// Copyright 2014 Silicon Laboratories, Inc.
// http://developer.silabs.com/legal/version/v11/Silicon_Labs_Software_License_Agreement.txt
//
// Program Description:
//
// This example demonstrates how the C8051F34x SMBus interface can communicate
// with a 256 byte I2C Serial EEPROM (Microchip 24LC02B).
// - Interrupt-driven SMBus implementation
// - Only master states defined (no slave or arbitration)
// - Timer1 used as SMBus clock source
// - Timer2 used by SMBus for SCL low timeout detection
// - SCL frequency defined by <SMB_FREQUENCY> constant
// - Pinout:
// P0.0 -> SDA (SMBus)
// P0.1 -> SCL (SMBus)
//
// P2.2 -> LED
//
// all other port pins unused
//
// How To Test:
//
// 1) Ensure shorting blocks are place on the following:
// - J19: Power - P1_PWR or SER_PWR
// - J7: +3VD - VDD
// - J12: P2.2 - P2.2_LED
// 2) Connect the USB Debug Adapter to J9. If P1_PWR power is selected on J19,
// connect the 9V power adapter to P1.
// 3) Compile and download code to a 'F340 device on a C8051F340-TB development
// board selecting Run -> Debug from the menus, clicking the Debug button in
// the quick menu, or pressing F11.
// 4) Connect the device to a to a 24LC02B serial EEPROM (see the EEPROM
// datasheet for the pinout information).
// 5) Run the code by selecting Run -> Resume from the menus, clicking the
// Resume button in the quick menu, or pressing F8:
// a) the test will indicate proper communication with the EEPROM by
// turning on the LED at the end the end of the test
// b) the test can also be verified by running to the if statements
// in main and checking the sent and received values by adding
// the variables to the Watch Window
//
// Target: C8051F340
// Tool chain: Simplicity Studio / Keil C51 9.51
// Command Line: None
//
// Release 1.1 (BL)
// - Updated Description / How to Test
// - Replaced C51 code with compiler agnostic code
// - 08 JAN 2014
//
// Release 1.0
// -Initial Revision (TP)
// -30 MAR 2006
//
//-----------------------------------------------------------------------------
// Includes and Device-Specific Parameters
//-----------------------------------------------------------------------------
#include <SI_C8051F340_Register_Enums.h>
//-----------------------------------------------------------------------------
// Global CONSTANTS
//-----------------------------------------------------------------------------
// System clock frequency in Hz
#define SYSCLK 12000000
#define SMB_FREQUENCY 100000 // Target SCL clock rate
// This example supports between 10kHz
// and 100kHz
#define WRITE 0x00 // SMBus WRITE command
#define READ 0x01 // SMBus READ command
// Device addresses (7 bits, lsb is a don't care)
#define EEPROM_ADDR 0xA0 // Device address for slave target
// Note: This address is specified
// in the Microchip 24LC02B
// datasheet.
// SMBus Buffer Size
#define SMB_BUFF_SIZE 0x08 // Defines the maximum number of bytes
// that can be sent or received in a
// single transfer
// Status vector - top 4 bits only
#define SMB_MTSTA 0xE0 // (MT) start transmitted
#define SMB_MTDB 0xC0 // (MT) data byte transmitted
#define SMB_MRDB 0x80 // (MR) data byte received
// End status vector definition
//-----------------------------------------------------------------------------
// Global VARIABLES
//-----------------------------------------------------------------------------
U8* pSMB_DATA_IN; // Global pointer for SMBus data
// All receive data is written here
U8 SMB_SINGLEBYTE_OUT; // Global holder for single byte writes.
U8* pSMB_DATA_OUT; // Global pointer for SMBus data.
// All transmit data is read from here
U8 SMB_DATA_LEN; // Global holder for number of bytes
// to send or receive in the current
// SMBus transfer.
U8 WORD_ADDR[2]; // Global holder for the EEPROM word
// address that will be accessed in
// the next transfer
U8 TARGET; // Target SMBus slave address
U8 sent_byte_counter;
U8 rec_byte_counter;
bit SMB_BUSY = 0; // Software flag to indicate when the
// EEPROM_ByteRead() or
// EEPROM_ByteWrite()
// functions have claimed the SMBus
bit SMB_RW; // Software flag to indicate the
// direction of the current transfer
bit SMB_SENDWORDADDR; // When set, this flag causes the ISR
// to send the 8-bit <WORD_ADDR>
// after sending the slave address.
bit SMB_RANDOMREAD; // When set, this flag causes the ISR
// to send a START signal after sending
// the word address.
// For the 24LC02B EEPROM, a random read
// (a read from a particular address in
// memory) starts as a write then
// changes to a read after the repeated
// start is sent. The ISR handles this
// switchover if the <SMB_RANDOMREAD>
// bit is set.
bit SMB_ACKPOLL; // When set, this flag causes the ISR
// to send a repeated START until the
// slave has acknowledged its address
// 16-bit SFR declarations
SBIT(SDA, SFR_P0, 0); // SW1 ='0' means switch pressed
SBIT(SCL, SFR_P0, 1); // SW2 ='0' means switch pressed
SBIT(LED, SFR_P2, 2); // LED='1' means ON
//-----------------------------------------------------------------------------
// Function PROTOTYPES
//-----------------------------------------------------------------------------
INTERRUPT_PROTO(Timer3_ISR, TIMER3_IRQn);
INTERRUPT_PROTO(SMBus_ISR, SMBUS0_IRQn);
void SMBus_Init(void);
void Timer1_Init(void);
void Timer3_Init(void);
void Port_Init(void);
void EEPROM_AddrWrite(U8 addr);
void EEPROM_ByteWrite(U8 addr, U8 dat);
void EEPROM_WriteArray(U8 dest_addr, U8* src_addr,
U8 len);
void EEPROM_AddrRead(U8 addr);
U8 EEPROM_ByteRead(U8 addr);
void EEPROM_ReadArray(U8* dest_addr, U8 src_addr,
U8 len);
//-----------------------------------------------------------------------------
// SiLabs_Startup() Routine
// ----------------------------------------------------------------------------
// This function is called immediately after reset, before the initialization
// code is run in SILABS_STARTUP.A51 (which runs before main() ). This is a
// useful place to disable the watchdog timer, which is enable by default
// and may trigger before main() in some instances.
//-----------------------------------------------------------------------------
void SiLabs_Startup (void)
{
PCA0MD &= ~0x40; // WDTE = 0 (disable watchdog timer)
}
//-----------------------------------------------------------------------------
// MAIN Routine
//-----------------------------------------------------------------------------
//
// Main routine performs all configuration tasks, then loops forever sending
// and receiving SMBus data to the slave EEPROM.
void main (void)
{
char in_buff[8] = {0}; // Incoming data buffer
char out_buff[8] = "ABCDEFG"; // Outgoing data buffer
U8 temp_char; // Temporary variable
bit error_flag = 0; // Flag for checking EEPROM contents
U8 i; // Temporary counter variable
// Set internal oscillator to highest
// setting of 24500000 (or 12000000 for 'F320)
OSCICN |= 0x03;
// If slave is holding SDA low because of an improper SMBus reset or error
while(!SDA)
{
// Provide clock pulses to allow the slave to advance out
// of its current state. This will allow it to release SDA.
XBR1 = 0x40; // Enable Crossbar
SCL = 0; // Drive the clock low
for(i = 0; i < 255; i++); // Hold the clock low
SCL = 1; // Release the clock
while(!SCL); // Wait for open-drain
// clock output to rise
for(i = 0; i < 10; i++); // Hold the clock high
XBR1 = 0x00; // Disable Crossbar
}
Port_Init (); // Initialize Crossbar and GPIO
LED = 0; // Turn off the LED before the test
// starts
Timer1_Init (); // Configure Timer1 for use as SMBus
// clock source
Timer3_Init (); // Configure Timer3 for use with SMBus
// low timeout detect
SMBus_Init (); // Configure and enable SMBus
EIE1 |= 0x01; // Enable the SMBus interrupt
IE_EA = 1; // Global interrupt enable
// Read and write some bytes to the EEPROM and check for proper
// communication
// Write the value 0xAA to location 0x25 in the EEPROM
EEPROM_ByteWrite(0x25, 0xAA);
// Read the value at location 0x25 in the EEPROM
temp_char = EEPROM_ByteRead(0x25);
// Check that the data was read properly
if (temp_char != 0xAA)
{
error_flag = 1;
}
// // Write the value 0xBB to location 0x25 in the EEPROM
// EEPROM_ByteWrite(0x25, 0xBB);
//
// // Write the value 0xCC to location 0x38 in the EEPROM
// EEPROM_ByteWrite(0x38, 0xCC);
//
// // Read the value at location 0x25 in the EEPROM
// temp_char = EEPROM_ByteRead(0x25);
//
// // Check that the data was read properly
// if (temp_char != 0xBB)
// {
// error_flag = 1;
// }
//
// // Read the value at location 0x38 in the EEPROM
// temp_char = EEPROM_ByteRead(0x38);
//
// // Check that the data was read properly
// if (temp_char != 0xCC)
// {
// error_flag = 1;
// }
//
// // Store the outgoing data buffer at EEPROM address 0x50
// EEPROM_WriteArray(0x50, out_buff, sizeof(out_buff));
//
// // Fill the incoming data buffer with data starting at EEPROM address 0x50
// EEPROM_ReadArray(in_buff, 0x50, sizeof(in_buff));
//
// // Check that the data that came from the EEPROM is the same as what was
// // sent
// for (i = 0; i < sizeof(in_buff); i++)
// {
// if (in_buff[i] != out_buff[i])
// {
// error_flag = 1;
// }
// }
// Indicate communication is good
if (error_flag == 0)
{
// LED = ON indicates that the test passed
LED = 1;
}
while(1);
}
//-----------------------------------------------------------------------------
// Initialization Routines
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// SMBus_Init()
//-----------------------------------------------------------------------------
//
// Return Value : None
// Parameters : None
//
// The SMBus peripheral is configured as follows:
// - SMBus enabled
// - Slave mode disabled
// - Timer1 used as clock source. The maximum SCL frequency will be
// approximately 1/3 the Timer1 overflow rate
// - Setup and hold time extensions enabled
// - Free and SCL low timeout detection enabled
//
void SMBus_Init (void)
{
SMB0CF = 0x5D; // Use Timer1 overflows as SMBus clock
// source;
// Disable slave mode;
// Enable setup & hold time extensions;
// Enable SMBus Free timeout detect;
// Enable SCL low timeout detect;
SMB0CF |= 0x80; // Enable SMBus;
}
//-----------------------------------------------------------------------------
// Timer1_Init()
//-----------------------------------------------------------------------------
//
// Return Value : None
// Parameters : None
//
// Timer1 is configured as the SMBus clock source as follows:
// - Timer1 in 8-bit auto-reload mode
// - SYSCLK / 12 as Timer1 clock source
// - Timer1 overflow rate => 3 * SMB_FREQUENCY
// - The maximum SCL clock rate will be ~1/3 the Timer1 overflow rate
// - Timer1 enabled
//
void Timer1_Init (void)
{
// Make sure the Timer can produce the appropriate frequency in 8-bit mode
// Supported SMBus Frequencies range from 10kHz to 100kHz. The CKCON register
// settings may need to change for frequencies outside this range.
#if ((SYSCLK/SMB_FREQUENCY/3) < 255)
#define SCALE 1
CKCON |= 0x08; // Timer1 clock source = SYSCLK
#elif ((SYSCLK/SMB_FREQUENCY/4/3) < 255)
#define SCALE 4
CKCON |= 0x01;
CKCON &= ~0x0A; // Timer1 clock source = SYSCLK / 4
#endif
TMOD = 0x20; // Timer1 in 8-bit auto-reload mode
TH1 = -(SYSCLK/SMB_FREQUENCY/SCALE/3); // Timer1 configured to overflow at 1/3
// the rate defined by SMB_FREQUENCY
TL1 = TH1; // Init Timer1
TCON_TR1 = 1; // Timer1 enabled
}
//-----------------------------------------------------------------------------
// Timer3_Init()
//-----------------------------------------------------------------------------
//
// Return Value : None
// Parameters : None
//
// Timer3 configured for use by the SMBus low timeout detect feature as
// follows:
// - Timer3 in 16-bit auto-reload mode
// - SYSCLK/12 as Timer3 clock source
// - Timer3 reload registers loaded for a 25ms overflow period
// - Timer3 pre-loaded to overflow after 25ms
// - Timer3 enabled
//
void Timer3_Init (void)
{
TMR3CN = 0x00; // Timer3 configured for 16-bit auto-
// reload, low-byte interrupt disabled
CKCON &= ~0x40; // Timer3 uses SYSCLK/12
TMR3RL = -(SYSCLK/12/40); // Timer3 configured to overflow after
TMR3 = TMR3RL; // ~25ms (for SMBus low timeout detect)
EIE1 |= 0x80; // Timer3 interrupt enable
TMR3CN |= 0x04; // Start Timer3
}
//-----------------------------------------------------------------------------
// PORT_Init
//-----------------------------------------------------------------------------
//
// Return Value : None
// Parameters : None
//
// Configure the Crossbar and GPIO ports.
//
// P0.0 digital open-drain SMBus SDA
// P0.1 digital open-drain SMBus SCL
//
// P2.2 digital push-pull LED
//
// all other port pins unused
//
// Note: If the SMBus is moved, the SCL and SDA sbit declarations must also
// be adjusted.
//
void PORT_Init (void)
{
P0MDOUT = 0x00; // All P0 pins open-drain output
P2MDOUT |= 0x04; // Make the LED (P2.2) a push-pull
// output
XBR0 = 0x04; // Enable SMBus pins
XBR1 = 0x40; // Enable crossbar and weak pull-ups
P0 = 0xFF;
}
//-----------------------------------------------------------------------------
// SMBus Interrupt Service Routine (ISR)
//-----------------------------------------------------------------------------
//
// SMBus ISR state machine
// - Master only implementation - no slave or arbitration states defined
// - All incoming data is written starting at the global pointer <pSMB_DATA_IN>
// - All outgoing data is read from the global pointer <pSMB_DATA_OUT>
//
INTERRUPT(SMBus_ISR, SMBUS0_IRQn)
{
bit FAIL = 0; // Used by the ISR to flag failed
// transfers
static char i; // Used by the ISR to count the
// number of data bytes sent or
// received
static U8 sent_byte_counter;
static U8 rec_byte_counter;
static bit SEND_START = 0; // Send a start
switch (SMB0CN & 0xF0) // Status vector
{
// Master Transmitter/Receiver: START condition transmitted.
case SMB_MTSTA:
SMB0DAT = TARGET; // Load address of the target slave
SMB0DAT &= 0xFE; // Clear the LSB of the address for the
// R/W bit
SMB0DAT |= SMB_RW; // Load R/W bit
SMB0CN_STA = 0; // Manually clear START bit
i = 0; // Reset data byte counter
rec_byte_counter = 1; // Reset the counter
sent_byte_counter = 1; // Reset the counter
break;
// Master Transmitter: Data byte (or Slave Address) transmitted
case SMB_MTDB:
if (SMB0CN_ACK) // Slave Address or Data Byte
{ // Acknowledged?
if (SEND_START)
{
SMB0CN_STA = 1;
SEND_START = 0;
break;
}
if(SMB_SENDWORDADDR) // Are we sending the word address?
{
if (sent_byte_counter <= 2)
{
SMB0DAT = WORD_ADDR[sent_byte_counter-1]; // Send word address
sent_byte_counter++;
}
else
{
SMB_SENDWORDADDR = 0; // Clear flag
sent_byte_counter=1;
if (SMB_RANDOMREAD)
{
SEND_START = 1; // Send a START after the next SMB0CN_ACK cycle
SMB_RW = READ;
}
}
break;
}
if (SMB_RW==WRITE) // Is this transfer a WRITE?
{
if (i < SMB_DATA_LEN) // Is there data to send?
{
// send data byte
SMB0DAT = *pSMB_DATA_OUT;
// increment data out pointer
pSMB_DATA_OUT++;
// increment number of bytes sent
i++;
}
else
{
SMB0CN_STO = 1; // Set SMB0CN_STO to terminte transfer
SMB_BUSY = 0; // Clear software busy flag
}
}
else {} // If this transfer is a READ,
// then take no action. Slave
// address was transmitted. A
// separate 'case' is defined
// for data byte recieved.
}
else // If slave NACK,
{
if(SMB_ACKPOLL)
{
SMB0CN_STA = 1; // Restart transfer
}
else
{
FAIL = 1; // Indicate failed transfer
} // and handle at end of ISR
}
break;
// Master Receiver: byte received
case SMB_MRDB:
if ( i < SMB_DATA_LEN ) // Is there any data remaining?
{
*pSMB_DATA_IN = SMB0DAT; // Store received byte
pSMB_DATA_IN++; // Increment data in pointer
i++; // Increment number of bytes received
SMB0CN_ACK = 1; // Set SMB0CN_ACK bit (may be cleared later
// in the code)
}
if (i == SMB_DATA_LEN) // This is the last byte
{
SMB_BUSY = 0; // Free SMBus interface
SMB0CN_ACK = 0; // Send NACK to indicate last byte
// of this transfer
SMB0CN_STO = 1; // Send STOP to terminate transfer
}
break;
default:
FAIL = 1; // Indicate failed transfer
// and handle at end of ISR
break;
}
if (FAIL) // If the transfer failed,
{
SMB0CF &= ~0x80; // Reset communication
SMB0CF |= 0x80;
SMB0CN_STA = 0;
SMB0CN_STO = 0;
SMB0CN_ACK = 0;
SMB_BUSY = 0; // Free SMBus
FAIL = 0;
}
SMB0CN_SI = 0; // Clear interrupt flag
}
//-----------------------------------------------------------------------------
// Timer3 Interrupt Service Routine (ISR)
//-----------------------------------------------------------------------------
//
// A Timer3 interrupt indicates an SMBus SCL low timeout.
// The SMBus is disabled and re-enabled if a timeout occurs.
//
INTERRUPT(Timer3_ISR, TIMER3_IRQn)
{
SMB0CF &= ~0x80; // Disable SMBus
SMB0CF |= 0x80; // Re-enable SMBus
TMR3CN &= ~0x80; // Clear Timer3 interrupt-pending flag
SMB_BUSY = 0; // Free bus
}
//-----------------------------------------------------------------------------
// Support Functions
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// EEPROM_ByteWrite ()
//-----------------------------------------------------------------------------
//
// Return Value : None
// Parameters :
// 1) U8 addr - address to write in the EEPROM
// range is full range of character: 0 to 255
//
// 2) U8 dat - data to write to the address <addr> in the EEPROM
// range is full range of character: 0 to 255
//
// This function writes the value in <dat> to location <addr> in the EEPROM
// then polls the EEPROM until the write is complete.
//
void EEPROM_ByteWrite(U8 addr, U8 dat)
{
while (SMB_BUSY); // Wait for SMBus to be free.
SMB_BUSY = 1; // Claim SMBus (set to busy)
// Set SMBus ISR parameters
TARGET = EEPROM_ADDR; // Set target slave address
SMB_RW = WRITE; // Mark next transfer as a write
SMB_SENDWORDADDR = 1; // Send Word Address after Slave Address
SMB_RANDOMREAD = 0; // Do not send a START signal after
// the word address
SMB_ACKPOLL = 1; // Enable Acknowledge Polling (The ISR
// will automatically restart the
// transfer if the slave does not
// acknowledge its address.
// Specify the Outgoing Data
WORD_ADDR[0] = 0x00; // Set the target address in the
WORD_ADDR[1] = addr; // Set the target address in the
// EEPROM's internal memory space
SMB_SINGLEBYTE_OUT = dat; // Store <dat> (local variable) in a
// global variable so the ISR can read
// it after this function exits
// The outgoing data pointer points to the <dat> variable
pSMB_DATA_OUT = &SMB_SINGLEBYTE_OUT;
SMB_DATA_LEN = 1;
// SMB_DATA_LEN = 1; // Specify to ISR that the next transfer
// will contain one data byte
// Initiate SMBus Transfer
SMB0CN_STA = 1;
}
//-----------------------------------------------------------------------------
// EEPROM_WriteArray ()
//-----------------------------------------------------------------------------
//
// Return Value : None
// Parameters :
// 1) U8 dest_addr - beginning address to write to in the EEPROM
// range is full range of character: 0 to 255
//
// 2) U8* src_addr - pointer to the array of data to be written
// range is full range of character: 0 to 255
//
// 3) U8 len - length of the array to be written to the EEPROM
// range is full range of character: 0 to 255
//
// Writes <len> data bytes to the EEPROM slave specified by the <EEPROM_ADDR>
// constant.
//
void EEPROM_WriteArray(U8 dest_addr, U8* src_addr,
U8 len)
{
U8 i;
U8* pData = (U8*) src_addr;
for( i = 0; i < len; i++ ){
EEPROM_ByteWrite(dest_addr++, *pData++);
}
}
//-----------------------------------------------------------------------------
// EEPROM_ByteRead ()
//-----------------------------------------------------------------------------
//
// Return Value :
// 1) U8 data - data read from address <addr> in the EEPROM
// range is full range of character: 0 to 255
//
// Parameters :
// 1) U8 addr - address to read data from the EEPROM
// range is full range of character: 0 to 255
//
// This function returns a single byte from location <addr> in the EEPROM then
// polls the <SMB_BUSY> flag until the read is complete.
//
U8 EEPROM_ByteRead(U8 addr)
{
U8 retval; // Holds the return value
while (SMB_BUSY); // Wait for SMBus to be free.
SMB_BUSY = 1; // Claim SMBus (set to busy)
// Set SMBus ISR parameters
TARGET = EEPROM_ADDR; // Set target slave address
SMB_RW = WRITE; // A random read starts as a write
// then changes to a read after
// the repeated start is sent. The
// ISR handles this switchover if
// the <SMB_RANDOMREAD> bit is set.
SMB_SENDWORDADDR = 1; // Send Word Address after Slave Address
SMB_RANDOMREAD = 1; // Send a START after the word address
SMB_ACKPOLL = 1; // Enable Acknowledge Polling
// Specify the Incoming Data
WORD_ADDR[0] = 0x00; // Set the target address in the
WORD_ADDR[1] = addr; // Set the target address in the
// EEPROM's internal memory space
pSMB_DATA_IN = &retval; // The incoming data pointer points to
// the <retval> variable.
SMB_DATA_LEN = 1; // Specify to ISR that the next transfer
// will contain one data byte
// Initiate SMBus Transfer
SMB0CN_STA = 1;
while(SMB_BUSY); // Wait until data is read
return retval;
}
//-----------------------------------------------------------------------------
// EEPROM_ReadArray ()
//-----------------------------------------------------------------------------
//
// Return Value : None
// Parameters :
// 1) U8* dest_addr - pointer to the array that will be filled
// with the data from the EEPROM
// range is full range of character: 0 to 255
//
// 2) U8 src_addr - beginning address to read data from the EEPROM
// range is full range of character: 0 to 255
//
// 3) U8 len - length of the array to be read from the EEPROM
// range is full range of character: 0 to 255
//
// Reads up to 256 data bytes from the EEPROM slave specified by the
// <EEPROM_ADDR> constant.
//
void EEPROM_ReadArray (U8* dest_addr, U8 src_addr,
U8 len)
{
while (SMB_BUSY); // Wait for SMBus to be free.
SMB_BUSY = 1; // Claim SMBus (set to busy)
// Set SMBus ISR parameters
TARGET = EEPROM_ADDR; // Set target slave address
SMB_RW = WRITE; // A random read starts as a write
// then changes to a read after
// the repeated start is sent. The
// ISR handles this switchover if
// the <SMB_RANDOMREAD> bit is set.
SMB_SENDWORDADDR = 1; // Send Word Address after Slave Address
SMB_RANDOMREAD = 1; // Send a START after the word address
SMB_ACKPOLL = 1; // Enable Acknowledge Polling
// Specify the Incoming Data
WORD_ADDR[0] = 0x00; // Set the target address in the
WORD_ADDR[1] = src_addr; // Set the target address in the
// EEPROM's internal memory space
// Set the the incoming data pointer
pSMB_DATA_IN = (U8*) dest_addr;
SMB_DATA_LEN = len; // Specify to ISR that the next transfer
// will contain <len> data bytes
// Initiate SMBus Transfer
SMB0CN_STA = 1;
while(SMB_BUSY); // Wait until data is read
}
//-----------------------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------------------
Passing external voltage through ADC on EFM8UB1
Hardware: EFM8UB1 SLSTK2000A, BGX 13P SLEXP8027A
We would like to input an analog voltage to the EFM8 starter kit board, pass it through the ADC, send the digital signal serially to the BGX board, which is then sent via bluetooth to a phone.
We are trying to use the temperature sensor example as a baseline to understand the basics on how to do this, but it seems more complicated than we thought.
We have disabled the temperature sensor in REF0CN and set the ADC0MX register to accept input from P1.0.
We think this should allow us to input an analog signal into P1.0, and receive the digitized voltage values on the cellphone. We are able to see values that change with the voltage, but they are way off of what we are actually inputting to the pin. Is there an easier way to display the real voltage values out of the ADC?
Attached is a zip file of our code. We've added comments to clarify what we're trying to do.
Simplicity Studio 4 and Development Kit C8051F340DK
Hi,
How to connect the Development kit type 'C8051F340DK' to Simplicity Studio 4? I tried entering the product name and registering the kit serial number but Simplicity studio 4 wouldn't recognize my development kit.
Thanks!
Possibility to program C8051F MCUs with SiUtil.dll and HEX file content bufered in RAM buffer instead of physical HEX file stored in HDD.
Hello,
We are using the FlashUtil Programmer source code files (compiled under Microsoft Visual Studio) to program the automotive
C8051F MCU chip with HEX file. So far everything works great as long as we feed the SiUtil.dll DownloadCS() function with a first string
parameter (tem3) storing full HDD disk path to existing HEX file as below:
result = DownloadCS(temp3, m_UserCodeErase, g_DisableDialogs, FALSE, nbankNum, m_LockCodeSpace, TRUE, &checkSum);
However now we need to add a firmware code security/encryption feature as follows:
1. We encrypt the original .HEX file with AES algorithm creating new encrypted .AEF file.
2. Then we can decrypt the scrambled .AEF file into RAM memory buffer getting the original .HEX file content.
3. Now we want to feed somehow the SiUtils.dll's DownloadCS() function directly with the decrypted HEX
content localized in memory buffer and NOT from the file in HDD.
At present, we have to create and write the buffer to some temporary file on HDD (in Windows Temp directory) then
get the full path to the temorary file and finally pass the Temp file path to DownloadCS() function.
This is NOT a good solution in terms of firmawe security however.
The questions are:
1. Is it possible to use another Download function from SiUtil.dll which accepts e.g. pointer to memory buffer with Intel HEX file content?
2. If NOT, can you provide us any source code of DownloadCS() that we could modify and compile so that the ne Download function could
be able to read the Intel HEX data from internal memory buffer instead of HDD file?
3. If NOT, could you provide us with some custom modified SiUtil.dll with additional DownloadCS() variation (with different name certainly)
which will accept the pointer to memory buffer containing Intel HEX compatible text string? Probably the extra parameter "StringLength"
will be necessary.
4. If NOT, can you propose any other solution with SiUtil.dll which will allow us to do MCU downloading decrypted Firmware directly from the
memory buffer and avoid creating the real original Intel HEX file on HDD?
The creation of temporary RAM disk in NOT a solution either, because the RAM disk will be visible in the Windows OS to the user and so the
decrypted Firmawe stored in the RAM disk as a file while programming MCU. The only way to securely program the MCU from encrypted
AEF file is to do all the decryption and programming on-the-fly using exclusively RAM memory and NOT touching the HDD at all.
Thank you so much for you valuable support.
Best Regards
Wojek L.
How to transfor C8051F340 USB from Windows to Linux
Hello,
I develop C8051F340 for many years in MS Windows. Now I will transfer Windows's application software to Linux, the software include USB interface,which was developped with USBXpress SDK in windows. I try to search solution in forum, nothing found about F340 USB. So how can I transfer F340 USB software from Windows OS to Linux.
EFM8SB2单片机C2升级问题
现在需要在linux上做EFM8SB2的升级功能，通过C2接口实现，按照AN127技术手册和官方提供的demo程序，完成linux的升级程序，现在程序可以通过C2接口正确的读到device ID（0x16），但是执行擦除整片flash指令时，会失败
log如下：
0x03指令通过log确认可以执行成功，执行到0xDE指令时，POLL IN BUYS 一直返回忙碌状态，无法继续执行
执行此指令之前，已经对cpu 进行halt的动作
该问题一直无法解决，请协助一下，谢谢。
EFM8BB3 logic gate programming
Hello everyone, newbie here, I am trying to program a specific combination of logic gates involving 3 different inputs: A, B and C. to make the following circuit:
so this should be: T=AB'+BC'.
in the Configurator I can set the input pins for both A and B, but not for C:
why is this so? is it a limitation of my MCU? can i still somehow make that logic circuit in my MCU?
any help would be appreciated.
Using Command Line programmer FlashUtilCL.exe
Hi, I am using the FlashUtilCL.exe command line programmer to program EFM8BB10F8G-A-QFN20 MCUs using a USB EC3 debugger. I have found the documentation a bit unclear in some parts so have some questions.
1. The command line readme is dated 2011 but the utildll.exe release notes have updates up to 2017. Is there a newer readme for the command line programmer?
2. Does the downloadusb command include a verify function?
3. When the command succeeds should there be a return code shown? I get no return code for success and if there is an error I get a text description of the error.
4. I have found that if I run the downloadusb command with the lock option I can still run the verifyusb command with no errors. Is this correct?
Thanks
Nick
wait about 30 second with 'Updating symbol information' message
Hello,
Recently I design using EFM8SB2 series .
I use newest IDE tool version , but i have to wait about 30 second with 'Updating symbol information' message after OMF file download.
How to use without no waiting?
Please help.
Thanks
David
RTC interface: why so hard?
EFM8LB1 bootloader problem
I have some problem when i using efm8load.exe download the application to EFM8LB1.
problem as follows：
Sometimes some commands $83 33 ... ... will return? But $07 34 00 00 ... ... always returns "C".
Any suggestions?
Thanks.
iAP2 firmware for iPhone accessorys
we are part of the MFi program and develop an iPhone accessory via the lightning interface. A 8-bit Si Labs MCU should be part of our accessory. Is there any iAP2 software/firmware template we can use to develop our accessory after purchasing the MCUs (Universal Bee Family)?
Best regards,
Erik
UART Bootloader for C8051F120. (AN778)
Hello ,
I am new to the bootloader concept and having trouble to get it to work.
I tried with the bootloader examples in AN778 to "wrap" it to F120.
Has anyone made the bootloader for F120. Just simple one..
EFM8 Busy Bee- Can I put the enum to the XDATA?
How do I put the enum to the XData? Thank you very much.