CH32V003 SPI slave receive only mode

[fulda1]

Hi,

is it possible to configure SPI to work as slave receiver?

I have master with two wires - clock and data. master send 8bit bytes in structure:
idle is low, data are valid on 2md edge, 8bit data.

I would like to use CH32003 as slave for this master.
it seems easy configuration by datasheet: SPI_CTLR1 = 0x06C1. Unfortunately I do not see how to done configuration like this using arduino library.
On the top it seems, that interrupt is not supported at all.

I have few questions as workarounds:

1. how to configure pins to assign them to SPI? (default one)
2. how to configure interrupt assigned to SPI to call my function?

Thank you

R16_SPI_CTLR1	// 0x40013000	SPI Control register1
	0000 0110 1100 0001 = 0x06C1
	                  1: Data sampling starts from the second clock edge.
	                 0: SCK is held low in idle state.
	                0: Configured as a slave device.
	            00 0: FHCLK /2;
	           1: Enable SPI.
	          1: LSB is transmitted first.
	        0: NSS is low.
	       1: Software control of the NSS pins.
	      1: Receive only, simplex mode.
	     0: Use 8-bit data length for sending and receiving.
	   0: Continue to send data from the data register.
	  0: CRC calculation is disabled.
	 0: Disable output, receive only.
	0: Selection of 2-line bi-directional mode.

[maxint-rd]

Unfortunately I have no experience in using SPI in such way. I did some work to make I2C slave work on CH32 and some work to enable interrupt driven Serial, but those are different protocols and I don't know exactly how the implementation of SPI slave would be done precisely. The interrupt functions within the SPI class are currently not implemented. I guess the proper way to implement this would be to implement those functions.

Edit: the original STM32 implementation has the same functions not implemented. The Arduino example at the end of this page uses the attachInterrupt() method to implement slave functionality, so having those functions still seems to be the proper way.

For I2C (and also for Serial) there are interrupt handlers used to process data reception. For SPI there is SPI1_IRQHandler (and for some chips SPI2_IRQHandler), so perhaps you can have a look at the I2C and Serial implementation to see how they do their thing.

The only example I found within the CH32fun project is spi_24L01_rx, but that one uses a loop to continuously receive data.
You can also review the EVT SPI examples. This EVT Example supports slave mode and defines an interrupt handler. Maybe that example gives you enough hints to get something working.

BTW. The default (weak) SPI IRQ handlers are just empty loops.

[fulda1]

Hi,

Let me explain a little. My signal have idle in low, data are valid on falling (2nd) edge of clock. Data are LSB first.
More details (in German language, but time diagram on page 6 is OK)
https://normen.railcommunity.de/RCN-600.pdf

I try to use direct register names and/or that HAL style management. None of them works for me.

For your inspiration, one variant of my *.ino

#define LED_BUILTIN PD6

#define SPI_MISO PC7    // not used
#define SPI_MOSI PC6    // SUSI data
#define SPI_SCK PC5     // SUSI clock
#define SPI_CS PC4     // not used

void initSPI() {
    GPIO_InitTypeDef GPIO_InitStructure={0};
    SPI_InitTypeDef SPI_InitStructure={0};

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init( GPIOC, &GPIO_InitStructure );

    //GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
    //GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    //GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    //GPIO_Init( GPIOC, &GPIO_InitStructure );

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init( GPIOC, &GPIO_InitStructure );

#define SPI_FirstBit_LSB  ((uint16_t)0x0080)

    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
    SPI_InitStructure.SPI_CRCPolynomial = 7;
    SPI_Init( SPI1, &SPI_InitStructure );

    SPI_Cmd( SPI1, ENABLE );

  // SPI_CTLR1 = 0x06C1;
}

void setup() {
  Serial.begin(115200);
  delay(200);
  Serial.println("Welcome");
  initSPI();
  lastmillis = millis() + 1000;
  laststat=SPI1->STATR;
}

void loop() {
  if (millis()>=lastmillis) {
    Serial.println("--timeout--");
    Serial.print("SPI STATR:");
    Serial.println(SPI1->CTLR1);
    Serial.println(lastmillis / 1000);
    lastmillis = millis() + 1000;
  }
  if (SPI_I2S_GetFlagStatus( SPI1, SPI_I2S_FLAG_RXNE ) != RESET ) {
    Serial.println("--CHANGE--");
    laststat=SPI1->STATR;
    Serial.print("SPI STATR:");
    Serial.println(laststat);
    Serial.print("DATA:");
    Serial.println(SPI_I2S_ReceiveData( SPI1 ));
    lastmillis = millis() + 1000;
  }
}

[maxint-rd]

Good illustration of what you're working on.

I try to use direct register names and/or that HAL style management. None of them works for me.

I'm certainly no expert on this, but I've learned past year that most peripherals require a clock to operate. In the EVT example you can see that next to initilization of the various init structures, there is also this call to enable the peripheral clock: RCC_PB2PeriphClockCmd( RCC_PB2Periph_GPIOC | RCC_PB2Periph_SPI1, ENABLE );

It seems like your code is missing that.

[fulda1]

Good illustration of what you're working on.

I try to use direct register names and/or that HAL style management. None of them works for me.

I'm certainly no expert on this, but I've learned past year that most peripherals require a clock to operate. In the EVT example you can see that next to initilization of the various init structures, there is also this call to enable the peripheral clock: RCC_PB2PeriphClockCmd( RCC_PB2Periph_GPIOC | RCC_PB2Periph_SPI1, ENABLE );

It seems like your code is missing that.

Waw, you are right. I forget about that. I'm focused to SPI Clk signal as a clock, but for sure peripheral need some system clock. That make sense. And I must upgrade my library version to last one. In tagged version 1.0.4 function is called RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOC | RCC_APB2Periph_SPI1, ENABLE );

OK, I can compile it now, but it is to late here to start testing and tomorrow I'm all day off. So I will try to test it day after tomorrow.

[maxint-rd]

In tagged version 1.0.4 function is called RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOC | RCC_APB2Periph_SPI1, ENABLE );

Good find! That different function name is probably because the V003 board functions in this Arduino core are based on an earlier version of the SDK. The VM00X (V002/V006/etc) board has the same function name as used in that EVT example. The EVT example is likely based on newer SDK code. The current master still uses those older SDK functions for some boards. I encountered the same when updating my CH32 fork of Adafruit_SleepyDog and had to use board-specific function calls.

But as mentioned earlier, I most definitely recommend you to update to the latest master branch code since it has many useful improvements. Updating shouldn't take too much time.
If you have more time I also suggest you to have a look at the various open PR's that have not been merged yet.

Good luck testing and have fun!

[fulda1]

OK, much better.
For the project "portability" is primary target. Future users must be able to run without tweeking libraries.

Now my latest version:

void initSPI() {
    //GPIO_InitTypeDef GPIO_InitStructure={0};
    SPI_InitTypeDef SPI_InitStructure={0};

    RCC_APB2PeriphClockCmd(  RCC_APB2Periph_SPI1, ENABLE ); // do not forget clock
    pinMode(SPI_SCK,INPUT); // SUSI data
    pinMode(SPI_MOSI,INPUT); // SUSI clock
    //pinMode(SPI_MISO,GPIO_Mode_AF_PP);    // not used
    //pinMode(SPI_CS,INPUT);     // not used

    //GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
    //GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    //GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    //GPIO_Init( GPIOC, &GPIO_InitStructure );


#define SPI_FirstBit_LSB  ((uint16_t)0x0080)

    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_RxOnly;
    SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_LSB;
    SPI_InitStructure.SPI_CRCPolynomial = 7;
    SPI_Init( SPI1, &SPI_InitStructure );

    SPI_Cmd( SPI1, ENABLE );
}

FYI: arduino pinMode enable clock for GPIOC, and it is no necessary at all.
I do not know, if baudrate have some sense.

[maxint-rd]

For the project "portability" is primary target. Future users must be able to run without tweeking libraries.

Yes, that would be nice. However, if you're making a library for users of the CH32 Arduino core, I'm afraid you have to consider the current situation. I see CH32V002 as a successor of the V003 and although code is largely compatible, there currently are some differences to consider. In my version of the Adafruit_SleepyDog library I used board specific constructs like these:

    // enable power interface module clock
#if defined(CH32V00x) || defined(CH32X035)
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
#elif defined(CH32VM00X)
    RCC_PB1PeriphClockCmd(RCC_PB1Periph_PWR, ENABLE);
#else
    //#warning(NOTE: no support for other CH32 mcu) 
#endif

I do not know, if baudrate have some sense.

Sorry, can't offer any experience in that area. Usually the slave device just tries to follow the master clock speed up until a specified maximum. The I2C protocol uses fixed speeds such as 100kHz and 400kHz, but they can vary a bit and there even is a specification for clock-stretching, but that's not always supported. I figured that out when making my TinySoftWire library, a bit-banging I2C library to make peripherals using ATtiny13A and similar MCUs.

I'm looking forward to see your final version and test results. Good luck!

[fulda1]

OK, last part I do not see in SPI is interrupt. It seems, that some definition is done in startup file:
https://github.com/openwch/arduino_core_ch32/blob/main/system/CH32V00x/SRC/Startup/startup_ch32v00x.S#L52C10-L52C38
Function SPI1_IRQHandler is registered, but cannot see it elsewhere used.
Is my understanding correct, that I must declare function by this name and it will automatically become interrupt handler?
Of course must enable interrupt execution etc.?

[maxint-rd]

That definition in the startup file is the weak default handler. All it implements is an empty loop. Weak means that you can override it with your own implementation.

In the EVT example you can see enabling of the RX interrupt on line 114 (with init-structure definition just before). The actual handler implementation starts at lin 185.

That EVT example was the only interrupt driven SPI slave example I could find. If you find another one, feel free to post a link here.

BTW. Having those default handlers in the .S startup assembly prevents LTO to work. In PR #215 this is fixed by moving them to a .c file.