Skip to main content

Control Unit (CodevisionAVR)

  1. #include <mega8515.h>
  2. //8MHz CB1 final 29 April without pulse strecher
  3. #include<stdio.h>                        
  4. #include<delay.h>
  5. // Declare your global variables here
  6.        char a;    
  7.        bit dlag,ulag;
  8.        char str[16];  
  9.        int dly=0;  
  10.        
  11. void blink();    
  12. void blink2();    
  13. void main(void)
  14. {
  16. DDRB=0xFF;
  18. DDRC=0x80;
  20. PORTC=0x00;
  21. ACSR=0x80;    
  22.     while (1)
  23.       {
  24.      
  25.       a=PINC;    
  26.       a^=0x70;    
  27.            
  28.    if(a&0x20)       {PORTB=0x02;    blink2();    
  29.           }    
  30.    
  32.    else if(a&0x40)  {PORTB=0x01;    blink2();    
  33.          }
  34.    else if(a&0x10)  {PORTB=0x00;    blink2();  
  35.             }
  36.    else
  37.    {  
  38.        if(a)
  39.        {
  40.         switch(a)
  41.             {
  42.             case 1: //Move Down  
  43.                     PORTB=0x06;;  
  44.                     delay_ms(200);
  45.                     dly=0;
  46.            
  47.                  break;    
  48.                  
  49.             case 3: //Move Down Sort Steps
  50.                     PORTB=0x06;    
  51.                     delay_ms(100);    
  52.                     dly=0;
  53.                        
  54.                   break;  
  55.                  
  56.              ////////////////////////////////////
  57.                  
  58.                      
  59.             case 2: //Move Down Long Steps          
  60.             if(ulag)
  61.             {
  62.              delay_ms(250); ulag=0;
  63.             }
  64.             else
  65.             {        PORTB=0x06;    
  66.                     delay_ms(35);    
  67.                     dly=15;   dlag=1;
  68.              }      
  69.                   break;                  
  70.             /////////////////////////////////
  71.             case 6: //Don't move
  72.                           PORTB=0x08;    delay_ms(200);  
  73.                               dly=10;       ulag=0; dlag=0;
  74.                    break;
  75.             ///////////////////////////////////////////      
  76.             case 4: //Move Up in Steps    
  77.             if(dlag)
  78.             { delay_ms(250); dlag=0;
  79.             }
  80.             else
  81.             {                        
  82.                              PORTB=0x11;     delay_ms(35);  
  83.                                dly=15; ulag=1;
  84.              }                  
  85.                     break;
  86.              
  87.              ////////////////////////////////////////////
  88.                                                                                    
  89.                          
  90.                              
  91.             case 12: //Move Up in Short steps
  92.                                PORTB=0x11;      delay_ms(90);  
  93.                                   dly=0;
  94.                      break;          
  95.             case 8:  //Move Up in Long Steps  
  96.                                 PORTB=0x11;     delay_ms(190);
  97.                                     dly=0;
  98.             //Long or Short steps is controlled by the time delay
  99.             }
  100.        
  101.        }
  102.        else
  103.        {
  104.        //Make all OFF
  105.        PORTB=0;
  106.        delay_ms(dly);
  107.        }                                      
  108.    
  109.        }    
  110.        
  111.        
  112.       };    
  113. }
  114.    void blink()
  115. {  
  117. a&=0x0F;
  118. switch(a)
  119.             {
  120.             case 1: //Move Down  
  121.                     PORTB=0x04;;  
  122.                     delay_ms(200);
  123.                     dly=0;
  124.            
  125.                  break;    
  126.                  
  127.             case 3: //Move Down Sort Steps
  128.                     PORTB=0x04;    
  129.                     delay_ms(100);    
  130.                     dly=0;
  131.                        
  132.                   break;  
  133.                  
  134.              //////////////////////////////////////////
  135.                  
  136.                      
  137.             case 2: //Move Down Long Steps          
  138.                PORTB=0x04;    
  139.                     delay_ms(50);    
  140.                     dly=15;  
  141.                   break;                  
  142.             ///////////////////////////////////
  143.             case 6: //Don't move
  144.                           PORTB=0x08;    delay_ms(80);  
  145.                               dly=10;  
  146.                    break;
  147.             ///////////////////////////////////
  148.             case 4: //Move Up in Steps    
  149.                              
  150.                              PORTB=0x10;     delay_ms(50);  
  151.                
  152.                     break;
  153.                  
  154.              //////////////////////////////////
  155.                          
  156.             case 12: //Move Up in Short steps
  157.                                PORTB=0x10;      delay_ms(90);  
  158.                                   dly=0;
  159.                      break;          
  160.             case 8:  //Move Up in Long Steps  
  161.                                 PORTB=0x10;     delay_ms(190);
  162.                                     dly=0;
  163.             //Long or Short steps is controlled by the time delay
  164.             }
  165. }                            
  167.       void blink2()
  168. {  
  170. a&=0x0F;
  171. switch(a)
  172.             {
  173.             case 1: //Move Down  
  174.                     PORTB.2=1;  
  175.                     delay_ms(200);
  176.                     dly=0;
  177.            
  178.                  break;    
  179.                  
  180.             case 3: //Move Down Sort Steps
  181.                     PORTB.2=1;    
  182.                     delay_ms(100);    
  183.                     dly=0;
  184.                        
  185.                   break;  
  186.                  
  187.              /////////////////////////////////
  188.                  
  189.                      
  190.             case 2: //Move Down Long Steps          
  191.                PORTB.2=1;    
  192.                     delay_ms(50);    
  193.                     dly=15;  
  194.                   break;                  
  195.             ////////////////////////////////
  196.             case 6: //Don't move
  197.                           PORTB.3=1;    delay_ms(80);  
  198.                               dly=10;  
  199.                    break;
  200.             /////////////////////////////////////
  201.             case 4: //Move Up in Steps    
  202.                              
  203.                              PORTB.4=1;     delay_ms(50);  
  204.                
  205.                     break;
  206.                
  207.              ////////////////////////////////////
  208.                                                                                    
  209.                          
  210.                              
  211.             case 12: //Move Up in Short steps
  212.                                PORTB.4=1;      delay_ms(90);  
  213.                                   dly=0;
  214.                      break;          
  215.             case 8:  //Move Up in Long Steps  
  216.                                 PORTB.4=1;     delay_ms(190);
  217.                                     dly=0;
  218.             //Long or Short steps is controlled by the time delay
  219.             }
  220. }                            

Comments

Post a Comment

Popular posts from this blog

Questions

1. What is a Stub function? Ans : A function without any definition which presents no error when called. 2. Why there are two ld scripts generated by STM32Cube IDE? Ans: The CubeIDE always presents two different LDscripts on for generating the executable for Debugging which goes to RAM another for normal code upload that goes to flash memory. 3. What is Supervisory Mode/ privileged mode ? Ans : When you are using a Kernel then there are two modes user mode and privileged mode. In User mode the applications cant have system calls. 4. What is "make -j6" ? Ans : Make has an argument for number of jobs, so when you add -j6 it will create 6 different compiler instances, so that the systems could use multicore to the fullest.  Linux people generally do add "-j $(nproc)" where nproc is a command line which returns number of processors attached. 5. What is weak attribute ? Ans : Weak attribute used to denote weak symbols which helps linkers to choose one function out of mul...
Post a Comment
Read more

#@$%

  #include  "msp430x21x2.h"     #define PWM_OUTPUT              0x03 #define DUTY_CYCLE              TA0CCR2 #define MAX_LIMIT               300   /* #define no_of_samples           1 #define duty_cycle_limit        1000 #define temp_sensor             0xA000   #define panel_selection_cutoff  250 */ #define PV_VOLTAGE              INCH_0 #define PV_CURRENT              INCH_1 #define BATT_VOLTAGE            INCH_2 #define BATT_CURRENT            INCH_3   #define UPPER_CRG_LVL           0x0105 // 0x00FF // 0x00F5 //0x023A #define LOWER_CRG_LVL   ...
Post a Comment
Read more

STM32 Port configuration via structures

 How Does STM32CubeIDE   /*Configure GPIO pin : Pd3 */   GPIO_InitStruct.Pin = GPIO_PIN_3;   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;   GPIO_InitStruct.Pull = GPIO_NOPULL;   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;   HAL_GPIO_Init(GPIOd, &GPIO_InitStruct);  Now what is GPIOD and GPIO_InitStruct GPIOD the definition is deep inside CMSIS "Drivers\CMSIS\Device\ST\STM32F4xx\Include\stm32f411xe.h" #define GPIOD               ((GPIO_TypeDef *) GPIOD_BASE) and  GPIOD_BASE declared in same file #define GPIOD_BASE            (AHB1PERIPH_BASE + 0x0C00UL) Now GPIO_InitStruct is comes from  the line GPIO_InitTypeDef GPIO_InitStruct = {0};  so the structure GPIO_InitTypeDef is as follows as defined in  typedef struct {   uint32_t Pin; /*!< Specifies the GPIO pins to be configured.     This parameter can be any value of @ref GPIO_p...
Post a Comment
Read more