AC (Autonomous Controller)

General Description

This driver provides API functions to configure, manage and interact with the Autonomous Controller (AC) subsystem within High Performance Programmable Analog Sub-System (HPPASS).

The autonomous controller is a programmable finite-state machine (FSM) sequencer that works from a 16-entry state transition table, to transition appropriately through various pre-defined states, based on timer, counter, and/or events. The AC provides hardware control without the need for CPU or external intervention.
The internal structure and external HW interface of the AC is shown at the picture below.

Autonomous controller can perform the following functions:

• Enable/disable SAR ADC and/or CSG, provide a BLOCK_READY status to the firmware
• Process input hardware/firmware triggers to execute programmed actions
• Trigger any of the internal or connected blocks
• Implement hardware delays/counters
• Perform periodic actions (e.g., triggering) in a timed loop
• Receive conditions from the connected blocks and acting on those events
• Generate an AC-based interrupt to the CPU
• Digital output to as many as five GPIOs

The AC has a standard interface to each sub-block of HPPASS, the interface consists of: Enable, Trigger, and Conditions signals groups.

Refer to the Technical Reference Manual for detailed information.

To configure the AC, the driver uses a configuration structure of type cy_stc_hppass_ac_t that must be predefined. In turn, this structure holds the non-NULL pointer to the State Transition Table (STT) array of type cy_stc_hppass_ac_stt_t. The configuration structure also holds a specialized startup configuration array of type cy_stc_hppass_startup_t.
This array defines the parameters of the AC HW startup.

State Transition Table

The AC can implement a single threaded programming sequence using a simple format. The AC program is stored in a RAM table called a STT, which consists of 16 States (or programming instructions) of type cy_stc_hppass_ac_stt_t. These programming instructions can form one or more programs, called by FW, like subroutines.

Note

At least one state (e.g. 'Stop') of the state transition table must be predefined in the STT.

The CSG and/or SAR should be enabled in the first state of the STT to ensure proper working of the AC.

Here is an example of a simple program coded by STT instructions.

#define CY_HPPASS_STT_NUM_ENTRIES (4U) /* Define number of states */

const cy_stc_hppass_ac_stt_t stt_cfg[CY_HPPASS_STT_NUM_ENTRIES] =
{
    /* STATE #0: Set P7_0, P7_1 HIGH for ((.count + 1) * clock period) value */
    {
        .condition     = CY_HPPASS_CONDITION_CNT_DONE,                /* Set the condition for moving to the next state */
        .action        = CY_HPPASS_ACTION_WAIT_FOR,                   /* Wait in this state until .count = 199 cycles */
        .branchStateIdx   = 0U,                                          /* Ignored in this state */
        .interrupt     = false,
        .count         = 199U,                                        /* Set the counter value in cycles */
        .gpioOutUnlock = true,                                        /* Unlock the GPIO Out for AC */
        .gpioOutMsk       = CY_HPPASS_GPIO_OUT_0 | CY_HPPASS_GPIO_OUT_1, /* Enable GPIO_OUT0 and GPIO_OUT1 in this state */
        .csgUnlock     = {false, false, false, false, false},
        .csgEnable     = {false, false, false, false, false},
        .csgDacTrig    = {false, false, false, false, false},
        .sarUnlock     = false,
        .sarEnable     = false,
        .sarGrpMsk        = 0U,
        .sarMux        = {{0}, {0}, {0}, {0}}
    },
    /* STATE #1: Set P7_0 LOW for ((.count + 1) * clock period) value */
    {
        .condition     = CY_HPPASS_CONDITION_CNT_DONE,       /* Set the condition for moving to the next state */
        .action        = CY_HPPASS_ACTION_WAIT_FOR,          /* Wait in this state until .count = 199 cycles */
        .branchStateIdx   = 0U,                                 /* Ignored in this state */
        .interrupt     = false,
        .count         = 199U,                               /* Set the counter value in cycles */
        .gpioOutUnlock = true,                               /* Keep unlock the GPIO Out for AC */
        .gpioOutMsk       = CY_HPPASS_GPIO_OUT_0,               /* GPIO_OUT0 is still Enabled and GPIO_OUT1 becomes disabled */
        .csgUnlock     = {false, false, false, false, false},
        .csgEnable     = {false, false, false, false, false},
        .csgDacTrig    = {false, false, false, false, false},
        .sarUnlock     = false,
        .sarEnable     = false,
        .sarGrpMsk        = 0U,
        .sarMux        = {{0}, {0}, {0}, {0}}
    },
    /* STATE #2: Set P7_0, P7_1 LOW for ((.count + 1) * clock period) value */
    {
        .condition     = CY_HPPASS_CONDITION_CNT_DONE,       /* Set the condition for moving to the next state */
        .action        = CY_HPPASS_ACTION_WAIT_FOR,          /* Go to branch state 3 if the condition TRUE */
        .branchStateIdx   = 0U,                                 /* Ignored in this state */
        .interrupt     = false,
        .count         = 199U,
        .gpioOutUnlock = true,                               /* Keep unlock the GPIO Out for AC */
        .gpioOutMsk       = MY_HPPASS_GPIO_OUT_DISABLE_ALL,     /* Disable All HPPASS AC GPIOs in this state*/
        .csgUnlock     = {false, false, false, false, false},
        .csgEnable     = {false, false, false, false, false},
        .csgDacTrig    = {false, false, false, false, false},
        .sarUnlock     = false,
        .sarEnable     = false,
        .sarGrpMsk        = 0U,
        .sarMux        = {{0}, {0}, {0}, {0}}
    },
    /* STATE #3: Go to the stage 0 */
    {
        .condition     = CY_HPPASS_CONDITION_TRUE,           /* Set condition TRUE */
        .action        = CY_HPPASS_ACTION_BRANCH_IF_TRUE,    /* Go to branch state 0 if condition TRUE */
        .branchStateIdx   = 0U,                                 /* Set branch state 0 */
        .interrupt     = false,
        .count         = 0U,
        .gpioOutUnlock = false,                              /* Don't change the GPIO in this state */
        .gpioOutMsk       = MY_HPPASS_GPIO_OUT_DISABLE_ALL,     /* This value is ignored here because gpioOutUnlock = false */
        .csgUnlock     = {false, false, false, false, false},
        .csgEnable     = {false, false, false, false, false},
        .csgDacTrig    = {false, false, false, false, false},
        .sarUnlock     = false,
        .sarEnable     = false,
        .sarGrpMsk        = 0U,
        .sarMux        = {{0}, {0}, {0}, {0}}
    }
};

Startup

Startup is initiated by enabling the AC with loaded AC startup sequence instructions (cy_stc_hppass_ac_t::startup). The startup block have dedicated logic to time the HPPASS startup and will generate BLOCK_READY condition once HPPASS startup is done. The application should wait for the BLOCK_READY condition before using any HPPASS features. The BLOCK_READY condition can be checked by Cy_HPPASS_AC_IsBlockReady function.

Note

Only usage of the startup parameters recommended by the vendor guarantees the reliable work of the autonomous controller.
Please use the Device Configurator tool to make configurations or refer to the Technical Reference Manual chapter 27.2.1.1 for detailed information.

Code Snippets

Snippet 1: GPIO Toggling by Autonomous Controller

An example is shown below, describes a simple case of usage Autonomous Controller for toggling GPIO Out:

• Configure GPIO pin P7_0 and set HSIOM mode as P7_0_PASS_MCPASS_DOUT0:

  const cy_stc_gpio_pin_config_t TEST_PIN_0_config =
  {
      .outVal    = 1,                        /* Output = High */
      .driveMode = CY_GPIO_DM_STRONG_IN_OFF, /* Input buffer off */
      .hsiom     = P7_0_PASS_MCPASS_DOUT0,   /* Set HSIOM MCPASS DOUT0 mode */
      .intEdge   = CY_GPIO_INTR_DISABLE,     /* Disable interrupt */
      .intMask   = 0UL,
      .vtrip     = CY_GPIO_VTRIP_CMOS,       /* CMOS voltage trip */
      .slewRate  = CY_GPIO_SLEW_FAST,        /* Fast slew rate */
      .driveSel  = CY_GPIO_DRIVE_1_2,        /* Full drive strength */
      .vregEn    = 0UL,                      /* SIO-specific setting - ignored */
      .ibufMode  = 0UL,                      /* SIO-specific setting - ignored */
      .vtripSel  = 0UL,                      /* SIO-specific setting - ignored */
      .vrefSel   = 0UL,                      /* SIO-specific setting - ignored */
      .vohSel    = 0UL,                      /* SIO-specific setting - ignored */
      .nonSec    = 0UL                       /* Secure access */
  };

• Configure cy_stc_hppass_ac_stt_t structure array with appropriate configurations for each state of Autonomous Controller:

  #define CY_HPPASS_STT_NUM_ENTRIES (4U) /* Define number of states */
  
  const cy_stc_hppass_ac_stt_t stt_cfg[CY_HPPASS_STT_NUM_ENTRIES] =
  {
      /* STATE #0: Set P7_0, P7_1 HIGH for ((.count + 1) * clock period) value */
      {
          .condition     = CY_HPPASS_CONDITION_CNT_DONE,                /* Set the condition for moving to the next state */
          .action        = CY_HPPASS_ACTION_WAIT_FOR,                   /* Wait in this state until .count = 199 cycles */
          .branchStateIdx   = 0U,                                          /* Ignored in this state */
          .interrupt     = false,
          .count         = 199U,                                        /* Set the counter value in cycles */
          .gpioOutUnlock = true,                                        /* Unlock the GPIO Out for AC */
          .gpioOutMsk       = CY_HPPASS_GPIO_OUT_0 | CY_HPPASS_GPIO_OUT_1, /* Enable GPIO_OUT0 and GPIO_OUT1 in this state */
          .csgUnlock     = {false, false, false, false, false},
          .csgEnable     = {false, false, false, false, false},
          .csgDacTrig    = {false, false, false, false, false},
          .sarUnlock     = false,
          .sarEnable     = false,
          .sarGrpMsk        = 0U,
          .sarMux        = {{0}, {0}, {0}, {0}}
      },
      /* STATE #1: Set P7_0 LOW for ((.count + 1) * clock period) value */
      {
          .condition     = CY_HPPASS_CONDITION_CNT_DONE,       /* Set the condition for moving to the next state */
          .action        = CY_HPPASS_ACTION_WAIT_FOR,          /* Wait in this state until .count = 199 cycles */
          .branchStateIdx   = 0U,                                 /* Ignored in this state */
          .interrupt     = false,
          .count         = 199U,                               /* Set the counter value in cycles */
          .gpioOutUnlock = true,                               /* Keep unlock the GPIO Out for AC */
          .gpioOutMsk       = CY_HPPASS_GPIO_OUT_0,               /* GPIO_OUT0 is still Enabled and GPIO_OUT1 becomes disabled */
          .csgUnlock     = {false, false, false, false, false},
          .csgEnable     = {false, false, false, false, false},
          .csgDacTrig    = {false, false, false, false, false},
          .sarUnlock     = false,
          .sarEnable     = false,
          .sarGrpMsk        = 0U,
          .sarMux        = {{0}, {0}, {0}, {0}}
      },
      /* STATE #2: Set P7_0, P7_1 LOW for ((.count + 1) * clock period) value */
      {
          .condition     = CY_HPPASS_CONDITION_CNT_DONE,       /* Set the condition for moving to the next state */
          .action        = CY_HPPASS_ACTION_WAIT_FOR,          /* Go to branch state 3 if the condition TRUE */
          .branchStateIdx   = 0U,                                 /* Ignored in this state */
          .interrupt     = false,
          .count         = 199U,
          .gpioOutUnlock = true,                               /* Keep unlock the GPIO Out for AC */
          .gpioOutMsk       = MY_HPPASS_GPIO_OUT_DISABLE_ALL,     /* Disable All HPPASS AC GPIOs in this state*/
          .csgUnlock     = {false, false, false, false, false},
          .csgEnable     = {false, false, false, false, false},
          .csgDacTrig    = {false, false, false, false, false},
          .sarUnlock     = false,
          .sarEnable     = false,
          .sarGrpMsk        = 0U,
          .sarMux        = {{0}, {0}, {0}, {0}}
      },
      /* STATE #3: Go to the stage 0 */
      {
          .condition     = CY_HPPASS_CONDITION_TRUE,           /* Set condition TRUE */
          .action        = CY_HPPASS_ACTION_BRANCH_IF_TRUE,    /* Go to branch state 0 if condition TRUE */
          .branchStateIdx   = 0U,                                 /* Set branch state 0 */
          .interrupt     = false,
          .count         = 0U,
          .gpioOutUnlock = false,                              /* Don't change the GPIO in this state */
          .gpioOutMsk       = MY_HPPASS_GPIO_OUT_DISABLE_ALL,     /* This value is ignored here because gpioOutUnlock = false */
          .csgUnlock     = {false, false, false, false, false},
          .csgEnable     = {false, false, false, false, false},
          .csgDacTrig    = {false, false, false, false, false},
          .sarUnlock     = false,
          .sarEnable     = false,
          .sarGrpMsk        = 0U,
          .sarMux        = {{0}, {0}, {0}, {0}}
      }
  };

• Set HPPASS and AC state transition table configuration, used by Cy_HPPASS_Init API:

  const cy_stc_hppass_cfg_t hppassCfg =
  {
      .ac =
      {
          .sttEntriesNum = CY_HPPASS_STT_NUM_ENTRIES,                   /* Set number of states in State Transition Table */
          .stt           = stt_cfg,                                     /* Set State Transition Table */
          .gpioOutEnMsk   = CY_HPPASS_GPIO_OUT_0 | CY_HPPASS_GPIO_OUT_1, /* Enable GPIO Out0, Out1 */
          .startupClkDiv      = 7U,                                          /* Set Startup Clock Divider */
          .startup       = {{0}, {0}, {0}, {0}}
      },
      .vref = CY_HPPASS_VREF_LOCAL,
      .csg       = NULL,
      .sar       = NULL,
      .trigIn    = {{0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}},
      .trigPulse = {CY_HPPASS_DISABLED, CY_HPPASS_DISABLED, CY_HPPASS_DISABLED, CY_HPPASS_DISABLED,
                    CY_HPPASS_DISABLED, CY_HPPASS_DISABLED, CY_HPPASS_DISABLED, CY_HPPASS_DISABLED},
      .trigLevel = {{0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}}
  };

• Initialize and start Autonomous Controller:

      /* Initialize GPIO P7_0, P7_1 for AC test */
      Cy_GPIO_Pin_Init(GPIO_PRT7, 0U, &TEST_PIN_0_config);
      Cy_GPIO_Pin_Init(GPIO_PRT7, 1U, &TEST_PIN_1_config);
  
      /* Initialize HPPASS */
      if (CY_HPPASS_SUCCESS != Cy_HPPASS_Init(&hppassCfg))
      {
          /* Stop program execution */
          CY_ASSERT(0);
      }

      if (CY_HPPASS_SUCCESS != Cy_HPPASS_AC_Start(0U, 0U))
      {
          /* Stop program execution */
          CY_ASSERT(0);
      }

Snippet 2: The AC state triggering by FW and HW input triggers

The below example is a simple case of using HPPASS input trigger events to trigger the Autonomous Controller state. The code snippet shows two approaches: FW trigger and HW trigger configurations.

• Configure the cy_stc_hppass_ac_stt_t structure array, where the Autonomous Controller in state #0 waits for a trigger to change that state:

  #define CY_HPPASS_STT_NUM_ENTRIES (4U) /* Define number of states */
  
  /* Autonomous Controller State Transition Table, describes states and triggering conditions */
  const cy_stc_hppass_ac_stt_t stateTransitionTable[CY_HPPASS_STT_NUM_ENTRIES] =
  {
      /* STATE #0: Enable SAR and wait for trigger 0 signal */
      {
          .condition     = CY_HPPASS_CONDITION_TRIG_0,
          .action        = CY_HPPASS_ACTION_WAIT_FOR,
          .branchStateIdx   = 0U,
          .interrupt     = false,
          .count         = 0U,
          .gpioOutUnlock = false,
          .gpioOutMsk       = 0,
          .csgUnlock     = {false, false, false, false, false},
          .csgEnable     = {false, false, false, false, false},
          .csgDacTrig    = {false, false, false, false, false},
          .sarUnlock     = true,
          .sarEnable     = true,
          .sarGrpMsk        = 0U,
          .sarMux        = {{0}, {0}, {0}, {0}}
      },
      /* STATE #1: Wait for trigger 0 signal */
      {
          .condition     = CY_HPPASS_CONDITION_TRIG_0,
          .action        = CY_HPPASS_ACTION_WAIT_FOR,
          .branchStateIdx   = 0U,
          .interrupt     = false,
          .count         = 0U,
          .gpioOutUnlock = false,
          .gpioOutMsk       = 0,
          .csgUnlock     = {false, false, false, false, false},
          .csgEnable     = {false, false, false, false, false},
          .csgDacTrig    = {false, false, false, false, false},
          .sarUnlock     = false,
          .sarEnable     = false,
          .sarGrpMsk        = 0U,
          .sarMux        = {{0}, {0}, {0}, {0}}
      },
      /* STATE #2: Wait for trigger 1 signal */
      {
          .condition     = CY_HPPASS_CONDITION_TRIG_1,
          .action        = CY_HPPASS_ACTION_WAIT_FOR,
          .branchStateIdx   = 0U,
          .interrupt     = false,
          .count         = 0U,
          .gpioOutUnlock = false,
          .gpioOutMsk       = 0,
          .csgUnlock     = {false, false, false, false, false},
          .csgEnable     = {false, false, false, false, false},
          .csgDacTrig    = {false, false, false, false, false},
          .sarUnlock     = false,
          .sarEnable     = false,
          .sarGrpMsk        = 0U,
          .sarMux        = {{0}, {0}, {0}, {0}}
      },
      /* STATE #3: Stop the Autonomous controller */
      {
          .condition     = CY_HPPASS_CONDITION_TRUE,
          .action        = CY_HPPASS_ACTION_STOP,
          .branchStateIdx   = 0U,
          .interrupt     = false,
          .count         = 0U,
          .gpioOutUnlock = false,
          .gpioOutMsk       = 0,
          .csgUnlock     = {false, false, false, false, false},
          .csgEnable     = {false, false, false, false, false},
          .csgDacTrig    = {false, false, false, false, false},
          .sarUnlock     = false,
          .sarEnable     = false,
          .sarGrpMsk        = 0U,
          .sarMux        = {{0}, {0}, {0}, {0}}
      }
  };
  
  /* State transition table configuration, used by Cy_HPPASS_Init API */
  const cy_stc_hppass_cfg_t hppassCfg =
  {
      .ac =
      {
          .sttEntriesNum = CY_HPPASS_STT_NUM_ENTRIES,
          .stt = stateTransitionTable,
          .gpioOutEnMsk = 0U,
          .startupClkDiv = 7U,
          .startup = {{0}, {0}, {0}, {0}}
      },
      .vref   = CY_HPPASS_VREF_LOCAL,
      .csg       = NULL,
      .sar       = NULL,
      .trigIn    =
      {   
          { /* The input trigger 0 configuration */
              .type = CY_HPPASS_TR_FW_PULSE,
              .hwMode = CY_HPPASS_PULSE_ON_BOTH_SINGLE_SYNC
          },
          { /* The input trigger 1 configuration */
              .type = CY_HPPASS_TR_HW_B,
              .hwMode = CY_HPPASS_PULSE_ON_BOTH_SINGLE_SYNC
          },
          {0}, {0}, {0}, {0}, {0}, {0}
      },
      .trigPulse = {CY_HPPASS_DISABLED, CY_HPPASS_DISABLED, CY_HPPASS_DISABLED, CY_HPPASS_DISABLED,
                    CY_HPPASS_DISABLED, CY_HPPASS_DISABLED, CY_HPPASS_DISABLED, CY_HPPASS_DISABLED},
      .trigLevel = {{0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}}
  };

  Initialization of the hardware modules for the AC with input triggers:

      Cy_SysClk_PeriphAssignDivider(PCLK_TCPWM0_CLOCK_COUNTER_EN3, CY_SYSCLK_DIV_8_BIT, 0U);
      tcpwmStatus = Cy_TCPWM_Counter_Init(TCPWM0, TCPWM_CNT_NUM, &tcpwmCfg);
      printf("Cy_TCPWM_Counter_Init status: %s\r\n", ((tcpwmStatus == 0) ? "SUCCESS" : "FAIL"));
      Cy_TCPWM_Counter_Enable(TCPWM0, TCPWM_CNT_NUM);
  
      trigmuxStatus = Cy_TrigMux_Select(TRIG_OUT_1TO1_2_TCPWM0_GRP0_CNT3_OUT1_TO_MCPASS_TR_IN1, 0, TRIGGER_TYPE_EDGE);
      printf("Cy_TrigMux_Select status: %s\r\n", ((trigmuxStatus == 0) ? "SUCCESS" : "FAIL"));
  
      hppassStatus = Cy_HPPASS_Init(&hppassCfg);
      printf("Cy_HPPASS_Init status: %s\r\n", ((hppassStatus == 0) ? "SUCCESS" : "FAIL"));
  
      hppassACStatus = Cy_HPPASS_AC_Start(0U, 0U); /* Start Autonomous Controller */
      printf("Cy_HPPASS_AC_Start status: %s\r\n", ((hppassACStatus == 0) ? "SUCCESS" : "FAIL"));
      __enable_irq();
  
      hppassACStatus = Cy_HPPASS_AC_GetState(&hppassState);
      printf("\nAC state: %s, STT pointer = %d, Ready to testing\r\n", ((hppassState.ac.running == 0) ? "STOPPED" : "RUNNING"), hppassState.ac.stateIdx);

  Triggering HPPASS Autonomous Controller state by FW trigger:

      for(uint8_t i=1; i<=2; i++)
      {
          printf("--- Start FW Trigger test ---\r\n");
          Cy_HPPASS_SetFwTrigger(CY_HPPASS_TRIG_0_MSK); /* Set firmware trigger */
  
          Cy_SysLib_Delay(100);
  
          hppassACStatus = Cy_HPPASS_AC_GetState(&hppassState); /*Get and print AC state*/
          printf("AC state: %s, STT pointer = %d, ", ((hppassState.ac.running == 0) ? "STOPPED" : "RUNNING"), hppassState.ac.stateIdx);
          printf("The test: %s\r\n", (((hppassState.ac.running == 1) && (hppassState.ac.stateIdx == i)) ? "PASSED" : "FAILED"));
      }

  Triggering HPPASS Autonomous Controller state by HW trigger:

      printf("--- Start HW Trigger test ---\r\n");
      Cy_TCPWM_TriggerStart_Single(TCPWM0, TCPWM_CNT_NUM); /* Software start on the TCPWM0*/
  
      Cy_SysLib_Delay(500);
  
      hppassACStatus = Cy_HPPASS_AC_GetState(&hppassState); /*Get and print AC state*/
      printf("AC state: %s, STT pointer = %d, ", ((hppassState.ac.running == 0) ? "STOPPED" : "RUNNING"), hppassState.ac.stateIdx);
      printf("The test: %s\r\n", (((hppassState.ac.running == 0) && (hppassState.ac.stateIdx == 3)) ? "PASSED" : "FAILED"));

API Reference
	Macros
	Functions
	Data Structures
	Enumerated Types