通过将整数转换为二进制来填充数组的void函数 int main（无效） { /*停止WDT*/ MAP_WDT_A_holdTimer（）； /*在UART模式下选择P1.2和P1.3*/ 映射\u GPIO\u设置专用模块功能输入引脚（GPIO\u端口\u P1， GPIO_引脚1 | GPIO_引脚2 | GPIO_引脚3，GPIO_主模块_功能）； /*将DCO设置为12MHz*/ CS_设置数据中心频率（CS_数据中心频率12）； /*配置UART模块*/ 映射UART初始化模块（EUSCI A0基础和uartConfig）； /*启用UART模块*/ MAP_UART_启用模块（EUSCI_A0_基地）； /*将GPIO2.4配置为PWM的外围输出，将P6.7配置为按钮的外围输出 *打断*/ MAP_GPIO_setAsPeripheralModuleFunctionOutputPin（GPIO_端口P2、GPIO_PIN4、， GPIO_主_模块_功能）； 重定向（）； /*将P1.0配置为输出*/ 映射GPIO设置为输出引脚（GPIO端口P1，GPIO引脚0）； MAP_GPIO_setOutputLowOnPin（GPIO_端口_P1，GPIO_引脚0）； /*将定时器_A配置为大约500毫秒的周期，以及 *初始占空比为该值的10%（3200滴答声）*/ //MAP_Interrupt_enableSeepOnisrexit（）； 映射中断启用中断（INT\U TA0\U 0）； MAP_Timer_A_generatePWM（定时器_A0_基和pwmConfig）； 映射\u定时器\u A\u clearInterruptFlag（定时器\u A0\u基准）； 映射定时器启用中断（定时器A0基数）； 映射\u计时器\u启用捕获比较中断 （定时器A0为基极，定时器A为捕获比较寄存器0）； /*启用主中断*/ MAP_Interrupt_enableMaster（）； /*不用时睡觉*/ 而(1) { //MAP_PCM_gotoLPM0（）； } } const int bit_length=33； 整数周期； 整数倍[33]； int值[32]； x=598； 数字_位=10； //此函数-周期、时间、值 //x是32位整数，number_位是该整数的位数 无效整数到整数（uint32\UTX，整数位）{ int i=0； 周期=位长度*67；//15fps->1/15=66.67m 对于（i=0；i>i）&1）==0）/*右移i位，则选中开/关*/ 值[i]=1000；/*根据结果为值[i]赋值*/ 其他的 数值[i]=11000； 倍[i]=位长度*i；/*设置倍[i]*/ } 乘以[i]=位长度*i； } void TA0_0_IRQHandler（void） { int i，值； 映射\u计时器\u A\u clearCaptureCompareInterrupt（计时器\u A0\u基， 计时器\u A\u捕获比较\u寄存器\u 0）； 时间=时间+1； 如果（时间>=时段）{ 时间=0； 映射\u GPIO\u开关输出输入（GPIO\u端口\u P1，GPIO\u引脚0）； } 对于（i=0；乘以[i]！=-1；i++）{ 如果（次[i]>时间）{ 打破 } 值=值[i]； } 映射\u定时器\u设置比较值（定时器\u A0\u基，定时器\u捕获比较\u寄存器\u 1，值）； }

所以这个函数将取x（32位整数）和number_位（整数中有多少位），并将填充主数组。如果位为1，则值=11000，这将点亮led。如果位为0，则值=1000。不幸的是，LED不闪烁或不做任何事情。在此之前，我手动执行此操作，是的，LED闪烁

int time=0;
const int BIT_LENGTH = 33;
int period;
int times[33]; //{x}
int values[32];//{y}

//new 1001010110
  const int period=667; //15fps - bitlength*67
  const int times[]={0,67,200,267,333,400,467,600,667,-1};
  const int values[]={11000,1000,11000,1000,11000,1000,11000,1000};

---

似乎您想检查

x

的每一位，看看它是

1

还是

0

，但是使用

>

是正确的

x>>i; //x<<i
if(x&1==0){

它将通过循环每次将

x

的值移位一，然后检查最右边的位

此外，循环计数器不正确，而不是

for(i=1;i<x;i++){

虽然查看了代码，但我认为没有理由对

时间[0]

和

值[0]

的设置进行特殊处理，如果仔细检查，您会发现可以从

for(i = 0; i < number_bit; i++) {

for（i=0；i

---

并包括设置

时间[0]

和

值[0]

在循环中。您只需在设置

值之后进行移位，或者在
i
为
0
时，使用
if
不移位
x
，如果通过我们已经进行的扩展讨论，您正在寻求基于
中的
数字位
填充
值数组uint32\u t x
通过将值
x
向右移动
number\u位
次数，并在每次迭代时确定
x
中的位是
0
还是
1
并设置
值[i]，将值传递给
int\u数组
函数=1000
如果位为
0
，如果位为
1
，则可以执行以下操作：

#define BIT_LENGTH 33   /* if you need a constant, define one (or more) */
#define FPS_MULT   33
...
/* fill values based on nbits bit-values in x, 
 * fill times based on BIT_LENGTH and index.
 * note: CHAR_BIT defined in limits.h
 * (defined as 8 for virtually all common systems)
 */
void int_to_array (uint32_t x, int nbits)
{
    int i = 0;  /* loop variable - can be declared in loop for C99+ */
    period = BIT_LENGTH * FPS_MULT;     // your 30fps-1/30=0.033

    /* validate nbits <= 32 */
    if (nbits > (int)(sizeof x * CHAR_BIT)) {
        fprintf (stderr, "error: nbits out of range of uint32_t\n");
        return;
    }

    for (i = 0; i < nbits; i++) {
        if (((x >> i) & 1) == 0)    /* shift right by i-bits, check on/off */
            values[i] = 1000;       /* assign to values[i] based on result */
        else
            values[i] = 11000;
        times[i] = BIT_LENGTH * i;  /* set times[i] */
    }
    times[i] = BIT_LENGTH * i;      /* final times[BIT_LENGTH - 1] */
}

（注意：我通过在检查中添加可选括号来调整函数，以消除
-pedantic
有符号/无符号比较警告，并在循环后添加一个最终
倍[I]=BIT_LENGTH*I；
来处理
倍
比
值多1个元素的次数）

示例测试

10（1010）

或更大的值，
0xdeadbeef（11011110101011011011111101111）

仔细检查一下，如果您还有其他问题，请告诉我。
不确定您在问什么。我试图编辑方框下方的文本，但它没有改变任何内容。但让我在这里澄清一下。我是否需要将x>>i或x放在下面。您现在的处理方式得到了什么结果？如果它与您想要完成的内容不同，请解释为什么现在你看到了它和你想要的有什么不同。事实上，我还没有测试它，因为我需要将它与蓝牙代码结合起来。我使用CCS Cloud来做这件事。我需要确保我在测试它之前做了正确的事情。好吧，我肯定会设计一种方法来测试它，然后再将它与其他代码集成。你能不能打电话给我在这里和伟大的一个简单的控制台应用程序或东西，看看你的代码如何工作？你知道如何测试这个吗？当然，只要通过
x=10
（二进制
1010
）和
nbits=32
，你的值数组将容纳
{1000，11000，1000，11000，…。
数组将容纳
{0,33,66,99，…，1056}
。还要注意，如果
nbits
小于
sizeof x*CHAR\u BIT
，您只需
for(i = 1; i < number_bit - 1; i++) {

for(i = 0; i < number_bit; i++) {

#define BIT_LENGTH 33   /* if you need a constant, define one (or more) */
#define FPS_MULT   33
...
/* fill values based on nbits bit-values in x, 
 * fill times based on BIT_LENGTH and index.
 * note: CHAR_BIT defined in limits.h
 * (defined as 8 for virtually all common systems)
 */
void int_to_array (uint32_t x, int nbits)
{
    int i = 0;  /* loop variable - can be declared in loop for C99+ */
    period = BIT_LENGTH * FPS_MULT;     // your 30fps-1/30=0.033

    /* validate nbits <= 32 */
    if (nbits > (int)(sizeof x * CHAR_BIT)) {
        fprintf (stderr, "error: nbits out of range of uint32_t\n");
        return;
    }

    for (i = 0; i < nbits; i++) {
        if (((x >> i) & 1) == 0)    /* shift right by i-bits, check on/off */
            values[i] = 1000;       /* assign to values[i] based on result */
        else
            values[i] = 11000;
        times[i] = BIT_LENGTH * i;  /* set times[i] */
    }
    times[i] = BIT_LENGTH * i;      /* final times[BIT_LENGTH - 1] */
}

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <errno.h>
#include <limits.h>

#define BIT_LENGTH 33   /* if you need a constant, define one (or more) */
#define FPS_MULT   33

int period;
int times[BIT_LENGTH]; 
int values[BIT_LENGTH - 1];

/* fill values based on nbits bit-values in x, 
 * fill times based on BIT_LENGTH and index.
 * note: CHAR_BIT defined in limits.h
 * (defined as 8 for virtually all common systems)
 */
void int_to_array (uint32_t x, int nbits)
{
    int i = 0;  /* loop variable - can be declared in loop for C99+ */
    period = BIT_LENGTH * FPS_MULT;     // your 30fps-1/30=0.033

    /* validate nbits <= 32 */
    if (nbits > (int)(sizeof x * CHAR_BIT)) {
        fprintf (stderr, "error: nbits out of range of uint32_t\n");
        return;
    }

    for (i = 0; i < nbits; i++) {
        if (((x >> i) & 1) == 0)    /* shift right by i-bits, check on/off */
            values[i] = 1000;       /* assign to values[i] based on result */
        else
            values[i] = 11000;
        times[i] = BIT_LENGTH * i;  /* set times[i] */
    }
    times[i] = BIT_LENGTH * i;      /* final times[BIT_LENGTH - 1] */
}

int main (int argc, char **argv) {

    unsigned long tmp = argc > 1 ? strtoul (argv[1], NULL, 0) : 10;
    uint32_t x;
    int i, nbits = sizeof x * CHAR_BIT;

    if (errno || tmp > UINT32_MAX) {
        fprintf (stderr, "error: conversion error or value out of range.\n");
        return 1;
    }
    x = (uint32_t)tmp;

    int_to_array (x, nbits);

    printf ("x: %u\n\nperiod: %d\n\n", x, period);
    for (i = 0; i < nbits; i++)
        printf ("values[%2d]: %5d    times[%2d]: %5d\n",
                i, values[i], i, times[i]);

    printf ("                     times[%2d]: %5d\n", i, times[i]);

    return 0;
}

$ ./bin/values_times
x: 10

period: 1089

values[ 0]:  1000    times[ 0]:     0
values[ 1]: 11000    times[ 1]:    33
values[ 2]:  1000    times[ 2]:    66
values[ 3]: 11000    times[ 3]:    99
values[ 4]:  1000    times[ 4]:   132
values[ 5]:  1000    times[ 5]:   165
values[ 6]:  1000    times[ 6]:   198
values[ 7]:  1000    times[ 7]:   231
values[ 8]:  1000    times[ 8]:   264
values[ 9]:  1000    times[ 9]:   297
values[10]:  1000    times[10]:   330
values[11]:  1000    times[11]:   363
values[12]:  1000    times[12]:   396
values[13]:  1000    times[13]:   429
values[14]:  1000    times[14]:   462
values[15]:  1000    times[15]:   495
values[16]:  1000    times[16]:   528
values[17]:  1000    times[17]:   561
values[18]:  1000    times[18]:   594
values[19]:  1000    times[19]:   627
values[20]:  1000    times[20]:   660
values[21]:  1000    times[21]:   693
values[22]:  1000    times[22]:   726
values[23]:  1000    times[23]:   759
values[24]:  1000    times[24]:   792
values[25]:  1000    times[25]:   825
values[26]:  1000    times[26]:   858
values[27]:  1000    times[27]:   891
values[28]:  1000    times[28]:   924
values[29]:  1000    times[29]:   957
values[30]:  1000    times[30]:   990
values[31]:  1000    times[31]:  1023
                     times[32]:  1056

$ ./bin/values_times 0xdeadbeef
x: 3735928559

period: 1089

values[ 0]: 11000    times[ 0]:     0
values[ 1]: 11000    times[ 1]:    33
values[ 2]: 11000    times[ 2]:    66
values[ 3]: 11000    times[ 3]:    99
values[ 4]:  1000    times[ 4]:   132
values[ 5]: 11000    times[ 5]:   165
values[ 6]: 11000    times[ 6]:   198
values[ 7]: 11000    times[ 7]:   231
values[ 8]:  1000    times[ 8]:   264
values[ 9]: 11000    times[ 9]:   297
values[10]: 11000    times[10]:   330
values[11]: 11000    times[11]:   363
values[12]: 11000    times[12]:   396
values[13]: 11000    times[13]:   429
values[14]:  1000    times[14]:   462
values[15]: 11000    times[15]:   495
values[16]: 11000    times[16]:   528
values[17]:  1000    times[17]:   561
values[18]: 11000    times[18]:   594
values[19]: 11000    times[19]:   627
values[20]:  1000    times[20]:   660
values[21]: 11000    times[21]:   693
values[22]:  1000    times[22]:   726
values[23]: 11000    times[23]:   759
values[24]:  1000    times[24]:   792
values[25]: 11000    times[25]:   825
values[26]: 11000    times[26]:   858
values[27]: 11000    times[27]:   891
values[28]: 11000    times[28]:   924
values[29]:  1000    times[29]:   957
values[30]: 11000    times[30]:   990
values[31]: 11000    times[31]:  1023
                     times[32]:  1056