PSoC 6 MCU

I'm using a CY8C6137 PSoC 6 connected via I2C to a device using clock stretching. The PSoC 6 is the master and the device the slave. Clock stretching is done between the data and the acknowledge.

When the device transmits it holds the SCL line low after the 8th bit while it prepares the next byte, releases the SCL line and then reads the ACK bit from the PSoC 6. When the device receives, it holds the SCL line low after it receives the 8th bit then sends ACK or NACK.

How is I2C clock stretching handled in the PSoC 6? It's no problem if basic APIs need to be modified as I already have done so for other purposes.

Hi Everyone,

A few weeks ago I posted a message here complaining that Cy_TCPM_Counter_SetPeriod() is not behaving as documented. In my application I need to dynamically change the period of a counter anywhere from 1 to 400 Hz to generate a periodic interrupt that will trigger other events. The problem was that no mater what period I tried to set, the counter ignored it and remained running at the initial frequency when it was initialized. Frustrated I resorted to just de-initialize and reinitialize the counter with the new frequency.  A few weeks later the problem came back to bite me again when I needed to change the period of a timer in PMW mode, and posted a second message here.

After detailed code review and debugging, and stepping through the code, I finally found a few errors in my code, AND, understood how the API really has to be used. This is not clearly documented anywhere, at least in the places where I looked (this forum and others).

First, don't repeat my errors:

1. Pay attention to the type of parameters that each function expects.  For example,

Cy_TCPWM_TriggerStart_Single(Timer_1_HW, Timer_1_NUM);  // The second parameter must be the timer NUMBER
Cy_TCPWM_TriggerStart(Timer_1_HW, Timer_1_MASK);  // The second parameter must be the timer MASK (or the OR '|'  combined mask of several timers, if you want to start them all in sync)

2. Double check the parameters used in the PDL documentation. In one instance the example has the second parameter incorrect (it uses counter MASK where it should use counter NUMBER, twice!).  All xx_Single() versions of the functions work on a single timer and expect the timer number.  That error in the example led me to believe that xx_MASK and xx_NUMBER are interchangeable, when they are NOT.

3. You must STOP the counter to make changes to the period, duty cycle,  compare values, etc. There may be instances where this is not necessary, but better safe than sorry, in the PDL documentation the examples do not mention this, (at least for the functions that I used).

4. It seems that Cy_TCPWM_TriggerStopOrKill_Single() is not an atomic operation. You must test and make sure that the counter has stopped before continuing. This was the principal problem I had since the beginning.

So, here is the the safe method to alter counter parameters that I came up with:

uint32_t loops;   // this variable is for debugging purposes only

void Change_Timer_1_Frequency(uint32_t _new_frequency)
{
      uint32_t period = 0;

   /* validate frequency range */
   if (_new_frequency < MIN_FREQUENCY || _new_frequency > MAX_FREQUENCY)
        return;

    period = _Timer_1_clock / _new_frequency;

    loops = 0;

    Cy_TCPWM_TriggerStopOrKill_Single(Timer_1_HW, Timer_1_NUM);

    /* IMPORTANT: wait for the timer to stop before changing registers */
     while (Cy_TCPWM_Counter_GetStatus(Timer_1_HW, Timer_1_NUM) &      CY_TCPWM_COUNTER_STATUS_COUNTER_RUNNING )
         loops++;

    Cy_TCPWM_Counter_SetCounter(Timer_1_HW, Timer_1_NUM, 0);
    Cy_TCPWM_Counter_SetPeriod(Timer_1_HW, Timer_1_NUM, period);
    Cy_TCPWM_TriggerStart_Single(Timer_1_HW, Timer_1_NUM);
}

I introduced the variable Loops for testing purposes. In a simple, Hello World type of program when only this code is running Loops may be 0, most of the time. But as the program grows in complexity with interrupts and external events going on at the same time, that won't be the case.  In my application Loops ends up anywhere from 65 a to over 600 iterations before the counter stopped!

In summary, I thing that PDL is a good helper, but its documentation is minimal and the examples just snippets not really tested in an actual program.  As a former boss of mine used to say "Trust is good, check is better!"

Hello All,

I have a project using PSoC63 in which the Vdd (and Vdda) varies from 2.1 to 2.5 V.  I am using the Scanning SAR ADC as follows:

• Differential input across a low impedance (shunt resistor).
• VRef is System Bandgap (1.2V).
• Input common mode voltage is near Vss.

It appears that, with a constant input voltage, as Vdd (Vdda) increases, ADC readings increase somewhat.  I don't have actual numbers - this is simply a consistent pattern that I have observed.

Has anyone else seen this behavior?  If so, do you have a fix?

Paul

Hi, I am trying to wrap my head around a potential smartio use:

Goal: Deterministic cycling between three GPIO signals that control isolated FETs to toggle between three voltage levels on *one* output pin. To avoid shorts, only one signal may be high, and a dead time between switching would be helpful. In the end I'd like to have a function that enables the smartio voltage cycling like cycle_voltage(count,ontime,deadtime);

Signal pins: SIG_GND, SIG_MID, SIG_HIGH -> controlling the external 0V, 75V, 135V switching in my application:

SIG_HIGH=1                          ________                                           135V              
                                                    |                 |
SIG_LOW=1           _______|                 |               ______...          75V
                                   |                                  |               |
SIG_GND=1 ____|                                  |______ |                            0V

Desired toggle behavior: 100-500uS signal high, then 0-1uS dead time, then signal high for next SIG_ pin. 

Questions:
- I want to 1) cycle and 2) control signal high time for each signal and dead time from firmware. How do I think of this problem in terms of Chip inputs, clocks and perhaps chained LUTs?
- Can I link the SAR ADC's EOS trigger to start the smartio cycling?
- Alternatively, would it be possible in smartio to start the ADC on the first voltage cycling and snapshot scan every X cycles? 

Thanks! 

I wonder if is it possible to access the QSPI Flash from M0+.

The example provided in the modus toolbox seems to use the M4 ( as there is the HAL lib that is not usable with M0 ).

Please help

Thanks

S

When I create a task, it seems to run just fine.  But as soon as I call any blocking function (vTaskDelay), the app never seems to re-enter the Ready state. I have configTICK_RATE_HZ is defined in FreeRTOSConfig.h.  Is there anything else I can look at? 

Hello everyone, this is my second question on this lovely community.

If the person who had helped in my previous question sees this, I posted this in a new post so the other one doesn't get out of context and doesn't become too long 🙂

Last time, a member helped solve my previous problem, which is to generate a 45 kHz signal over a period of 10 ms every second. I will post below the build and the code, and what my new problem is according to their suggestion.

The idea is to use a timer, and call an interrupt one overflow of the timer counter to generate the signal over 10 ms and disable the PWM afterwards.

Here is the m04 code:

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

void Counter_Int_Handler()                                                //Counter interrupt handler
{   
    printf("Handler is here \r\n");
    Cy_TCPWM_ClearInterrupt(Timer_HW, Timer_CNT_NUM, CY_TCPWM_INT_ON_TC); //Clearing the interrupt
    Cy_GPIO_Inv(LED_PORT, LED_NUM);
    CyDelay(10);
    Cy_GPIO_Inv(LED_PORT, LED_NUM);
    PWM_Disable();
    CyDelay(990);
    PWM_Start();
    printf("End of Handler \r\n\n");
}

int main(void)
{
    UART_Start();  
    Timer_Start();
    PWM_Start();
    
    bool flag = true;
    
    Cy_GPIO_Write(LED_PORT,LED_NUM,1);
    
    Cy_SysInt_Init(&SysInt_1_cfg,Counter_Int_Handler);                    //Configuring the interrupt
    NVIC_ClearPendingIRQ(SysInt_1_cfg.intrSrc);                           //Clearing the interrupt
    NVIC_EnableIRQ(SysInt_1_cfg.intrSrc);                                 //Calling the interrupt handler
    __enable_irq();                                                       //Enable global interrupts
    
    //(void)Cy_TCPWM_Counter_Init(Timer_HW, Timer_CNT_NUM, &Timer_config);
    Cy_TCPWM_Enable_Multiple(Timer_HW, Timer_CNT_MASK);  //
    Cy_TCPWM_TriggerReloadOrIndex(Timer_HW, Timer_CNT_MASK); 
    
    printf ("\033[3J");                                                   //Clearing PuTTY's scrollback buffer
    printf ("\ec");                                                       //Clearing previous PuTTY outputs
    printf("UART link established \r\n\n");
    
    __enable_irq(); 
    for(;;)
    {   
        printf("Hello for loop! \r\n");
        Cy_SysPm_Sleep(CY_SYSPM_WAIT_FOR_INTERRUPT);
    }
}

The problem is that once the interrupt handler is called and start executing, it executes infinitely and never exits back to the for loop.

Also, although I am I managed to get the interrupt service routine to work, I am not quite sure if I understand how I exactly did it, nor what is the exact logic behind it as well; you could say I am following my sense and basic understanding of these matters.

My questions are as following:

1) Is the interrupt logic correct?

2) Could the interrupt logic used here be enhanced to be more efficient and/or exit to the for loop and back to the interrupt again without flags?

3) How to use flags?

I will post a weird attempt of mine to grasp the idea of flags, but in my opinion I failed miserably and most probably didn't actually understand anything.

Here is the miserable attempt on grasping flags:

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

void Counter_Int_Handler()                                                //Counter interrupt handler
{   
    bool flag = true;
    printf("Handler is here \r\n");
    Cy_TCPWM_ClearInterrupt(Timer_HW, Timer_CNT_NUM, CY_TCPWM_INT_ON_TC); //Clearing the interrupt
    Cy_GPIO_Inv(LED_PORT, LED_NUM);
    CyDelay(10);
    Cy_GPIO_Inv(LED_PORT, LED_NUM);
    PWM_Disable();
    CyDelay(990);
    PWM_Start();
    if (flag == true){
    printf("End of Handler flag trigered \r\n\n");
    NVIC_ClearPendingIRQ(SysInt_1_cfg.intrSrc);
    __NVIC_DisableIRQ(SysInt_1_cfg.intrSrc);
    }
}

int main(void)
{
    UART_Start();  
    Timer_Start();
    PWM_Start();
    
    bool flag = false;
    
    Cy_GPIO_Write(LED_PORT,LED_NUM,1);
    
    Cy_SysInt_Init(&SysInt_1_cfg,Counter_Int_Handler);                    //Configuring the interrupt
    NVIC_ClearPendingIRQ(SysInt_1_cfg.intrSrc);                           //Clearing the interrupt
    NVIC_EnableIRQ(SysInt_1_cfg.intrSrc);                                 //Calling the interrupt handler
    __enable_irq();                                                       //Enable global interrupts
    
    //(void)Cy_TCPWM_Counter_Init(Timer_HW, Timer_CNT_NUM, &Timer_config);
    Cy_TCPWM_Enable_Multiple(Timer_HW, Timer_CNT_MASK);  //
    Cy_TCPWM_TriggerReloadOrIndex(Timer_HW, Timer_CNT_MASK); 
    
    printf ("\033[3J");                                                   //Clearing PuTTY's scrollback buffer
    printf ("\ec");                                                       //Clearing previous PuTTY outputs
    printf("UART link established \r\n\n");
    
    if (flag == true){
        for(;;){   
            printf("Hello for loop! flag is true \r\n");
            NVIC_EnableIRQ(SysInt_1_cfg.intrSrc);                         //Calling the interrupt handler
            flag = false;
            Cy_SysPm_Sleep(CY_SYSPM_WAIT_FOR_INTERRUPT);
                }
                       }
    else {
        printf("Flag is flase! \r\n");
        flag = true;
        return flag;
          }
}

and here is the output of the last attempt with the flag:

I am excited and looking forward everyone's suggestions/solutions!

Thank you and best regards,

HappyPotamus.