Code Examples Forum Discussions

Hi,

I've just written my first sample program for XENSIV PAS CO2 Shield2Go for CY8CKIT-044.

Shematic

Pins

Tera Term logs

When the program starts, current command menu is shown.

At this stage, the sensor is in "idle mode"
To see the configuration settings, enter "status" command.

Then each status(es) are shown.
Measurement Rate is set to 5 sec, as the default value of 60 was too large for testing 😉
Entering "run" to the prompt start continous sensing.

I blew my breath to the sensor after 5 measurement,
so the co2 ppm rose  there.

After running a while, I entered "stop" command,
which will change the mode to "idle", and the prompt will be shown again.
Entering "help" shows the command again.

moto
(edited) typo fix 

Hi,

Last week, I posted a version for PSoC 4

https://community.infineon.com/t5/Code-Examples/SSD1306-I2C-OLED-128x64-PSoC-4-CY8C4146LQI-S433/td-p/389093

And here is a version for PSoC 5LP (CY8CKIT-059)

At first I was thinking that only a few changes will be required...
but I was wrong my i2c_utility for PSoC 5LP needed a lot of fixes... orz

Tera Term log

Schematic

Pins

moto

Here is the C# source code to a terminal program for a Windows PC.

Minimum System Requirements:

• Windows 7.  A lower version may work but has not been tested.
• C# Compiler.  I have compiled this on both Visual C# 2017 and 2019.

This code started as a simple PSoC UART (remote) to PC terminal application to replace Teraterm, Termite, RealTerm, etc.

I did this to eventually enhance the UART comm capabilities to include features such as

• Data logging (appending to a .csv file)
• Data Plotting.  This includes saving the plots as a .png file or .csv.

This code has those features built in by using my packetizing protocol.

Disclaimer

You are allowed to use this source code “at-will” for commercial or non-commercial purposes. I DO NOT state or imply any warranty for the use of this code in-whole or in-part.

I've attached an archive of the source code and a .pdf that describes the use and the packetizing protocol.

Len

Message was edited by: Len Removed bin and obj directories. Makes for a smaller .zip. Will be rebuilt when compiled.

Hi,

As I saw a discussion about this device

https://community.infineon.com/t5/PSoC-4/How-to-connect-an-Oled-to-CY8CKIT-041-41XX/td-p/386950

I purchased a 3 piece set from Amazon.

Since I did not have (or could not find) CY8CKIT-041-41XX, 
I used TSoC (CY8C4146LQI-S433) board.

Schematic

Pins

When started, monitor of starting sequence and first help message is shown in the UART (Tera Term)

To display the test pattern, Enter "TestPatern" to the prompt.

void do_test_pattern(void)
{
    char *ptr ;
    do_clear_display() ;
    ssd1306_fillrect(15, 10, 115, 20) ;
    ssd1306_set_color(SSD1306_BLACK) ;
    ssd1306_text_x = 16 ;
    ssd1306_text_y = 11 ;
    draw_string("SSD1306 I2C OLED") ;
    ssd1306_set_color(SSD1306_WHITE) ;
    ssd1306_line(10, 25, 120, 25) ;
    ssd1306_text_x = 28 ;
    ssd1306_text_y = 30 ;
    draw_string("PSoC Version") ;
    ssd1306_line(20, 40, 40, 60) ;
    ssd1306_line(20, 60, 40, 40) ;
    ssd1306_fillrect(50, 40, 70, 60) ;
    ssd1306_circle(90, 50, 10) ;
    
}

I'm afraid that I have not tested all the functionalies, but it seems that most of the basic functions are working.

moto

Hi all,

I make a CE which I2S in PSoC6 for CM4. This is a simple loop back program using DMA.

The environment used is as follows:

・PSoC Creator 4.4

・CY8CKIT-062-BLE

・I2S format: 24bits, 2words（Channels）, 1bit Delay

The circuit：

DMA Settings：

For Tx

For Rx

The observed waves and Rx buffer values:

Thanks,

Kenshow

Update main_cm4.c file in 2020/Dec/14

Hi all,

[Question]
I have a question about a “user_nvm_write()“ function of Firmware API.
When I programed 10 bytes of Data Flash using the “user_nvm_write()“ function,
remaining data(128-10=118byts) of the 1 page was programmed by 0xFF,
even if the erase value is 0x00.

I checked “Firmware User Manual (AE-step) Revision 1.02”, but I couldn’t find out
an explanation that unprogramed area will be programmed by 0xFF.
Do you know the reason why 0xFF will be programmed? Is this normal operation?

You can reproduce this result by the following my sample software, easily.
If my usage is not correct, please let me know about that.

Thank you.

=====================================
[Software Overview]
This code is a sample code to execute a "user_nvm_write()" and "user_nvm_page_erase()" of
the Firmware API commands.
And, this code is based on a "UART2_TTY_EXAMPLE_TLE984x" sample code.
refer to the following URL for more detail.
"https://community.infineon.com/t5/Code-Examples/UART2-sample-code-for-TLE984x/td-p/357169

[Confirmed environment of this software]
IDE = uVision ver 5.36.0.0
Board = TLE984x_Evalboard, TLE9844_Appkit
Terminal software = TeraTerm v4.99

[Usage of this software]
1, Program this software into the TLE984x of the evaluation board
2, Connect your PC and an evaluation board by USB cable
3, Lunch a terminal software and set 115200bps
4, RESET your evaluation board, then terminal software shows as the below.
Please press any key between 1~4 whitch you want.
------------------------------------
*** Menu ***
Key=1: Dump D-Flash (0x1100F000~, 128+16byte)
Key=2: Prog 10byte D-Flash (0x1100F000 = 0x30,0x31,0x32...0x39)
Key=3: Prog 5byte D-Flash (0x1100F000 = 0x00,0x01,0x02...0x04)
Key=4: PageErase D-Flash (0x1100F000~, 128byte)
------------------------------------

[Execution image]

Key 1 and 2

Key 3 and 4

Thank you.
Hiro.

Hi,

About a month ago, there was a discussion asking how to modify the sample of Lesson 9 of PSoC 101.

https://community.infineon.com/t5/PSoC-4/PSoC-101-Lesson-9-Timer-Example/m-p/382634#M43753

The poster's intention seemed to be using a Timer to distinct a short push and a long push for different functions or actions.

Although a Timer can have such capability, for making it more flexible, I suggested to use SysTick,

which also saves a Timer for other usage.

Although CY8CKIT-042 has 2 switches, SW1 is dedicated for RESET, so only SW2 is available for the user function.

This time the poster wanted to have a short push, and a long push of the button.

With a short push, a function will be called immediately and with a long push (or keep pushing),

another function will be called repeatedly in a certain interval.

We could have "Single Click", "Double Clicks", "Triple Clicks"..., too, but let save it for another day 😉

Now, the schematic

Pin_Switch (an input pin with dedicated interrupt)

Pins (Pin assignment)

Tera Term log

At first I pushed the button twice, then pushed and kept for a while.

Then pushed the button three times, then pushed and kept for while, again.

main.c

#include <project.h>
#include <stdio.h>

#define MAX_SW2_DURATION_MS 10000
#define SW2_SHORT_THRESHOLD 1000

volatile long sw2_duration  = -1 ;
volatile int  sw2_short_flag = 0 ;
volatile int  sw2_long_flag  = 0 ;
volatile int  sw2_held       = 0 ;
volatile long sw2_sec_count  = 0 ;
volatile long sw2_short_threshold = SW2_SHORT_THRESHOLD ; // New

/* print related utilities */
#define STR_LEN 64
char str[STR_LEN+1] ;

void print(char *str)
{
    UART_UartPutString(str) ;    
}

void cls(void)
{
    print("\033c") ; /* reset */
    CyDelay(100) ;
    print("\033[2J") ; /* clear screen */
    CyDelay(100) ;
}

void splash(char *title)
{
    cls() ;
    if (title && *title) {
        print(title) ;
        print(" ") ;
    }
    snprintf(str, STR_LEN, "(%s %s)\n\r", __DATE__, __TIME__) ;
    print(str) ;
}

/* SysTick related functions */
volatile uint32_t tick_count = 0 ;

void set_short_threshold(long new_value) // New
{
    sw2_short_threshold = new_value ;
}

CY_ISR(tick_callback)
{
    tick_count++ ;
    
    if (sw2_duration >= 0) { // if sw2_duration < 0, this stops
        sw2_duration++ ;
        if (sw2_duration >= sw2_short_threshold) { 
            sw2_long_flag = 1 ;
            sw2_held      = 1 ;
            sw2_duration  = 0 ;
        }
    }
}

int find_empty_slot(void)
{
    int result = -1 ;
    uint32_t i ;
    for (i = 0 ; i < CY_SYS_SYST_NUM_OF_CALLBACKS ; i++ ) {
        if (CySysTickGetCallback(i) == NULL) {
            result = i ;
            break ;
        }
    }
    return(result) ;
}

void start_sys_tick_timer(void)
{
    int sys_tick_slot = 0 ;

    sys_tick_slot = find_empty_slot() ;
    if (sys_tick_slot < 0) {
        print("Sorry No empty SysTick Slot available\n\r") ;
        while(1) { } /* halting here */
    } else {
        CySysTickStart() ;
        CySysTickSetCallback(sys_tick_slot, tick_callback) ;
    }
}

CY_ISR(sw2_isr)
{
    Pin_Switch_ClearInterrupt() ;
    if (Pin_Switch_Read()) { /* SW2=High -> released */
        if (sw2_held == 0) {
            sw2_short_flag = 1 ;
        }
        sw2_sec_count = 0 ;
        sw2_held      = 0 ;
        sw2_duration  = -1 ;
    } else { /* SW2=Low -> pushed */
        sw2_duration = 0 ;
    }
}

void init_hardware(void)
{
    /* Enable global interrupts. */
	CyGlobalIntEnable; 
    
    start_sys_tick_timer() ;
    
    sw2_int_ClearPending() ;
    sw2_int_StartEx(sw2_isr) ;
    
    UART_Start() ;
    splash("button double assing test") ;
}

int main(void)
{
    init_hardware() ;
    
    set_short_threshold(1500) ; // now 1.5 sec is the threshold
    
    for(;;)
    {
        if (sw2_short_flag) {
            sw2_short_flag = 0 ;
            print("Button Pushed!\n\r") ;
        }
        if (sw2_long_flag) {
            sw2_long_flag = 0 ;
            sw2_sec_count++   ;
            snprintf(str, STR_LEN, "%ld\n\r", sw2_sec_count) ;
            print(str) ;
        }
    }
}

At the bottom of the previous discussion, 
@Michael_K -san, asked a couple of questions, but as I could not reply to the discussion, let me try to reply here.

(Q1) Is it not possible to replace sw2_duration in the SysTick callback with the tick_count and reset tick_count after SW2_SHORT_TRESHOLD is reached?

I think it is possible, but if we want to use tick_count for other time measure(s),

I'd rather use dedicated variable to keep track of one purpose.

(Q2) And why does sw2_duration have the value -1 in the ISR?

In this example, I assigned three mode(s) on sw2_duration

-1 or negative number:

Counter for SW2 is inactive.

So nothing will be done in the ISR.

0 to sw2 duration: SW2 is in short or first pushed state

If SW2 is released during this state, it will be taken as sw2_short_flag.

sw2 duration or longer : SW2 is in long push state

While in this mode, function for sw2_long_flag is set repeatedly.

BTW, I did not care about overflow of the counter, since long can hold rather large value,

I thought not many will try to keep holding the button for such a long time (more than 20 days!)

moto

PSoC5LP Sigrok Mini Logic Analyzer
(50 MSPS sampling, for short length signals of about 0.5 to 1 ms)

Introduction:
In search for a basic low-end logic analyzer, I came across this wonderful free and open source Sigrok software tool that seems to support many hardware boards by various manufacturers, and that has a lot of Protocol Decoders. The below article shows how to use it with FX2LP based hardware board:

Cypress EZ-USB FX2LP-based Logic Analyzer using Open Source Sigrok
PulseView - KBA229176

https://community.cypress.com/t5/Knowledge-Base-Articles/Cypress-EZ-USB-FX2LP-based-Logic-Analyzer-using-Open-Source/ta-p/252866

and FX3:

https://community.infineon.com/t5/Knowledge-Base-Articles/EZ-USB-FX3-Explorer-kit-as-16-channel-100-MHz-logic-analyzer-with-sigrok/ta-p/283993

Trying to use the Sigrok software with PSoC5LP, I also stumbled across a nice ready PSoC Creator project in Github by MinatsuT !!

https://github.com/MinatsuT/PSoC5_USB_LogicAnalyzer

It mentions the below limitation "Maximum capturing frequency is 250kHz. This limitation comes from the bandwidth of USB Full Speed (12Mbps)."

But for some measurement and test applications, it may be sufficient to just capture a short finite length digital signal (ie, it does not have to be continuous data streaming). For this, if the RAM memory in the chip itself is sufficient(for example there is up to 64KB RAM in PSoC5LP devices), then we can consider options to capture digital signals at relatively higher sampling rates as supported by the chip, just dumping all the captured data to the RAM during the time critical capturing duration(in the order of uS), and then let the chip leisurely send the data to a PC over USB or other communication interface at a relatively slower rate (in the order of mS or seconds).

The attached project takes advantage of the "multi-spoke DMA architecture" present in PSoC5LP device to directly move the data from the port pins to RAM buffers at the maximum possible rates supported by the chip. For example, with the bus clock running at 48 MHz, this multi-spoke DMA can be configured to move 1 byte of port data to RAM every bus clock cycle.

Applications:
For those who already have a Kitprog board such as CY8CKIT-042, or other boards with Kitprog, it may double up as a small logic analyzer. Or the project may be ported to CY8CKIT-059. It may be useful for universities, students/amateur engineers, work-from-home, or field engineers for performing basic digital signal viewing tests such as:
- Checking if a KHz/Mhz clock is oscillating at the expected frequency
- Checking if an ADC EOC(End of Conversion) signal is coming out right
- Pulse widths in the order of a few 10s of nano-seconds etc

It may also be used to create custom-triggers (using the UDB PLDs/datapaths etc) to capture a bunch of signals when an unexpected event occurs.

Some Known Issues and Limitations:

1) The first few bus clock cycles (about 4-5) following the capture event would not be captured and would be missed, as the DMA needs to "warm up", ie, a few overhead clock cycles are required between the DMA request and the actual data being transferred by DMA(due to DMA state machine phases such as arbitration etc). So for applications that are critically looking at events that happen within about the first 1 uS following the capture event, this approach of using the PSoC5LP as Logic Analyzer may not be useful. (Only after these first few bus clock cycles, the DMA will be able to transfer 1 byte of data per bus clock cycle, from the Port register to RAM.)

2) During the critical capture duration (less than 1 ms at 48 MSPS), the DMA might hog the complete 100% bus bandwidth, and CPU might not be able to operate. Other hardware blocks should be able to operate.

Hardware:

CY8CKIT-042, Jumper wires

Software:

PulseView from Sigrok:

https://sigrok.org/wiki/Downloads

PSoC Creator 4.4

Projects:

1) Main project for PSoC5LP-Kitprog on CY8CKIT-042. This will act as the mini-Logic Analyzer. This is a bootloadable project that will replace the Kitprog firmware (Programmer/Debugger/I2C Bridge etc) on the CY8CKIT-042. This has a “.cyacd” file that will be bootloader to the PSoC5LP device.
2) Optional PSoC4 based test project (that uses the PSoC4 device on the same CY8CKIT-042) to feed test input signals such as Clock, PWM, ADC EOC pulses, SPI. This has a .hex file that will be programmed to the PSoC4 device.
Note: Should be directly feasible to use the main PSoC5LP project on other boards that use same Kitprog. Other Kitprogs(such as Kitprog2) may need some modifications.

Attachments:

1) PSoC5LP project
2) PSoC4 test project
3) Test Procedure document, with driver binding screenshots (using a "Zadig" tool that comes with PulseView)
4) The direct PSoC5LP cyacd file and PSoC4 test hex file are also attached as a zip file for quick access.
5) The original 16-Channel PSoC5LP Logic Analyzer(for CY8CKIT-059) from GitHub by MinatsuT, for continuous streaming of data at about 250 KSPS. Note that a micro-USB cable needs to be connected to CY8CKIT-059.

Some other PulseView Screenshots are also attached.

Note regarding sampling frequency:

The sampling frequency is fixed at 50 MHz for now (ignoring whatever setting is made at the PulseView frequency setting).

However, if the PulseView frequency setting is set to 50 KHz, then the timing values as calculated by PulseView provides the correct frequency number of the signal. But the units are 1000x slower than the actual signal So, if a frequency is seen as "1 KHz" it has to be interpreted as "1 MHz", and if a pulse timing is seen as "5 ms", it has to be interpreted as "5 uS", and so on.

(This setting has been made because there seems to be some issue with the 48 MHz frequency setting in the PulseView, so an approximate closer value for quick readability is chosen for now, the PLL in the device is set to 50 MHz. Hence the MHz - KHz variation)

For UART, the baud rate has to be divided by 1000, and fed in the UART protocol decoder in PulseView. For example, when using 115200 baud rate, it has to be entered as just 115. And only a few bytes can be viewed because hardly 1 ms of data would be captured. So instead, for UART and slower protocols, the continuous logic analyzer firmware(with ~250 ksps sample rate) can be used. Or, if the speed needs to be somewhat faster than that, this project needs to be modified to use slower bus clock values than 50 MHz, so that few more milliseconds of captured data can be viewed.

PulseView screenshots:

Clocks ScreenshotADC EOC Pulses Screenshot

Notes on PulseView:

For timing decoder, change the ‘Edges to check” to “Rising” (by default it is at “Any”, which would show double the frequency of a clock. 
The dark theme can be selected in:
 PulseView settings - > General -> User Interface Theme “QDarkStyleSheet”