⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 tubeavr.c

📁 DMX512控制器源程序
💻 C
字号:

/*=====================================================*/
/* 1. This Program Use ICCAVR 6.31A  Compile   System  */
/* 2. Make Use Of Attiny2313 Singlechip Fosc = 16MHz   */
/* 3. Last Modified : 2006-09-16 15:54                 */
/* 4  Version Number : V1.0                            */
/* 5. Editor :  LONG  CHUAN  LAO.                      */
/*=====================================================*/
   #include <iot2313v.h>
   #include <macros.h>
   
   #define       Uint        unsigned  int
   #define       ULint       unsigned  long int   
   #define       Uchar       unsigned  char
     
   //  1ms --- 1333  //
   #define       Max_Level         255
             
   //    前导码   //
   #define       Image             0xAA   
   #define       Write_Code        0xC3      
   #define       Switch_Bus        0xD4   
   #define       Dmx               0x00    
   #define       Pixel             0x10
   
   #define  Seven_Color_Change_Time    50000
   
   Uchar   const   Verify[ 8 ] = {
                                   0x01 , 0x23 , 0x45 , 0x67 , 
                                   0x89 , 0xAB , 0xCD , 0xEF ,  
                                 } ;   								 
   Uint    Sect_Channel_Count ;   
   Uint    Sect1_Start_Channel[ 4 ] ;
   Uint    Seven_Color_Change_Count ;   
//---------------------------//   
   Uchar   Nodes ;   
   Uchar   Row_Number ;   
   Uchar   Col_Number ;
   Uint    Address_Number ;
//---------------------------//
   Uchar   Mode ;         
   Uchar   Step ;      
   Uchar   Choose ;
   Uchar   Pass_Fg ;   
   Uchar   Byte_Count ;
   Uchar   Gray_Level_Count ;                  
//---------------------------//
   char    Cycle ;
   Uchar   Array[ 3 ] ;	  

Uchar Read_Eeprom( Uchar Address ) 
{
  while( EECR & 0x02 ) ;
  EEAR   =  Address ;
  EECR  |= 0x01 ;
  return  EEDR ;
}

void Write_Eeprom( Uchar Address , Uchar Datum ) 
{
  while( EECR & 0x02 ) ;
  EEAR   =  Address ;
  EEDR   =  Datum ;
  EECR  |= 0x04 ;
  EECR  |= 0x02 ;    
}
void port_init(void)
{ 
 PORTA = 0xFF;
 DDRA  = 0xFF; 
 PORTB = 0xFF;
 DDRB  = 0xFF; 
 PORTD = 0xFF;
 DDRD  = 0xFF; 
}
//UART0 initialize
// desired baud rate: 250000
// actual: baud rate:250000 (0.0%)
// char size: 9 bit
// parity: Disable

void uart0_init(void)
{
 UCSRB = 0x00; //disable while setting baud rate
 UBRRH = 0x00; //set baud rate upper
 UBRRL = 0x03; //set baud rate lower
 UCSRA = 0x00;
 UCSRC = 0x06;
 UCSRB = 0x9C; //enable
}

void Init_Devices( void )
{
 //stop errant interrupts until set up
 CLI(); //disable all interrupts 
 port_init();
 uart0_init();
 
 WDR(); //this prevents a timout on enabling
 WDTCR = 0x18; //WATCHDOG ENABLED - dont forget WDR
 WDTCR = 0x0A; //64ms
 
 MCUCR = 0x00;
 GIMSK = 0x00;
 TIMSK = 0x00;
 SEI(); //re-enable interrupts
 //all peripherals are now initialized
}

void  Gray_Scan_Disp( void )
{
    if( -- Gray_Level_Count == 0x00 )
        Gray_Level_Count = Max_Level ;
//------------------------------------------//
//   PB2 -----  Red      0x04  0xFB 
//   PB3 -----  Green    0x08  0xF7
//   PB4 -----  Blue     0x10  0xEF
/*		
    if( Gray_Level_Count >  Array[ 0 ] )
	    PORTB   &=   0xFB ;
	else
	    PORTB   |=   0x04 ;
		
    if( Gray_Level_Count >  Array[ 1 ] )
	    PORTB   &=   0xF7 ;
	else
	    PORTB   |=   0x08 ;
		
    if( Gray_Level_Count >  Array[ 2 ] )
	    PORTB   &=   0xEF ;
	else
	    PORTB   |=   0x10 ;
*/				
//------------------------------------------//

//   PB5 -----  Red      0x20  0xDF 
//   PB6 -----  Green    0x40  0xBF
//   PB7 -----  Blue     0x80  0x7F
		
    if( Gray_Level_Count >  Array[ 0 ] )
	    PORTB   &=   0xDF ;
	else
	    PORTB   |=   0x20 ;
		
    if( Gray_Level_Count >  Array[ 1 ] )
	    PORTB   &=   0xBF ;
	else
	    PORTB   |=   0x40 ;
		
    if( Gray_Level_Count >  Array[ 2 ] )
	    PORTB   &=   0x7F ;
	else
	    PORTB   |=   0x80 ;
				
//------------------------------------------//		
		
}


#pragma interrupt_handler Serial:8  
void   Serial( void )    
{ 
       Uchar   Temp ;
	   
	   Temp = UDR ;
			       
       if( ( UCSRB | 0xFD ) == 0xFD )
	     {
		   Step = 0 ; 
		   switch( UDR )
		      {
			     case  Image:
                               Step = 1 ;  				 
				               break ;
			     case  Dmx  :
                               Step = 7 ;				 
				               break ;
			  } 
         }
	   else
        { 
           switch( Step )
                 {
//----------------------------------------------------------// 
        	       case  1 :
				            Step = 0 ;
				            Temp = UDR ;							
      			            switch( Temp ) 
            					  {
                        		    case  Switch_Bus   : 
									                       Step = 2 ;
									                       Byte_Count = 0 ;														   				
                          			                       break ;														   												   													   
                        		    case  Write_Code   :  
									                       Step = 3 ;														   
                          			                       break ;
            					  } 
         		            break ;							
//----------------------------------------------------------//
        	       case  2 :
				            if( Byte_Count == UDR )
							  {
                                if( ++ Byte_Count >= 201 && ( Pass_Fg & 0x01 )== 0x00 )
								  {
								    Pass_Fg ++ ;
								  }
							  }  
						    else
    				            Step =  0 ;
							break ;
//----------------------------------------------------------//						
        	       case  3:
				            Step = 4 ;										            
				            Row_Number = UDR ;							       
         		            break ;
        	       case  4:
				            Step = 5 ;										              
				            Col_Number = UDR ;						
         		            break ;
        	       case  5:
				            Step = 6 ;						
							Nodes = UDR ;
							Byte_Count = 0 ;
         		            break ;
        	       case  6:		
				            if( UDR == Verify[ Byte_Count ] )
							  {
                                if( ++ Byte_Count >= 8 && ( Pass_Fg & 0x01 )== 0x01 )
								  {
         				            Step = 0 ;							
                                    Pass_Fg -- ;
                                    Pass_Fg |= 0x80 ;									
								  }
							  }  
						    else
							  {   //  RESET  //
    				            Step =  0 ;								
                                Pass_Fg = 0 ;	
							  }				   		   
         		            break ;														
//----------------------------------------------------------//
        	       case  7 :							
                            if( UDR == 0x00 )
							    Step = 8 ;
						    else
							    Step = 0 ;							 	
         		            break ;							
        	       case  8 :
				            Temp = UDR & 0xF0 ;
						    Choose = UDR & 0x03 ;							
							if( Temp == Pixel )
							  {
								Step = 9 ;	   		
								Byte_Count = 0 ;					  
								Sect_Channel_Count = 3 ;
							  }						
							else
							  {
    				            Step = 0 ;							  
							  }								   				   							
         		            break ;															
     			   case  9 : 
     			            if( Sect_Channel_Count >= Sect1_Start_Channel[ Choose ] )
          					  {
                                Array[ Byte_Count ] = UDR ;
                                if( ++ Byte_Count >= 3 )
								  {
									Step = 0 ;
                                    Pass_Fg = 0 ;									
								  }							
					          }
							else
							  {
                                Sect_Channel_Count ++ ;							  
							  }
         		            break ;
                 } 
        }            
}

void  Calculator( void )
{
      Address_Number  = Row_Number - 1 ;		                                       
      Address_Number *= Nodes ;
      Address_Number += Col_Number ;   
			
	  Sect1_Start_Channel[ 0 ]  = Row_Number << 1 ;  
	  Sect1_Start_Channel[ 0 ] += Row_Number ;              // x  3 			
			
	  Sect1_Start_Channel[ 1 ]  = Col_Number << 1 ;  
   	  Sect1_Start_Channel[ 1 ] += Col_Number ;              // x  3 			
											   
	  Sect1_Start_Channel[ 2 ]  = Address_Number << 1 ;  
	  Sect1_Start_Channel[ 2 ] += Address_Number ;              // x  3				

	  Sect1_Start_Channel[ 3 ]  = 0x00 ;             	  
}

  main( void )
       {
			WDR( ) ;
            Init_Devices(  ) ;			
			Gray_Level_Count = Max_Level ;						
							
			Pass_Fg = 0x10 ;				
            Nodes = Read_Eeprom( 0x06 ) ;																				
            Row_Number = Read_Eeprom( 0x07 ) ;						  
            Col_Number = Read_Eeprom( 0x08 ) ;									  										  										  
			
			Calculator(  ) ;
                do{
           			WDR( ) ;
                    Gray_Scan_Disp(  ) ;
                    switch( Pass_Fg )
					   {
					        case  0x80 :
                        				  Pass_Fg = 0 ;
																
							  			  Calculator(  ) ;
										  
                                		  Array[ 0 ] = 0 ; 
                            			  Array[ 1 ] = 0 ;
			                              Array[ 2 ] = 255 ;									  
																				
                                          Write_Eeprom( 0x06 , Nodes ) ;																				
                                          Write_Eeprom( 0x07 , Row_Number ) ;						  
                                          Write_Eeprom( 0x08 , Col_Number ) ;									  										  										  
							 
							              break ;
					        case  0x10 :										  	
                                          if( Seven_Color_Change_Count == 0 )
                                   		    {
                                    		  Seven_Color_Change_Count = Seven_Color_Change_Time ;
                                			  if( ++ Mode > 7 )
                                  			      Mode = 1 ;
                                			  if( Mode & 0x01 )
                                				  Array[ 0 ] = 0xFF ;
                                     	  	  else
                                				  Array[ 0 ] = 0x00 ;
												  
                                			  if( Mode & 0x02 )
                                				  Array[ 1 ] = 0xFF ;
                                     	  	  else
                                				  Array[ 1 ] = 0x00 ;
												  
                                			  if( Mode & 0x04 )
                                				  Array[ 2 ] = 0xFF ;
                                     	  	  else
                                				  Array[ 2 ] = 0x00 ;											
											}
										  else
										    {
                                              Seven_Color_Change_Count -- ; 											
											}
												  
							              break ;										  							  
					   }					   
//--------------------------------------------------//						  
                  }while( 1 ) ;     ///  while( 1 )  end 
       }                ///  main        end

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -