c - 输入 switch case 将每个变量重置为零和一些提示-6ren

c - 输入 switch case 将每个变量重置为零和一些提示

转载作者：行者123 更新时间：2023-11-30 14:47:28

我在考试中编写了这段代码，但它有一些问题(因此我失败了)。

在通过我的主板进行调试时(我有一个 atmel atmega328p Xplained mini)，我不知道为什么，但是在进入主开关以及开关(当前状态)和之间时>检查案例:我所有的状态变量都重置为零。如果我通过模拟器调试它，它似乎工作正常。

如果我将代码上传到开发板，它的工作效果就会很差，就像它无法识别某些中断一样。

另外我还想问你一件事。我在考试中使用了一个子板，它可以防止访问 PWM 输出的正确引脚，而且我必须驱动特定的输出(我的子板的 LED，例如在这段代码中我必须驱动 PORTC5 和 PORTC4)，所以我必须手动实现 PWM。我尝试实现您可以在代码中看到的解决方案(我使用 1ms 的计时器)。有没有更简单、更智能的解决方案？

你能帮我吗？

#include <avr/io.h>
#include <avr/interrupt.h>

typedef enum{checkled, heatingup, exposure, stop} machine;
machine currentstate=checkled;

typedef enum{twenty, fourty, sixty, eighty} brightness;
brightness light=twenty;

typedef enum{twoseconds, fourseconds, eightseconds, sixteenseconds} exposuretime;
exposuretime time=twoseconds;

volatile uint16_t tick=0;
volatile uint16_t oldtick=0;

volatile uint8_t flagchanged=0;

ISR(PCINT2_vect)
{
    if((PIND&(1<<PIND2))==0)
    {
        if(currentstate==checkled)
            currentstate=heatingup;
    }

    if((PIND&(1<<PIND3))==0)
    {
        if(currentstate==exposure || currentstate==heatingup)
        {
            currentstate=stop;
            PORTC&=~(1<<PORTC4);
            tick=0;
        }
    }

    if((PIND&(1<<PIND4))==0)
    {
        if(currentstate==checkled)
        {
            flagchanged=1;

            if(time==sixteenseconds)//rise time
                ;
            else if(time==eightseconds)
                time=sixteenseconds;
            else if(time==fourseconds)
                time=eightseconds;
            else if(time==twoseconds)
                time=fourseconds;
        }
    }

    if((PIND&(1<<PIND5))==0)
    {
        if(currentstate==checkled)
        {
            flagchanged=1;

            if(time==sixteenseconds)//decrease time
                time=eightseconds;
            else if(time==eightseconds)
                time=fourseconds;
            else if(time==fourseconds)
                time=twoseconds;
            else if(time==twoseconds)
                ;
        }
    }

    if((PIND&(1<<PIND6))==0)
    {
        if(currentstate==checkled)
        {
            flagchanged=1;

            if(light==eighty)//rise brightness
                ;
            else if(light==sixty)
                light=eighty;
            else if(light==fourty)
                light=sixty;
            else if(light==twenty)
                light=fourty;
        }
    }

    if((PIND&(1<<PIND7))==0)
    {
        if(currentstate==checkled)
        {
            flagchanged=1;

            if(light==eighty)//decrease brightness
                light=sixty;
            else if(light==sixty)
                light=fourty;
            else if(light==fourty)
                light=twenty;
            else if(light==twenty)
                ;
        }
    }

}

ISR(TIMER1_COMPA_vect)
{
    tick++;
}

int main(void)
{
    //DDRs
    DDRD&=~((1<<PIND2)|(1<<PIND3)|(1<<PIND4)|(1<<PIND5)|(1<<PIND6)|(1<<PIND7));//input
    PORTD|=(1<<PORTD2)|(1<<PORTD3)|(1<<PORTD4)|(1<<PORTD5)|(1<<PORTD6)|(1<<PORTD7);//pull-up resistors

    DDRC|=(1<<PORTC0)|(1<<PORTC1)|(1<<PORTC2)|(1<<PORTC3)|(1<<PORTC4)|(1<<PORTC5);//output

    //PCINTERRUPT
    PCICR|=(1<<PCIE2);
    PCMSK2|=(1<<PCINT18)|(1<<PCINT19)|(1<<PCINT20)|(1<<PCINT21)|(1<<PCINT22)|(1<<PCINT23);

    //TIMER
    TCCR0A|=(1<<WGM01);
    TIMSK0|=(1<<OCIE0A);
    OCR0A=15;//((clockfrequency/prescaler)*time)-1 - 1millisecond
    TCCR0B|=(1<<CS02)|(1<<CS00);

    sei();

    volatile uint8_t counter=0;
    volatile uint16_t check=0;

    while(1)
    {
        switch (currentstate)//FORM HERE
        {
            case checkled://TO HERE every variable is reset to ZERO
                if(flagchanged!=0)
                {


                    if(light==twenty)//led intesita
                    {
                        PORTC&=~(1<<PORTC0);
                        PORTC&=~(1<<PORTC1);
                    }
                    else if(light==fourty)
                    {
                        PORTC|=(1<<PORTC0);
                        PORTC&=~(1<<PORTC1);
                    }
                    else if(light==sixty)
                    {
                        PORTC&=~(1<<PORTC0);
                        PORTC|=(1<<PORTC1);
                    }
                    else if(light==eighty)
                    {
                        PORTC|=(1<<PORTC0);
                        PORTC|=(1<<PORTC1);
                    }


                    if(time==twoseconds)//led time
                    {
                        PORTC&=~(1<<PORTC2);
                        PORTC&=~(1<<PORTC3);
                    }
                    else if(time==fourseconds)
                    {
                        PORTC|=(1<<PORTC2);
                        PORTC&=~(1<<PORTC3);
                    }
                    else if(time==eightseconds)
                    {
                        PORTC&=~(1<<PORTC2);
                        PORTC|=(1<<PORTC3);
                    }
                    else if(time==sixteenseconds)
                    {
                        PORTC|=(1<<PORTC2);
                        PORTC|=(1<<PORTC3);
                    }

                    flagchanged=0;
                }
            break;

            case heatingup:
                if(tick<=3000)
                {
                    if(tick!=oldtick)
                    {
                        oldtick=tick;

                        if((tick%500)==0)//duty cycle al 50%
                            PORTC^=(1<<PORTC5);

                        if((tick%5)==0)//5% duty cycle
                        {

                            if(counter<=94)//per il 95% del periodo sta spento
                            {
                                PORTC&=~(1<<PORTC4);
                            }
                            else if(counter>=95 && counter<=101)//per il 5% del periodo sta acceso
                            {

                                if(counter==101)
                                {
                                    PORTC&=~(1<<PORTC4);
                                    counter=0;
                                }
                                else
                                PORTC|=(1<<PORTC4);

                            }

                            counter++;
                        }
                    }
                }
                else
                {
                    currentstate=exposure;
                    counter=0;
                    tick=0;

                    PORTC|=(1<<PORTC5);

                    //checking time of how much the lamp needs to be light up
                    switch (time)
                    {
                        case twoseconds:
                            check=2000;
                        break;

                        case fourseconds:
                            check=4000;
                        break;

                        case eightseconds:
                            check=8000;
                        break;

                        case sixteenseconds:
                            check=16000;
                        break;
                    }
                }
                break;

            case exposure:
                if(tick<=check)
                {
                    switch (light)//Checking duty cycle
                    {
                        case twenty://20% duty cycle
                            if(tick!=oldtick)
                            {
                                if((tick%20)==0)
                                {

                                    if(counter<=4)//80% off
                                    {
                                        PORTC&=~(1<<PORTC4);
                                    }
                                    else if(counter>=5 && counter<=6)//20% on
                                    {
                                        if(counter==6)
                                        {
                                            PORTC&=~(1<<PORTC4);
                                            counter=0;
                                        }
                                        else
                                        PORTC|=(1<<PORTC4);

                                    }

                                    counter++;
                                }
                            }
                        break;

                        case fourty://40% duty cycle
                            if(tick!=oldtick)
                            {
                                if((tick%20)==0)
                                {

                                    if(counter<=3)//60% off
                                    {
                                        PORTC&=~(1<<PORTC4);
                                    }
                                    else if(counter>=4 && counter<=6)//40% on
                                    {
                                        if(counter==6)
                                        {
                                            PORTC&=~(1<<PORTC4);
                                            counter=0;
                                        }
                                        else
                                        PORTC|=(1<<PORTC4);

                                    }

                                    counter++;
                                }
                            }
                        break;

                        case sixty://60% duty cycle
                            if(tick!=oldtick)
                            {
                                if((tick%20)==0)
                                {

                                    if(counter<=2)//40% off
                                    {
                                        PORTC&=~(1<<PORTC4);
                                    }
                                    else if(counter>=3 && counter<=6)//60% on
                                    {
                                        if(counter==6)
                                        {
                                            PORTC&=~(1<<PORTC4);
                                            counter=0;
                                        }
                                        else
                                        PORTC|=(1<<PORTC4);

                                    }

                                    counter++;
                                }
                            }
                        break;

                        case eighty://80% duty cycle
                            if(tick!=oldtick)
                            {
                                if((tick%20)==0)
                                {

                                    if(counter<=1)//20% off
                                    {
                                        PORTC&=~(1<<PORTC4);
                                    }
                                    else if(counter>=2 && counter<=6)//80% on
                                    {
                                        if(counter==6)
                                        {
                                            PORTC&=~(1<<PORTC4);
                                            counter=0;
                                        }
                                        else
                                        PORTC|=(1<<PORTC4);

                                    }

                                    counter++;
                                }
                            }
                        break;

                    }
                }
                else
                {
                    PORTC&=~(1<<PORTC4);
                    PORTC&=~(1<<PORTC5);
                    currentstate=checkled;
                    flagchanged=1;
                }

            break;

            case stop://Emergency stop
                if(tick<=2000)
                {
                    if(tick!=oldtick)
                    {
                        oldtick=tick;
                        if((tick%250)==0)
                        PORTC|=(1<<PORTC5);
                    }
                }
                else
                {
                    PORTC&=~(1<<PORTC5);
                    flagchanged=1;
                    currentstate=checkled;
                }
            break;
        }
    }
}

最佳答案

在主代码中，启用了定时器0的输出比较中断

TIMSK0|=(1<<OCIE0A);

但是您没有该 vector 的中断处理程序(您有 TIMER1_COMPA_vect - 用于定时器 1)。

因此，当定时器中断发生时，它由默认 vector 处理，该 vector 只是将控制重定向到重置 vector ，这会导致应用程序从头开始，包括变量初始化，这会导致您所有意外的行为正在观察。

因此，解决方案很简单:要么禁用 OCIE0A，要么为此中断创建一个处理程序。

关于c - 输入 switch case 将每个变量重置为零和一些提示，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/51221033/

文章推荐： c# - 在 MSTest 中处理单元测试中的预期异常

文章推荐： javascript - 如何在 Highcharts 中悬停时获取列类别名称

文章推荐： javascript - 使用 Array 在 javascript 中单击时更改图像

文章推荐： c - C语言中使用getchar()读取输入时是否需要分配内存？

switch-statement - 检查 switch 语句中的数字
是否有使用 switch 语句检查数字 0-9 的简单方法？我正在编写一个程序来检查某些字符和数字。就像检查“\0”、“F”或“f”一样，想知道是否还有一种方法可以以类似的方式检查 0-9。我知道我可
C# Switch If 条件来扩展 switch case
我有一些数据需要转换，为此我需要一个超过 50 个案例的切换条件，我需要 3 次相同的案例，但在第三次我需要 50 个案例和一些更多，我不想写两次相同的代码。也许有可能做这样的事情。 switch (
PHP switch 语句位于另一个 switch 语句中
我遇到这种情况，我必须检查两个 GET 变量。在检查语句内的第一个 switch 语句后，必须在第一个 case 循环内的第二个 switch 语句中检查第二个变量。我无法在这里发布确切的代码，但这
switch-statement - 如何使用函数指针而不是 switch 语句？
如何使用函数指针代替 switch 语句？最佳答案与 ars 发布的链接略有不同的方法:您可以将 switch 语句中的值用作函数指针数组中的数组索引。所以不要写 switch (i) {
c# - switch 语句中的 switch 语句？
我必须评估很多条件。就我而言，我必须做这样的事情: switch(id) { case 5: // switch some other cases here case
javascript - switch 语句内的 ng-switch 按钮
switch 按钮位于 switch 语句内，但仅在 switch 语句外部时才有效这是我的代码:
Javascript - 从一种 switch 语句情况到另一种 switch 语句
我试图在 switch 语句中有一个 case 跳转到不同的 switch 语句。在实践中，我希望用户在文本框中键入“关闭页面”，并且在浏览器关闭页面之前，我希望询问用户是否确定。输入“yes”将关
java - 在 switch 语句内循环或在循环内使用 switch 语句更有效？
(引用java)我试图确定哪个更好，编写更多代码并可能节省一些计算时间，或者编写更少代码但可能牺牲一些计算时间。这就是我好奇的地方这样做会更有效率吗: switch (availability) {
java - 修改 switch 语句内的变量以便在 switch 外部使用
我正在尝试构建一个 Android 应用程序，该应用程序可以访问加速度计传感器，并在单击按钮时将加速度计值(由 <> 包围)输出到串行 USB。当我更新值并尝试在 onClick 命令中调用它时遇到问
switch-statement - dwoo 语法中的 Switch Case
如何使用 Dwoo 模板引擎实现 switch case 语法。最佳答案 {if 3 == 5} never gonna happen {elseif 3 == 3} if you don'
java - 一个大的 switch 语句还是几个小的 switch 语句？
我想知道一个大的 switch 语句和几个小的 switch 语句之间是否有性能差异。包含数百个案例的大型 switch 语句。 switch(quest){ case 1:
javascript - 如何将一个 switch 语句放入另一个 switch 语句中
用户在 2 个选择框中进行选择后，我尝试计算出报值(value)。看起来 1 需要 2 个 switch 语句。这可能吗？ (可能的值比下面的值多得多。为了清楚起见，我删除了它们) var wor
c - switch 语句，跳出 for 循环以重新开始 switch
我在主 while 循环内有一个开关，它将运行我的游戏。我正在尝试打破我的开关，以便转到不同的案例。下面的例子更好地解释了这一点: int j = 0; While(1){ switch(j){ ca
java - 退出嵌套的 switch 语句到外部 switch 语句
我用 Java 创建了一个菜单，其中每个选项都有另一个菜单。我想知道是否可以从内部菜单退出回到主菜单。编辑:添加了主菜单选项 System.out.println("Main Menu");
Swift:在另一个 switch 语句中重构 switch 语句
我有一个计算新分数的方法。下面的方法有效，但问题是代码本身看起来可以被显着清理。我只是不知道什么是最好的方法。我根据 filterString 和枚举 individualScoreState 分配
switch-statement - Lisp 中的 switch 语句
在 Lisp 中使用字符串切换语句。 (defun switch(value) (case value (("XY") (print "XY"))
java - switch 语句，将默认设置为较早定义的 switch case？
我想做这样的事情: int i = 0; switch(difficulty) { case 1: i++; break; case 2: i--; break; defaul
switch-statement - switch 语句出错了 - swift 语言
在 Obj-c 中，我做了一个 switch 语句，我曾经使用 UIsplitviewcontroller 在我的 iPad 应用程序中四处移动现在我想快速地做同样的事情……我试了几个小时，现在我唯一
switch-statement - Latex 中的 Switch Case 条件输出
我想写一个结构如下的报告: \begin{document} \input[option=a]{class} \input[option=b]{class} \in
angularjs - "ng-switch on"和 "ng-switch"的区别
我正在认真阅读 ngSwitch 的 AngularJS API 引用。当我谈到那部分时的指令: place an expression on the on="..." attribute (or t

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c - 输入 switch case 将每个变量重置为零和一些提示