Part Number: BQ28Z610

(Please visit the site to view this file)Hi there,

I am still having issues with completing a successful learning cycle with the bq28z610 gas gauge; attached are the log and data memory parameter files for the most recent attempt where I reduced the discharge and charge currents in an attempt to prevent significant cell voltage imbalance.  I am using LiFePO4 Tenergy 34009-0 cells setup in a 2S configuration.

I had previously been told that my charging setup was incorrect.  I've been attempting the learning cycles using a power supply set to the desired final charge voltage (7.3V) with it current limited to the desired charging current.  This appeared to cause problems as the taper current was never achieved and charging current would sometimes go in and out.  I was under the impression that the bq28z610 would regulate the charge current itself.  Is this true?  And what would be the best method for charging the cells?

I also reviewed our data memory parameters and did not find anything that seemed troublesome, but could this also be looked over?  Any feedback would be appreciated.

Thanks,

Nick

Part Number: DS90UB936-Q1

Hi Team,

In register 0x0C of the 936 datasheet, for PASS_SEL and LOCK_SEL, there is an option of 10 for "Any" and 11 for "All" Enable Receiver Port(s) Pass/Lock. What is the difference between those two? I am not clear under what condition I would select 10 vs 11.

Any insight you can provide would be greatly appreciated. Thanks!

Jared

Part Number: TDC7200

I am trying to design the circuit to integrate the chip and not clear what the result will be if

STOP pulse before Start

Multiple START pulse

Please help to understand.

Part Number: TMS320F280049C

Concerning the HRCAP, in the F28004x TRM sprui33c, p.2102, Figure 19-17, There is a note about the TSCTR register when running in HR mode that says "Its not synchronized to SYSCLK domain so reads may not be accurate."

I'm confused as to why this is relevant.  You don't normally read the TSCTR register directly.  Rather, you read the captured values in the CAP1-4 registers.  What is the practical limitation of not being able to read TSCTR accurately?

Regards,

David

Part Number: SN74AHC74Q-Q1

Hi Team,

My Customer is looking for the Thermal Data of SN74AHC74QPWRQ1, the data in the datasheet is not complete. Can we provide this information?

Looking forward to your reply.

Regards,

_Renan

Part Number: CC3200

Hi,

Does CC3200 support transparent proxy? Could you please share sample code for reference.

Regards,

Sundar 

Part Number: DP83822I

Hi team,

My customer is evaluating KSZ8081 and DP83822I. Customer has a document that listed the link loss reaction time of KSZ8081 and DP83822I. It said KSZ8081 is 4.4us while DP83822I is 250us. So could you please help explain the meanning of  link loss reaction time and why we have worse spec. than competitor. Is this spec. critical to the system? Thanks.

Best regards,

Wayne

Part Number: RM44L920

Hi -

I'm embarking on a new project with a requirement for functional safety and overall reliability.  The project is large in scope and will require a lot of development effort on my part, and I know from past experience that the selection of an MCU is rather like a marriage in that once a commitment is made, one has to live with both the good and bad, with the bad often not being obvious or even knowable at the project outset.  Accordingly I have cast a wide net looking for MCUs suited to this purpose, and have considered Infineon Aurix, NXP S32, Renesas RH850, and TI's own Hercules series of parts.  After a considerable amount of research, I feel myself gravitating towards Hercules and have some design momentum in that direction already, but I feel like I need to ask this question before taking the plunge.

The entire Hercules line strikes me as mature, which is a double-edged sword.  On the positive side, it's comforting to use a product that is tried and true and has had some time to work out major kinks through silicon die revs and toolchain updates.  On the negative side, a line that is too mature can get long in the tooth and may be in danger of being retired, but sales and marketing departments are usually very opaque about this kind of thing until it suddenly happens.  As an engineer you have to learn to read between the lines a bit, and with Hercules there are several little signs that give me pause.  One is that as I've combed through the various parts to try to select the best combination of attributes for my application (one of which is availability), I have run into many parts that are marked as obsolete in the distribution channels I've looked at.  A second is that I've found several parts which, despite being marked as active, can't be found in distribution anywhere, even in TI's own store.  Still another is that many of the datasheets, app notes, forum posts, and software packages I've found are several years old, in some case five or more.  Finally, some of the industry reps I known for many years claim that TI has no long-term interest in MCUs in general and is trying to shed the business.  I don't know how much of this advice is speculative, self-serving fear mongering on their part in an effort to steer me towards their competitive lines, but a few of them used to rep TI before the whole sales and support model was changed several years back.

I have read a response from a TI engineer to a similar question about Hercules, and I'll quote him here: "There are no current plans to obsolete these parts. TI makes an effort to not obsolete products out of convenience. Convenience means: low running device, poor yields, limited customer adoption or similar items. TI’s obsolescence withdrawal schedule provides a longer lead time than the industry standard."

This is somewhat comforting to me assuming it still holds true today (it was from November 2018).  The reason I chose to post my concerns in spite of this response is this: availability of parts is one thing, but another equally important consideration is the long-term support of a part.  Given that my only support option for these parts is through these forums - I can't pick up a phone to talk to someone or have a TI engineer visit me on-site - I would consider the availability of TI engineers who are expert in these parts to be a critical consideration.

Hercules seems very capable, well-suited for its intended purpose, and worthy of our commitment overall - can any offer anyone assurances that I'm not making a mistake in selecting this over several other fresh-faced competitive parts that seem to have a lot of recent marketing investment?  I fully realize someone from TI may not be allowed to say "we plan to support Hercules for X years from today" or simply may not know what plans exist for it.  I'm just looking for anything that will perhaps assuage some of my concerns.

Thanks, and sorry for the loquacity.

Josh

Part Number: UCC3895

sir,

could you help confirm any problems with the schematic, or have any suggestions,thanks for your help.

my specification: input 480v VDC to 380v VBUS/3KW.

(Please visit the site to view this file)

Part Number: TMUX1072

new question

asdfasf

Part Number: TPS62821

Hi,

I’m working on a core power supply for a small FPGA and I have a few questions about some parts.

The requirements are:

Vin: 2.8 – 4.5V

Vout: 1.1V +/- 2.5%

Iout: 1 – 2 A

I’m looking at the TPS62821 (1A) and the TPS62825 (2A). Using the FPGA vendors tools I’ve come up with a capacitance requirement of about 250uF, however both of those parts don’t recommend more than 47 – 100uF of output capacitance, or at least suggest that other values should be evaluated carefully. The FPGA vendors tools model the power supply as a voltage source in series with a resistor (1m ohm by default) and an inductor (20nH). They suggest that those values should be adjusted to match the power supply’s datasheet, but I’m not sure how to come up with the correct values. It is possible that with better values for those parameters the capacitance requirements would be reduced. Do you have any idea how to characterize those things?

Both parts also recommend a feed forward capacitor for larger output capacitances. Is it possible to adjust the value of that capacitor to achieve stability with a larger output capacitance? If so, how would I go about doing that?

Thank you,

Lauren

Part Number: LAUNCHXL-CC2640R2

So I'm using a code based off the ADCbuf example to read voltages from various sensors and trying to send the data over UART to a terminal program. Can I create a buffer that will populate with which channel goes with which reading? I've tried reducing the buffer size, which works, but I don't want to have such a small buffer that the MCU is constantly sending a data stream over UART. It doesn't seem power efficient to me.

#include <unistd.h>
#include <stdint.h>
#include <stddef.h>

/* Driver Header files */
#include <ti/drivers/GPIO.h>
#include <ti/drivers/PIN.h>
#include <ti/drivers/UART.h>
#include <ti/drivers/ADCBuf.h>
// #include <ti/drivers/Watchdog.h>

/* Board Header file */
#include "Board.h"
#include <ti/drivers/timer/GPTimerCC26XX.h>
#include <ti/drivers/Power.h>
#include <ti/drivers/power/PowerCC26XX.h>
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Task.h>
#include <xdc/runtime/Types.h>

/////////////////////////// pin configuration ///////////////////////
/* Pin driver handles */
static PIN_Handle muxPinHandle;

/* Global memory storage for a PIN_Config table */
static PIN_State muxPinState;

/* Global Variables */
unsigned int muxidx = 0;
unsigned int muxmod = 0;
static int channels = 10;
int status = 3;

static int ADCFREQ = 100;
static int MUXFREQ = 5;

PIN_Config muxPinTable[] = {
    IOID_21 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX, //EN
    IOID_22 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX, //A3
    IOID_23 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX, //A2
    IOID_12 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX, //A1
    IOID_15 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX, //A0
    PIN_TERMINATE
};

/////////////////////////// mux task configuration ///////////////////////
/* Task data */
//Task_Struct timerTask;
//char timerTaskStack[512];

GPTimerCC26XX_Handle hMUXTimer;
void timerCallback(GPTimerCC26XX_Handle handle, GPTimerCC26XX_IntMask interruptMask) {
    // interrupt callback code goes here. Minimize processing in interrupt.
    GPIO_toggle(Board_GPIO_LED0);
        muxmod = muxidx % channels; //get remainder of muxidx for switch
    switch(muxmod) {
        case 0:
            PIN_setOutputValue(muxPinHandle, IOID_22, 0);
            PIN_setOutputValue(muxPinHandle, IOID_23, 0);
            PIN_setOutputValue(muxPinHandle, IOID_12, 0);
            PIN_setOutputValue(muxPinHandle, IOID_15, 0);
            break;
        case 1:
            PIN_setOutputValue(muxPinHandle, IOID_22, 0);
            PIN_setOutputValue(muxPinHandle, IOID_23, 0);
            PIN_setOutputValue(muxPinHandle, IOID_12, 0);
            PIN_setOutputValue(muxPinHandle, IOID_15, 1);
            break;
        case 2:
            PIN_setOutputValue(muxPinHandle, IOID_22, 0);
            PIN_setOutputValue(muxPinHandle, IOID_23, 0);
            PIN_setOutputValue(muxPinHandle, IOID_12, 1);
            PIN_setOutputValue(muxPinHandle, IOID_15, 0);
            break;
        case 3:
            PIN_setOutputValue(muxPinHandle, IOID_22, 0);
            PIN_setOutputValue(muxPinHandle, IOID_23, 0);
            PIN_setOutputValue(muxPinHandle, IOID_12, 1);
            PIN_setOutputValue(muxPinHandle, IOID_15, 1);
            break;
        case 4:
            PIN_setOutputValue(muxPinHandle, IOID_22, 0);
            PIN_setOutputValue(muxPinHandle, IOID_23, 1);
            PIN_setOutputValue(muxPinHandle, IOID_12, 0);
            PIN_setOutputValue(muxPinHandle, IOID_15, 0);
            break;
        case 5:
            PIN_setOutputValue(muxPinHandle, IOID_22, 0);
            PIN_setOutputValue(muxPinHandle, IOID_23, 1);
            PIN_setOutputValue(muxPinHandle, IOID_12, 0);
            PIN_setOutputValue(muxPinHandle, IOID_15, 1);
            break;
        case 6:
            PIN_setOutputValue(muxPinHandle, IOID_22, 0);
            PIN_setOutputValue(muxPinHandle, IOID_23, 1);
            PIN_setOutputValue(muxPinHandle, IOID_12, 1);
            PIN_setOutputValue(muxPinHandle, IOID_15, 0);
            break;
        case 7:
            PIN_setOutputValue(muxPinHandle, IOID_22, 0);
            PIN_setOutputValue(muxPinHandle, IOID_23, 1);
            PIN_setOutputValue(muxPinHandle, IOID_12, 1);
            PIN_setOutputValue(muxPinHandle, IOID_15, 1);
            break;
        case 8:
            PIN_setOutputValue(muxPinHandle, IOID_22, 1);
            PIN_setOutputValue(muxPinHandle, IOID_23, 0);
            PIN_setOutputValue(muxPinHandle, IOID_12, 0);
            PIN_setOutputValue(muxPinHandle, IOID_15, 0);
            break;
        case 9:
            PIN_setOutputValue(muxPinHandle, IOID_22, 1);
            PIN_setOutputValue(muxPinHandle, IOID_23, 0);
            PIN_setOutputValue(muxPinHandle, IOID_12, 0);
            PIN_setOutputValue(muxPinHandle, IOID_15, 1);
            break;
        case 10:
            PIN_setOutputValue(muxPinHandle, IOID_22, 1);
            PIN_setOutputValue(muxPinHandle, IOID_23, 0);
            PIN_setOutputValue(muxPinHandle, IOID_12, 1);
            PIN_setOutputValue(muxPinHandle, IOID_15, 0);
            break;
        case 11:
            PIN_setOutputValue(muxPinHandle, IOID_22, 1);
            PIN_setOutputValue(muxPinHandle, IOID_23, 0);
            PIN_setOutputValue(muxPinHandle, IOID_12, 1);
            PIN_setOutputValue(muxPinHandle, IOID_15, 1);
            break;
        case 12:
            PIN_setOutputValue(muxPinHandle, IOID_22, 1);
            PIN_setOutputValue(muxPinHandle, IOID_23, 1);
            PIN_setOutputValue(muxPinHandle, IOID_12, 0);
            PIN_setOutputValue(muxPinHandle, IOID_15, 0);
            break;
        case 13:
            PIN_setOutputValue(muxPinHandle, IOID_22, 1);
            PIN_setOutputValue(muxPinHandle, IOID_23, 1);
            PIN_setOutputValue(muxPinHandle, IOID_12, 0);
            PIN_setOutputValue(muxPinHandle, IOID_15, 1);
            break;
        case 14:
            PIN_setOutputValue(muxPinHandle, IOID_22, 1);
            PIN_setOutputValue(muxPinHandle, IOID_23, 1);
            PIN_setOutputValue(muxPinHandle, IOID_12, 1);
            PIN_setOutputValue(muxPinHandle, IOID_15, 0);
            break;
        case 15:
            PIN_setOutputValue(muxPinHandle, IOID_22, 1);
            PIN_setOutputValue(muxPinHandle, IOID_23, 1);
            PIN_setOutputValue(muxPinHandle, IOID_12, 1);
            PIN_setOutputValue(muxPinHandle, IOID_15, 1);
            break;
    }
    if(muxidx == channels){
    muxidx = 0; //reset counter back to zero, if it equals the number of channels
    }
    muxidx += 1; // increment counter
    
    
}



/////////////////////////// ADCbuf/UART configuration ///////////////////////
#define ADCBUFFERSIZE    (5)
#define UARTBUFFERSIZE   ((20 * ADCBUFFERSIZE) + 24)

uint16_t sampleBufferOne[ADCBUFFERSIZE];
uint16_t sampleBufferTwo[ADCBUFFERSIZE];
uint32_t microVoltBuffer[ADCBUFFERSIZE];
uint32_t buffersCompletedCounter = 0;
char uartTxBuffer[UARTBUFFERSIZE];

/* Driver handle shared between the task and the callback function */
UART_Handle uart;

/*
 * This function is called whenever an ADC buffer is full.
 * The content of the buffer is then converted into human-readable format and
 * sent to the PC via UART.
 */
void adcBufCallback(ADCBuf_Handle handle, ADCBuf_Conversion *conversion,
    void *completedADCBuffer, uint32_t completedChannel)
{
    uint_fast16_t i;
    uint_fast16_t uartTxBufferOffset = 0;

    /* Adjust raw ADC values and convert them to microvolts */
    ADCBuf_adjustRawValues(handle, completedADCBuffer, ADCBUFFERSIZE,
        completedChannel);
    ADCBuf_convertAdjustedToMicroVolts(handle, completedChannel,
        completedADCBuffer, microVoltBuffer, ADCBUFFERSIZE);

    /* Start with a header message. */
    uartTxBufferOffset = snprintf(uartTxBuffer,
        UARTBUFFERSIZE - uartTxBufferOffset, "\r\nBuffer %u finished.",
        (unsigned int)buffersCompletedCounter++);
        
    /* Write channel number to the UART buffer if there is room. */
    if (uartTxBufferOffset < UARTBUFFERSIZE) {
        uartTxBufferOffset += snprintf(uartTxBuffer + uartTxBufferOffset,
            UARTBUFFERSIZE - uartTxBufferOffset, "\r\nChannel: ");

        for (i = 0; i < ADCBUFFERSIZE && uartTxBufferOffset < UARTBUFFERSIZE; i++) {
            uartTxBufferOffset += snprintf(uartTxBuffer + uartTxBufferOffset,
                UARTBUFFERSIZE - uartTxBufferOffset, "%u,",
                (unsigned int)muxmod);
        }
    }

//    /* Write raw adjusted values to the UART buffer if there is room. */
//   uartTxBufferOffset += snprintf(uartTxBuffer + uartTxBufferOffset,
//        UARTBUFFERSIZE - uartTxBufferOffset, "\r\nRaw Buffer: ");
//
//    for (i = 0; i < ADCBUFFERSIZE && uartTxBufferOffset < UARTBUFFERSIZE; i++) {
//        uartTxBufferOffset += snprintf(uartTxBuffer + uartTxBufferOffset,
//            UARTBUFFERSIZE - uartTxBufferOffset, "%u,",
//        *(((uint16_t *)completedADCBuffer) + i));
//    }

    /* Write microvolt values to the UART buffer if there is room. */
    if (uartTxBufferOffset < UARTBUFFERSIZE) {
        uartTxBufferOffset += snprintf(uartTxBuffer + uartTxBufferOffset,
            UARTBUFFERSIZE - uartTxBufferOffset, "\r\nMicrovolts: ");

        for (i = 0; i < ADCBUFFERSIZE && uartTxBufferOffset < UARTBUFFERSIZE; i++) {
            uartTxBufferOffset += snprintf(uartTxBuffer + uartTxBufferOffset,
                UARTBUFFERSIZE - uartTxBufferOffset, "%u,",
                (unsigned int)microVoltBuffer[i]);
        }
    }

    /*
     * Ensure we don't write outside the buffer.
     * Append a newline after the data.
     */
    if (uartTxBufferOffset < UARTBUFFERSIZE) {
        uartTxBuffer[uartTxBufferOffset++] = '\n';
    }
    else {
        uartTxBuffer[UARTBUFFERSIZE-1] = '\n';
    }

    /* Display the data via UART */
    UART_write(uart, uartTxBuffer, uartTxBufferOffset);
}

/*
 * Callback function to use the UART in callback mode. It does nothing.
 */
void uartCallback(UART_Handle handle, void *buf, size_t count) {
   return;
}

/*
 *  ======== mainThread ========
 */
void *mainThread(void *arg0)
{
    /////////////////////////// mux ///////////////////////
    muxPinHandle = PIN_open(&muxPinState, muxPinTable);
    if(!muxPinHandle) {
        /* Error initializing mux output pins */
        while(1);
    }
    PIN_setOutputValue(muxPinHandle, IOID_21, 1);
    
    /////////////////////////// GPIO ///////////////////////
    
     /* Call driver init functions */
    GPIO_init();

    /* Configure the LED pins */
    GPIO_setConfig(Board_GPIO_LED0, GPIO_CFG_OUT_STD | GPIO_CFG_OUT_LOW);

    /* Turn on user LED */
    GPIO_write(Board_GPIO_LED0, Board_GPIO_LED_ON);
    
/////////////////////////// ADCbuf/ UART /////////////////////// 
    UART_Params uartParams;
    ADCBuf_Handle adcBuf;
    ADCBuf_Params adcBufParams;
    ADCBuf_Conversion continuousConversion;

    /* Call driver init functions */
    ADCBuf_init();
    UART_init();

    /* Create a UART with data processing off. */
    UART_Params_init(&uartParams);
    uartParams.writeDataMode = UART_DATA_BINARY;
    uartParams.writeMode = UART_MODE_CALLBACK;
    uartParams.writeCallback = uartCallback;
    uartParams.baudRate = 115200;
    uart = UART_open(Board_UART0, &uartParams);

    /* Set up an ADCBuf peripheral in ADCBuf_RECURRENCE_MODE_CONTINUOUS */
    ADCBuf_Params_init(&adcBufParams);
    adcBufParams.callbackFxn = adcBufCallback;
    adcBufParams.recurrenceMode = ADCBuf_RECURRENCE_MODE_CONTINUOUS;
    adcBufParams.returnMode = ADCBuf_RETURN_MODE_CALLBACK;
    adcBufParams.samplingFrequency = ADCFREQ;
    adcBuf = ADCBuf_open(Board_ADCBUF0, &adcBufParams);

    /* Configure the conversion struct */
    continuousConversion.arg = NULL;
    continuousConversion.adcChannel = Board_ADCBUF0CHANNEL0;
    continuousConversion.sampleBuffer = sampleBufferOne;
    continuousConversion.sampleBufferTwo = sampleBufferTwo;
    continuousConversion.samplesRequestedCount = ADCBUFFERSIZE;

    if (adcBuf == NULL){
        /* ADCBuf failed to open. */
        while(1);
    }

    /* Start converting. */
    status = ADCBuf_convert(adcBuf, &continuousConversion, 1);    
    //if (ADCBuf_convert(adcBuf, &continuousConversion, 1) !=
    //    ADCBuf_STATUS_SUCCESS) {
        /* Did not start conversion process correctly. */
    //    ADCBuf_close(adcBuf);
    //}

  GPTimerCC26XX_Params paramsMUX;
  GPTimerCC26XX_Params_init(&paramsMUX);
  paramsMUX.width          = GPT_CONFIG_32BIT;
  paramsMUX.mode           = GPT_MODE_PERIODIC_UP;
  paramsMUX.debugStallMode = GPTimerCC26XX_DEBUG_STALL_OFF;
  hMUXTimer = GPTimerCC26XX_open(CC2640R2_LAUNCHXL_GPTIMER1A, &paramsMUX); //Need timer 0A for ADCbuf
  if(hMUXTimer == NULL) {
    Task_exit();
  }

  Types_FreqHz  freq;
  BIOS_getCpuFreq(&freq); //48MHz
  //GPTimerCC26XX_Value loadVal = freq.lo / 1000; //47999 = 1ms. 1 clock tick = 1/48e6
  //GPTimerCC26XX_Value loadVal = 48000000; //48e6 = 1 sec
  GPTimerCC26XX_Value loadValMUX = 48000000/MUXFREQ; //24e6 = 0.5 sec
  loadValMUX = loadValMUX - 1;
  GPTimerCC26XX_setLoadValue(hMUXTimer, loadValMUX);
  GPTimerCC26XX_registerInterrupt(hMUXTimer, timerCallback, GPT_INT_TIMEOUT);

  GPTimerCC26XX_start(hMUXTimer);

  /* Start TI-RTOS */
 // BIOS_start();

  
  while(1) {
    Task_sleep(BIOS_WAIT_FOREVER);
  }
}

Part Number: TMS320C6678

Hi,

I am using a standard EVM C6678 PG2 board.

My intention is to enable the use of EDMA for all 8 cores, for all 3 EDMA controllers on this device, using TI's EDMA3 LLD layer.

Currently I am able to perform a correct memory to memory EDMA transfer (DDR to MSM), both by polling or by transfer complete interrupt, when running the program on a single core.

The problem is when I try this running on more than 1 core. At init phase, on the second core, all the times I get this EMC BUSSERR (127) exception. When debugging, this happens always in edma3ShadowRegionInit(), at the point where the execution is trying to set the ECRH register:

ptrEdmaShadowRegs->ECRH   = (rmInstInitConfig->ownDmaChannels[1U]
                                            | rmInstInitConfig->ownTccs[1U]);

I thought that maybe I don't initialize correctly multiple instances for EDMA 3 LLD & RM, but so far I am unable to find an error.

I have found some other guy on this forum, he performed the EDMA3_DRV_create() only once, on core 0, but this isn't working because the other cores will fail to open driver instances without this step.

Can someone please specify a few key points needed in using EDMA3 LLD:

1. Is it  correct to consider each core of C6678 DSP as a master for each EDMA controller?

2. Is is correct to let each core use one of the 8 regions? For simplicity I have used the same region as the core number, 0 to 7.

3. Is it correct that each core needs to call EDMA3_DRV_create() once? And if needed we can use multiple instances using EDMA3_DRV_open()?

4. Is there anything else I am missing about this multicore setup? Is there any specific requirement regarding memory layout, rights, and so on?

Thank you in advance!

Best regards,

Alin

Part Number: LM431

Hello, I am using the LM431BIM3 in the control loop of a flyback converter. However instead of having a Vref of 2.5V, i am measuring 2.6V instead which makes my output regulates at 12.6V instead of 12V.

R2=4.7k, R1=18k, R3=2.2k, R4=1k, Cz=22n.

The voltage across R3=7V

The voltage across R4=1.1V 

voltage across VAK of LM431=3.9V

Can someone help me understand why Vref=2.6V? and how to make it 2.5V? I guess Vref is current dependent..

Thanks

Part Number: MSP430F5529

Hi everyone,

I read this post: https://e2e.ti.com/support/microcontrollers/msp430/f/166/p/844684/3140359

Other than disabling interrupts, are there any other steps to take before jumping to the BSL through software?

For instance, do module registers have to be cleared, like the timers, the USCI, etc.?

Thank you!

Part Number: TAS2770EVM

Hi Sirs,

I have two questions.

1. I can't enable TAS2770EVM speaker (J10 or J15 and J20) when I connect a 3rd party SoC to it by I2S interface (SoC data out to TAS2770EVM SDIN) in PPC3.

I measured the SoC I2S waveform and it is normal when playing 48kHz/2ch/16bit (1.536MHz) and 48kHz/2ch/24bit (3.072MHz) wav file.

Which specific items I need to set in PPC3 when using external I2S interface?

2. When using I2S interface to enable speaker, can you tell me which I2C registers need to be configured and what are the values?

Thank you

Part Number: UAF42

Hello,

I have designed a band pass filter using part UAF42AP at f = 500 HZ (See my circuit schematics at 1.tiff). The filter is working well and neutralizing unwanted signals at other frequencies. However, while using the spectrum analyzer to evaluate its performance, I noticed that a signal (although weak) is generated by the IC at its center frequency. For example, you can notice this when inputs such as 1 Volts sin 50 Hz (see 3.tiff) or 1 Volts sin 5 KHz (see 2.tiff) were used. In other words, a self generated signal is added/mixed to the signal I am trying to collect at the center frequency, which is problematic. I also found an application data describing how to use UAF42AP to make a sine generator (see sbfa002.pdf). Therefore, I am suspecting that for some reason, maybe me not connecting some of the pins right, this chip is partially performing as an oscillator/sine generator. In addition, the self generated signal at the center frequency is in direct relation with the gain of the filter.

Please advise if any experts can help me resolve this problem. 

On a separate, any suggestions on how to reduce the noise when using UAF42AP would be appreciated as well.

P.S. I am using breadboard for this test. The green signal is the output and yellow is the input.

Best Regards,

(Please visit the site to view this file)(Please visit the site to view this file)(Please visit the site to view this file)

Part Number: AM5726

Tool/software: TI C/C++ Compiler

Hi All,

I have asked the same question in the forum.  ( SDK: ti-processor-sdk-linux-rt-am57xx-evm-06.00.00.07 )

I have also created a repository for the example testing the feature in addition to the codes pasted in the previous question. Please find the link below:

https://gitlab.com/mustafa-gonul/examples/ti-processor-sdk-linux-am57x/openmp/tree/master/001-variadic

Unfortunately the problem continues with the new version. ( SDK: ti-processor-sdk-linux-rt-am57xx-evm-06.01.00.08 ) When I check the ClearQuest, I see there is no updates. 

Our code base using the variadic arguments feature of the language. Because of that we cannot make a migration to newer version of the SDK. I appreciate it if you can give an estimation when it will be done.

Kind regards,

Mustafa

PS: Ticket is CODEGEN-6673 in the ClearQuest

Part Number: TM4C123GH6PM

I'm using IAR ide. I just copy the code from a example, which path is I wrote down below

C:\ti\tirtos_tivac_2_16_01_14\tirtos_tivac_2_16_01_14_examples\IAR\EK_TM4C123GXL\gpiointerrupt

I've included path 

$PROJ_DIR$
C:\Program Files (x86)\IAR Systems\Embedded Workbench 8.2\arm\CMSIS\Include
C:\TI-CMSIS-Devices-8636\TI\LM4F\Include
C:\ti\TivaWare_C_Series-2.1.4.178
C:\ti\TivaWare_C_Series-2.1.4.178\driverlib
C:\ti\TivaWare_C_Series-2.1.4.178\utils
C:\ti\xdctools_3_32_00_06_core\packages\xdc\
C:\ti\tirtos_tivac_2_16_01_14\products\bios_6_45_02_31\packages\ti\sysbios

and defined symbols - PART_TM4C123GH6PM

Now, I'm getting error that cannot open source file "xdc\std.h". I checked some other forum questions but they're using IAR ide. 

Part Number: IWR1642

Hi E2E,

Good day!

May I know where to find the pulse repetition frequency or pulse repetition time of IWR1642? Is this the same as chirp repetition time?

Looking forward to your response.

Best regards,

Franz