Hello,

I would like to interface EFM8 universal bee with a PC under Windows.
Silicon labs use library usbxpress. Why not.

I downloaded install_USBXpress_SDK v6.7.2 which contains a driver for Windows
and two examples for the host (FileTransfer and TestPanel).
Unfortunately examples for the devices are only for C8051xxx, not EFM8.

SimplicityStudio (v3.3) contains example EFM8UB1_USBXpress_Echo for
EFM8UB1 but nothing for the host.

If I use TestPanel from USBXPRESS_SDK V6.7.2 with a device loaded with
EFM8UB1_USBXpress_Echo I have a message
"Error openning device. Aborting application. Reset hardware and try again"

Anyone have a working application with EFM8UB1, usbxpress and Windows ?

Could you provide the source code of the efm8ub1_usbxpress.lib ?, I tried to make it run in Keil uvision, but it failed and obviously nobody in the forum or expert can provide me with a running lib file or project file for uvision, so I would try to make it myself.

Best Regards

Ralf

A Generic USB HID device that defines several input-type reports (with different report IDs). The largest report size is 64 bytes.

When hiddevice_getInputreport_interrupt () is called to read the report from the device, for some reason the number of bytes returned is always 64 bytes, the maximum report size;Obviously the report size from the device to the host is not 64 bytes, but smaller report size like 45 bytes...

Thanks!

uzslm

I want to load multiple applications into my  EFM8LB1. This is for a production product.

The program at 0x0FA00 will be a bootloader that decides whether to run the application in partition A or B. These are as follows:

Partition A will be the backup application that is field-tested and guaranteed to work. Partition B will be the beta application

The bootloader should run the program in partition B. if B application has faults; so I switch A. So my question is how to place the three separate applications (bootloader/A/B) at separate areas in flash. I find out a document https://www.keil.com/appnotes/files/apnt_104.pdf ; but I don't know how to configure it into simplicity INTERRUPT VECTOR ADDRESS and LOCATING PROGRAM CODE

Question2: I read somewhere that the address of the reset vector is fixed at 0x0000 by hardware so we can not change it;  But in the above document, I can change it. Could you guys let me know which is true. Thank you so much!

Does anybody has a working uvision Project File with the EFM8UB1 like Test Panel?

Thanx Ralf

I'm preparing some curriculum changes to my university's embedded microcontrollers class, and I'd like to hand out custom EFM8BB1-based boards that have a snap-off F326-based debugger, as I think the Silicon Labs EFM8 ecosystem has much better alignment with the learning outcomes of the course when compared to our existing Arduino-based curriculum.

I'm using the schematics in the ToolStick manual as a reference to designing this board, but I can't seem to locate the hex file that lives on the F326-based debugger. From other posts, it's clear that the source code is unavailable for this, but I would think the firmware hex would be freely downloadable (especially since another post mentions MCUs can be purchased with this firmware pre-programmed).

Where can I find this hex file?

Hello,

I am trying to read via JTAG from the integrated flash memory of a C8051F047 controller. It does not work as it should (data seems invalid). Reading from IDCODE works without any problems. I follow the process described in AN105.

a) AN105 is not applicable for F047, but for F00X, F01X, 02X. The description in the datasheet is identical. Can anyone confirm that the procedures are also applicable for F047? If not, can someone provide me information about the right procedure?

b) F047 is missing the FLASHSCL register. Is the configuration of this register necessary and if so how can it be replaced?

c) Is there any ready software to read out the memory? I currently use a Python script in combination with UrJTAG

Kind regards

Hi,

Is there a command line script for recording microcontrollers through the C2 interface, just as it is done with the UART bootloader (an945)?

My intention is to carry out the same process that is done with the MCUProductionProgrammer, however I need to record more than one microcontroller at once.

Thanks

I have noticed a timer/uart bug in my program where the baud rate on the uart is wrong in some cases.

This is the baseline program that i have tested on:

void main(void)
{
	uint8_t buffer[10] = {85, 85, 85, 85, 85, 85, 85, 85, 85, 85};
	
	// Disable Watchdog timer
	PCA0MD &= ~0x40;

	// Disable precision oscillator bias. Save 80uA in non-sleep modes
	REG0CN &= ~0x10; // OSCBIAS = 0

	// Disable global interrupts
	EA = 0;

	// Initialize the hardware
	PORT_Initialize();
	CLK_InitializeRTC_LFO(heartbeat);
	UART_Initialize();

	// Initialize low power internal oscillator, 10MHz
	CLKSEL = 0x14;
	// Verify that the system clock settings has been applied
	while (!(CLKSEL & 0x80));


	while(1)
	{
		// Display serial number on LED
		//BlinkSerialNumber(sensoraddress);

		//Waitms(400);

		UART_Send(buffer, 1);

		//Waitms(400);

		// Sleep.. zZz.. zZz.. zZz..
		//Sleep();
	}
}

This works as expected, with only UART sending the value 85 constantly.
But if i uncomment the Waitms(400) function before or after sending the UART byte, the output seems logically correct on the scope, but the baudrate becomes half. But if i change the UART function to send more than one byte from the buffer, the baudrate becomes correct again without changing anything else.. Uart and Waitms uses separate timers, so i don't know why this would happen.
 

Test number two: If i uncomment the BlinkSerialNumber() and the first Waitms(), the UART functions works fine sending one byte, but if i uncomment the second Waitms() function, the baudrate is wrong again.
 

Some other test:
It works with Sleep() and send one byte
It does not work with Send - Wait - Sleep
It does not work with Send - Sleep - Blink

What could be the issue with the timing?

These are my functions used:
 

void UART_Initialize(void)
{
	// Make P0.4(TX) and P0.5(RX) digital ports
	P0MDIN |= 0x30;

	// Make P0.4(TX) push-pull and P0.5(RX) open-drain
	P0MDOUT |= 0x10;
	P0MDOUT &= ~0x20;

	// Make sure the pins are not skipped on Crossbar
	P0SKIP &= ~0x30;

	// Enable UART0 on Crossbar
	XBR0 |= 0x01;

	// 8-bit variable bit rate
	// level of STOP bit is ignored
	// RX enabled
	// ninth bits are zeros
	// clear RI0 and TI0 bits
	SCON0 = 0x10;

	if (UART_SYSCLK/UART_BAUDRATE/2/256 < 1)
	{
		TH1 = -(UART_SYSCLK/UART_BAUDRATE/2);
		CKCON &= ~0x0B; // T1M = 1; SCA1:0 = xx
		CKCON |= 0x08;
	}
	else if (UART_SYSCLK/UART_BAUDRATE/2/256 < 4)
	{
		TH1 = -(UART_SYSCLK/UART_BAUDRATE/2/4);
		CKCON &= ~0x0B; // T1M = 0; SCA1:0 = 01
		CKCON |= 0x01;
	}
	else if (UART_SYSCLK/UART_BAUDRATE/2/256 < 12)
	{
		TH1 = -(UART_SYSCLK/UART_BAUDRATE/2/12);
		CKCON &= ~0x0B; // T1M = 0; SCA1:0 = 00
	}
	else
	{
		TH1 = -(UART_SYSCLK/UART_BAUDRATE/2/48);
		CKCON &= ~0x0B; // T1M = 0; SCA1:0 = 10
		CKCON |= 0x02;
	}

	// Init Timer1
	TL1 = TH1;

	// Timer1 enabled when TR1 = 1 irrespective of INT1 logic level
	// Timer1 incremented by clock defined by TM1 bit in register CKCON
	// Timer1 Mode2 - 8-bit Counter/timer with Auto-Reload
	TMOD &= ~0xF0;
	TMOD |= 0x20;

	// Start Timer1
	TR1 = 1;
	// Indicate TX0 ready
	TI0 = 1;
}

void UART_Send(uint8_t *buffer, uint8_t num)
{
	uint8_t restore_CLKSEL;
	restore_CLKSEL = CLKSEL;
	
	// Initialize low power internal oscillator, 20MHz
	CLKSEL = 0x04;
	// Verify that the system clock settings has been applied
	while (!(CLKSEL & 0x80));
	
	while (num--)
	{
		SBUF0 = *buffer++;
		while (!TI0); // Wait until TX
		TI0 = 0;
	}

	// Restore clock settings
	CLKSEL = restore_CLKSEL;
	// Verify that the system clock setting has been applied
	while (!(CLKSEL & 0x80));
}

void Waitms(uint16_t duration_ms)
{
	uint8_t restore_CKCON;
	uint8_t restore_CLKSEL;
	uint16_t i;

	// Save CKCON and CLKSEL state
	restore_CKCON = CKCON;
	restore_CLKSEL = CLKSEL;
	// Set sysclk to low power internal oscillator, 10MHz
	CLKSEL = 0x14;
	// Verify that the system clock settings has been applied
	while (!(CLKSEL & 0x80));

	// Timer2 high and low byte uses sysclk
	CKCON |= 0x30;

	// sysclk = 0.1us * 10000 = 1ms
	TMR2RLH = 0xD8;
	TMR2RLL = 0xEF;

	// Timer2 enabled
	TMR2CN |= 0x04;

	for (i = 0; i < duration_ms; i++)
	{
		while (!(TMR2CN & 0x80)); // Wait for overflow
		TMR2CN &= ~0x80; // Overflow flag cleared
	}

	// Overflow flag cleared
	TMR2CN &= ~0x80;
	// Timer2 disabled
	TMR2CN &= ~0x04;

	// Restore CKCON and CLKSEL state
	CKCON = restore_CKCON;
	CLKSEL = restore_CLKSEL;
	// Verify that the system clock settings has been applied
	while (!(CLKSEL & 0x80));	
}

void CLK_InitializeRTC_LFO(uint32_t alarm)
{
	// If the interface is locked
	if (RTC0KEY == 0x00)
	{ // Unlock the interface
		RTC0KEY = 0xA5;
		RTC0KEY = 0xF1;
	}

	// Enable low frequency oscillator
	CLK_RTCWrite(RTC0XCN, 0x08);

	// Enable smaRTClock oscillator
	CLK_RTCWrite(RTC0CN, 0x80);

	// Clear the clock fail flag (precautionary)
	CLK_RTCWrite(RTC0CN, 0xC0);
	
	// Clear PMU wake-up source flags
	PMU0CF |= 0x20;

	// Reset smaRTClock timer
	CLK_RTCWrite(CAPTURE0, 0x00);
	CLK_RTCWrite(CAPTURE1, 0x00);
	CLK_RTCWrite(CAPTURE2, 0x00);
	CLK_RTCWrite(CAPTURE3, 0x00);

	// Write '1' to RTC0SET
	CLK_RTCWrite(RTC0CN, 0xC2);
	// Wait for RTC0SET -> 0
	while (CLK_RTCRead(RTC0CN) & 0x02);

	// Write the value to the alarm registers
	CLK_RTCWrite(ALARM0, ((alarm >> 0) & 0xFF));
	CLK_RTCWrite(ALARM1, ((alarm >> 8) & 0xFF));
	CLK_RTCWrite(ALARM2, ((alarm >> 16) & 0xFF));
	CLK_RTCWrite(ALARM3, ((alarm >> 24) & 0xFF));

	// Enable timer run, alarm and auto reset
	CLK_RTCWrite(RTC0CN, 0xDC);

	// Clear the PMU0CF wake-up source flags
	PMU0CF |= 0x20;

	// Enable RTC alarm interrupt
	EIE1 = 0x02;
}

void Sleep(void)
{
	uint8_t restore_CLKSEL;
	restore_CLKSEL = CLKSEL;
	
	// Per datasheet p.163, the clock divide needs to be '1' before sleep
	// Initialize low power internal oscillator, 20MHz
	CLKSEL = 0x04;
	// Verify that the system clock settings has been applied
	while (!(CLKSEL & 0x80));

	// Clear all wake-up flags
	PMU0CF |= 0x20;

	// ~~~ Device in low power mode ~~~
	PMU0CF = 0x84; // Sleep mode with smaRTClock alarm wake-up
	NOP();
	NOP();
	// ~~~ Device is now awake ~~~

	// Clear all wake-up flags
	PMU0CF |= 0x20;

	// Restore clock settings
	CLKSEL = restore_CLKSEL;
	// Verify that the system clock setting has been applied
	while (!(CLKSEL & 0x80));
}

utility of smbus in SI DIRECT RX

Hello on the SI1062 card, I tried to write a code which generates an interrupt when timer 0 overflows, in the interrupt routine I initialize the timer and I reset, but when the compiler arrives at the routine of interrupt after executing the interrupt routine it remains blocked in the void vSmbus_SMBusStop () function. how is it possible to avoid this please? I am a beginner and having read the datasheet I did not understand the usefulness of SMBUS;

2nd question Is it possible on the SI1062 To set the  timer0  clock  to 1MHZ?

Below is a link to a video of two calculators I built, one using a C8051F020 and LCD and more recently another using a C8051F120 and GLCD:

https://www.youtube.com/watch?v=p7MBGPf2i6E

For the C8051F020 I wrote the code in C and used the floating point library.

For the C8051F120 I wrote the code in assembly with routines to add, subtract, multiply and divide two 16-bit integers. I am now writing a C version of this calculator and would like to implement floating-point/fixed-point and eventually create a scientific calculator that does powers, trigonometric functions etc.

This is a hobby project and I want to write all of the routines and not depend on libraries. I have read Clive Maxfield's excellent "How computers do math" that explains integer math and am now looking for material on floating-point/fixed-point routines. Anyone recommend anything in particular?

Howdy folks.  Long time SiLabs user here that has hit an unusual problem.

It started with my Busy Bee BRDF5101A development board we were using for cap sense evaluation of EFM8SB1 parts.  I began with the "Capsense No Overlay Demo" and completely evaluated that functionality without incident.  Then, I disconnected the overlay and began developing some code to drive WS2812 LEDs off SPI_CS, which didn't seem to be connected to anything critical and was easily accessible on the header.  My development board had nothing much connected externally, just my SALAE Logic analyzer and the USB Cable for power/debug.  I wasn't seeing the GPIO toggling at a fast enough speed and was trying some different methods of bit-banging it when suddenly the board just up and died.  The JLink on it is fine, but the MCU is totally dead.

Well ok, that was a problem... but my actual boards with EFM8SBs just arrived and so I started to bring them up.  The hardware implementation is essentially 3.3V VCC, GND, the C2 interface to an external J-link, and a bunch of ESD-protected, floating I/O going to headers...  The peripheral boards that connect to those headers are still being assembled.  So I was probing P1.6 with an oscilloscope to see if I could work out an effective bit-banging routine.  The pin had a 40us rise time so something wasn't configured right.  I was loading and debugging code when suddenly it wouldn't execute past PC counter 0, which is C? STARTUP.  It programs, and never gets to main(). 

So I grabbed the next board and began testing on that.  Following good ESD protocols, only my Tek scope connected and I quickly verified the 3.3V provided by an LDO was nice and stable.  Apparently the HWConfig pin configurator had something going strange...  P1.6 was configured as a push pull output with high drive capability, but the InitDevices.c had an extra line after the Port1 Mode initialization, where Port0 Mode initialization was getting shoved into the Port1 register and overriding it.  Yuck.. not sure what was up with that, but I fixed it and saw the 20ns rise times I was expecting.  

The WS2812 requires a very precise waveform, difficult to obtain via bit-banging, so I rewrote the code to more closely match a library capable of running on a much slower AVR part.  This particular approach manually unrolls the loops and uses #defines with bunches of _nop_() instructions.  I compiled, ran, and boom... CPU is dead again.  Won't get off PC counter 0.   The pin actually seems permanently stuck at 1.6V, outputting a faint square-like wave at +/- 20mV.  

I rebooted, repowered, checked all connections.  Created a new Blinky() example project to try... and all boards continue to exhibit the same problem.  Blinky ran on a fresh board momentarily (I shut it off quickly just in case) so my development environment or setup doesn't appear to be to blame.  

So this is kind of a mystery.  The stable VCC rail and lack of any meaningful circuitry connected to the pins leads me to believe something in the code is killing the parts.  Perhaps the pin configurator has more wrong with it than I found via inspection.  But I've worked with every manner of MCU have can't say I've ever killed a part via misconfiguring a floating pin's mode.  

SiLabs Commander has never wanted to properly detect or connect to these parts via a J-link.  Normally on another brand of ARM I'd use the vendor Flash tool or JFlash to inspect/change any problematic option bytes or just nuke the thing back to defaults.  Any ideas on what I could use to do that here?  Is it possible some option bytes got hosed?  

Alternatively, does it seem plausible a misconfigured pin could damage the part in such a way it can erase, program and start to run but fail to advance its instructions?

Finally, could this be related to the capsense churning away on floating pins?   Every I/O is ESD protected with diodes, and the scope was just connected sitting there.  But perhaps it is ultra sensitive or exposes the pins in a less protected manner. 

My stock of EFM8s is low and lead times are horrible.  Tomorrow I was going to take a new board w/ Blinky and just strip it to a single pin outputting a square wave and see if it could run all day without blowing.  I don't have many more shots to get this right should would appreciate any insight folks can come up with!