TMS320F28067: TMS320F28067 ERROR " _system_post_cinit()"

/*
 * main.c
 *
 *  Created on: 13-Jul-2023
 *      Author: dsingh
 */

//###########################################################################
//
// FILE:   Example_2806xLEDBlink.c
//
// TITLE:  Timer based blinking LED Example
//
//!  \addtogroup f2806x_example_list
//!  <h1>Timer based blinking LED(timed_led_blink)</h1>
//!
//!  This example configures CPU Timer0 for a 500 msec period, and toggles the
//!  GPIO34 LED once per interrupt. For testing purposes, this example
//!  also increments a counter each time the timer asserts an interrupt.
//!
//!  \b Watch \b Variables \n
//!  - CpuTimer0.InterruptCount
//!
//! \b External \b Connections \n
//!  Monitor the GPIO34 LED blink on (for 500 msec) and off (for 500 msec) on
//!  the 2806x control card.
//
//###########################################################################
// $TI Release:  $
// $Release Date:  $
// $Copyright:
// Copyright (C) 2009-2023 Texas Instruments Incorporated - http://www.ti.com/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
//   Redistributions of source code must retain the above copyright
//   notice, this list of conditions and the following disclaimer.
//
//   Redistributions in binary form must reproduce the above copyright
//   notice, this list of conditions and the following disclaimer in the
//   documentation and/or other materials provided with the
//   distribution.
//
//   Neither the name of Texas Instruments Incorporated nor the names of
//   its contributors may be used to endorse or promote products derived
//   from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// $
//###########################################################################

//
// Included Files
//
//#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File
#include "F2806x_Device.h"     // F2806x Headerfile Include File
#include "F2806x_Examples.h"   // F2806x Examples Include File
//#include "F2806x_Adc.h"
//#pragma CODE_SECTION(epwm1_timer_isr, "ramfuncs");
//#pragma CODE_SECTION(epwm2_timer_isr, "ramfuncs");
////
//// These are defined by the linker (see F2808.cmd)
////
//extern Uint16 RamfuncsLoadStart;
//extern Uint16 RamfuncsLoadEnd;
//extern Uint16 RamfuncsRunStart;
//extern Uint16 RamfuncsLoadSize;
////
// Function Prototypes statements for functions found within this file.
//
//__interrupt void cpu_timer0_isr(void);
//
// Main
//
void main(void)
{
    //
    // Step 1. Initialize System Control:
    // PLL, WatchDog, enable Peripheral Clocks
    // This example function is found in the F2806x_SysCtrl.c file.
    //
    InitSysCtrl();
    EALLOW;
//    GpioCtrlRegs.GPBMUX1.bit.GPIO34 = 0;
//      //  GpioCtrlRegs.GPBMUX1.bit.GPIO41 = 0;
//    GpioCtrlRegs.GPBDIR.bit.GPIO34 = 1;

     //  GpioCtrlRegs.GPAMUX2.bit.GPIO18 = 3;

       GpioCtrlRegs.GPBMUX1.bit.GPIO40 = 0;
     //  GpioCtrlRegs.GPBMUX1.bit.GPIO41 = 0;
       GpioCtrlRegs.GPBDIR.bit.GPIO40 = 1;
//     //  GpioCtrlRegs.GPBDIR.bit.GPIO41 = 1;
       EDIS;
    //
    // Step 2. Initalize GPIO:
    // This example function is found in the F2806x_Gpio.c file and
    // illustrates how to set the GPIO to it's default state.
    //
     //InitGpio();  // Skipped for this example

    //
    // Step 3. Clear all interrupts and initialize PIE vector table:
    // Disable CPU interrupts
    //
    DINT;

    //
    // Initialize the PIE control registers to their default state.
    // The default state is all PIE interrupts disabled and flags
    // are cleared.
    // This function is found in the F2806x_PieCtrl.c file.
    //
    InitPieCtrl();

    //
    // Disable CPU interrupts and clear all CPU interrupt flags
    //
    IER = 0x0000;
    IFR = 0x0000;

    //
    // Initialize the PIE vector table with pointers to the shell Interrupt
    // Service Routines (ISR).
    // This will populate the entire table, even if the interrupt
    // is not used in this example.  This is useful for debug purposes.
    // The shell ISR routines are found in F2806x_DefaultIsr.c.
    // This function is found in F2806x_PieVect.c.
    //
    InitPieVectTable();

    //
    // Interrupts that are used in this example are re-mapped to
    // ISR functions found within this file.
    //
//    EALLOW;    // This is needed to write to EALLOW protected registers
//    PieVectTable.TINT0 = &cpu_timer0_isr;
//    EDIS;      // This is needed to disable write to EALLOW protected registers

    //
    // Step 4. Initialize the Device Peripheral. This function can be
    //         found in F2806x_CpuTimers.c
    //
   // InitCpuTimers();   // For this example, only initialize the Cpu Timers

    //
    // Configure CPU-Timer 0 to interrupt every 500 milliseconds:
    // 80MHz CPU Freq, 50 millisecond Period (in uSeconds)
    //
   // ConfigCpuTimer(&CpuTimer0, 90, 2000000);//4-Seconds

    //
    // To ensure precise timing, use write-only instructions to write to the
    // entire register. Therefore, if any of the configuration bits are changed
    // in ConfigCpuTimer and InitCpuTimers (in F2806x_CpuTimers.h), the
    // below settings must also be updated.
    //

    //
    // Use write-only instruction to set TSS bit = 0
    //
    //CpuTimer0Regs.TCR.all = 0x4001;

    //
    // Step 5. User specific code, enable interrupts:
    //

    //
    // Configure GPIO34 as a GPIO output pin
    //
   // EALLOW;
//    GpioCtrlRegs.GPBMUX1.bit.GPIO34 = 0;
//    GpioCtrlRegs.GPBDIR.bit.GPIO34 = 0;
//    GpioCtrlRegs.GPBPUD.bit.GPIO34=1;

//    GpioCtrlRegs.GPAMUX2.bit.GPIO18 = 0;
//    GpioCtrlRegs.GPADIR.bit.GPIO18 = 1;


   // EDIS;

//    EALLOW;
//     //  GpioCtrlRegs.GPAMUX2.bit.GPIO18 = 3;
//
//       GpioCtrlRegs.GPBMUX1.bit.GPIO40 = 0;
//     //  GpioCtrlRegs.GPBMUX1.bit.GPIO41 = 0;
//       GpioCtrlRegs.GPBDIR.bit.GPIO40 = 1;
//     //  GpioCtrlRegs.GPBDIR.bit.GPIO41 = 1;
//       EDIS;


//    //
//     // Copy time critical code and Flash setup code to RAM
//     // This includes the following ISR functions: epwm1_timer_isr(),
//     // epwm2_timer_isr(), epwm3_timer_isr and and InitFlash();
//     // The  RamfuncsLoadStart, RamfuncsLoadSize, and RamfuncsRunStart
//     // symbols are created by the linker. Refer to the F2808.cmd file.
//     //
//     memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (Uint32)&RamfuncsLoadSize);
//
//     //
//     // Call Flash Initialization to setup flash waitstates
//     // This function must reside in RAM
//     //
   //  InitFlash();
//
//    //
    // Enable CPU INT1 which is connected to CPU-Timer 0
    //
    IER |= M_INT1;

    //
    // Enable TINT0 in the PIE: Group 1 interrupt 7
    //
   // PieCtrlRegs.PIEIER1.bit.INTx7 = 1;

    //
    // Enable global Interrupts and higher priority real-time debug events
    //
    EINT;   // Enable Global interrupt INTM
    ERTM;   // Enable Global realtime interrupt DBGM

    //
    // Step 6. IDLE loop. Just sit and loop forever (optional)
    //

    for(;;)
    {
        Uint16 counter=0;
        Uint16 i=0;
//       GpioDataRegs.GPATOGGLE.bit.GPIO18 = 1;//GPIO34
//        DELAY_US(1000000);
        GpioDataRegs.GPBTOGGLE.bit.GPIO40 = 1;//GPIO34
        for(i;i<3000;i++)
        {
            if(counter>=3000)
            {
            break;
            }

            counter++;
        }

      //  DELAY_US(100000);
//        GpioDataRegs.GPBTOGGLE.bit.GPIO41 = 1;//GPIO34
//        DELAY_US(1000000);
    }
}

//
// cpu_timer0_isr -
//
//__interrupt void
//cpu_timer0_isr(void)
//{
//    CpuTimer0.InterruptCount++;
//
//    //
//    // Toggle GPIO34 once per 500 milliseconds
//    //
//    GpioDataRegs.GPATOGGLE.bit.GPIO18 = 1;//GPIO34
//
//    //
//    // Acknowledge this interrupt to receive more interrupts from group 1
//    //
//    PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
//}
//
////
//// End of File
////
//
//
//