codebin.org

Untitled

By Melodic Lechwe, 5 Months ago, written in C++, viewed 81 times.
URL http://codebin.org/view/b53c6781 Shorturl http://gw.gd/RJVI Embed
Download Paste or View Raw — Expand paste to full width of browser
  1. #include <avr/io.h>
  2. #include <avr/interrupt.h>
  3. #include <avr/delay.h>
  4.  
  5. typedef unsigned char BYTE;
  6.  
  7. #define TOP_SEGMENT                             1<<PD0
  8. #define TOP_RIGHT_SEGMENT               1<<PD1
  9. #define BOTTOM_RIGHT_SEGMENT    1<<PD2
  10. #define BOTTOM_SEGMENT                  1<<PD3
  11. #define BOTTOM_LEFT_SEGMENT             1<<PD4
  12. #define TOP_LEFT_SEGMENT                1<<PD5
  13. #define MIDDLE_SEGMENT                  1<<PD6
  14.  
  15. inline void SEGMENT_ON(BYTE segment) { PORTD &= (~segment); }
  16. inline void SEGMENT_OFF(BYTE segment) { PORTD |= segment; }
  17.  
  18. #define DIGIT_SELECT_ONE                1<<PB1
  19. #define DIGIT_SELECT_TWO                1<<PB2
  20. #define DIGIT_SELECT_THREE              1<<PB3
  21. #define DIGIT_SELECT_FOUR               1<<PB4
  22. #define DIGIT_SELECT_NUM                3
  23.  
  24. inline void DIGIT_ON(BYTE digit) { PORTB |= digit; }
  25. inline void DIGIT_OFF(BYTE digit) { PORTB &= (~digit); }
  26.  
  27. //#define GET_TIMER_COUNT_FROM_MS(NumMS,Prescale) (int)((1000000.0/Prescale) / (1000.0/NumMS) - 1.0)
  28. //Let's define a variable called brightness that varies from:
  29. //5000 blindingly bright (15.7mA current draw per digit)
  30. //2000 shockingly bright (11.4mA current draw per digit)
  31. //1000 pretty bright (5.9mA)
  32. //500 normal (3mA)
  33. //200 dim but readable (1.4mA)
  34. //50 dim but readable (0.56mA)
  35. //5 dim but readable (0.31mA)
  36. //1 dim but readable in dark (0.28mA)
  37.  
  38. #define DISPLAY_BRIGHTNESS 1000
  39.  
  40. BYTE GDisplayDigits[DIGIT_SELECT_NUM];
  41.  
  42. inline void SelectDigit(BYTE digitNum)
  43. {
  44.         switch (digitNum)
  45.         {
  46.                 case 0:
  47.                         {
  48.                                 DIGIT_OFF(DIGIT_SELECT_TWO);
  49.                                 DIGIT_OFF(DIGIT_SELECT_THREE);
  50.                                 DIGIT_OFF(DIGIT_SELECT_FOUR);
  51.                                 DIGIT_ON(DIGIT_SELECT_ONE);
  52.                         }
  53.                         break;
  54.                
  55.                 case 1:
  56.                         {
  57.                                 DIGIT_OFF(DIGIT_SELECT_ONE);
  58.                                 DIGIT_OFF(DIGIT_SELECT_THREE);
  59.                                 DIGIT_OFF(DIGIT_SELECT_FOUR);
  60.                                 DIGIT_ON(DIGIT_SELECT_TWO);
  61.                         }
  62.                         break;
  63.                
  64.                 case 2:
  65.                         {
  66.                                 DIGIT_OFF(DIGIT_SELECT_ONE);
  67.                                 DIGIT_OFF(DIGIT_SELECT_TWO);
  68.                                 DIGIT_OFF(DIGIT_SELECT_FOUR);
  69.                                 DIGIT_ON(DIGIT_SELECT_THREE);                  
  70.                         }
  71.                         break;
  72.                
  73.                 case 3:
  74.                         {
  75.                                 DIGIT_OFF(DIGIT_SELECT_ONE);
  76.                                 DIGIT_OFF(DIGIT_SELECT_TWO);
  77.                                 DIGIT_OFF(DIGIT_SELECT_THREE);
  78.                                 DIGIT_ON(DIGIT_SELECT_FOUR);
  79.                         }
  80.                         break;
  81.                
  82.                 default:
  83.                         {
  84.                                 DIGIT_OFF(DIGIT_SELECT_ONE);
  85.                                 DIGIT_OFF(DIGIT_SELECT_TWO);
  86.                                 DIGIT_OFF(DIGIT_SELECT_THREE);
  87.                                 DIGIT_OFF(DIGIT_SELECT_FOUR);
  88.                         }
  89.                         break;
  90.         };
  91. }
  92.  
  93. void DisplayNumberOnSelectedDigit(BYTE number)
  94. {
  95.         switch (number)
  96.         {
  97.                 case 0:
  98.                         {
  99.                                 SEGMENT_ON(TOP_SEGMENT);
  100.                                 SEGMENT_ON(TOP_RIGHT_SEGMENT);
  101.                                 SEGMENT_ON(BOTTOM_RIGHT_SEGMENT);
  102.                                 SEGMENT_ON(BOTTOM_SEGMENT);
  103.                                 SEGMENT_ON(BOTTOM_LEFT_SEGMENT);
  104.                                 SEGMENT_ON(TOP_LEFT_SEGMENT);
  105.                                 SEGMENT_OFF(MIDDLE_SEGMENT);
  106.                         }
  107.                         break;
  108.                
  109.                 case 1:
  110.                         {
  111.                                 SEGMENT_OFF(TOP_SEGMENT);
  112.                                 SEGMENT_ON(TOP_RIGHT_SEGMENT);
  113.                                 SEGMENT_ON(BOTTOM_RIGHT_SEGMENT);
  114.                                 SEGMENT_OFF(BOTTOM_SEGMENT);
  115.                                 SEGMENT_OFF(BOTTOM_LEFT_SEGMENT);
  116.                                 SEGMENT_OFF(TOP_LEFT_SEGMENT);
  117.                                 SEGMENT_OFF(MIDDLE_SEGMENT);
  118.                         }
  119.                         break;
  120.                 case 2:
  121.                         {
  122.                                 SEGMENT_ON(TOP_SEGMENT);
  123.                                 SEGMENT_ON(TOP_RIGHT_SEGMENT);
  124.                                 SEGMENT_OFF(BOTTOM_RIGHT_SEGMENT);
  125.                                 SEGMENT_ON(BOTTOM_SEGMENT);
  126.                                 SEGMENT_ON(BOTTOM_LEFT_SEGMENT);
  127.                                 SEGMENT_OFF(TOP_LEFT_SEGMENT);
  128.                                 SEGMENT_ON(MIDDLE_SEGMENT);    
  129.                         }
  130.                         break;
  131.                 case 3:
  132.                         {
  133.                                 SEGMENT_ON(TOP_SEGMENT);
  134.                                 SEGMENT_ON(TOP_RIGHT_SEGMENT);
  135.                                 SEGMENT_ON(BOTTOM_RIGHT_SEGMENT);
  136.                                 SEGMENT_ON(BOTTOM_SEGMENT);
  137.                                 SEGMENT_OFF(BOTTOM_LEFT_SEGMENT);
  138.                                 SEGMENT_OFF(TOP_LEFT_SEGMENT);
  139.                                 SEGMENT_ON(MIDDLE_SEGMENT);
  140.                         }
  141.                         break;
  142.                 case 4:
  143.                         {
  144.                                 SEGMENT_OFF(TOP_SEGMENT);
  145.                                 SEGMENT_ON(TOP_RIGHT_SEGMENT);
  146.                                 SEGMENT_ON(BOTTOM_RIGHT_SEGMENT);
  147.                                 SEGMENT_OFF(BOTTOM_SEGMENT);
  148.                                 SEGMENT_OFF(BOTTOM_LEFT_SEGMENT);
  149.                                 SEGMENT_ON(TOP_LEFT_SEGMENT);
  150.                                 SEGMENT_ON(MIDDLE_SEGMENT);
  151.                         }
  152.                         break;
  153.                 case 5:
  154.                         {
  155.                                 SEGMENT_ON(TOP_SEGMENT);
  156.                                 SEGMENT_OFF(TOP_RIGHT_SEGMENT);
  157.                                 SEGMENT_ON(BOTTOM_RIGHT_SEGMENT);
  158.                                 SEGMENT_ON(BOTTOM_SEGMENT);
  159.                                 SEGMENT_OFF(BOTTOM_LEFT_SEGMENT);
  160.                                 SEGMENT_ON(TOP_LEFT_SEGMENT);
  161.                                 SEGMENT_ON(MIDDLE_SEGMENT);
  162.                         }
  163.                         break;
  164.                 case 6:
  165.                         {
  166.                                 SEGMENT_ON(TOP_SEGMENT);
  167.                                 SEGMENT_OFF(TOP_RIGHT_SEGMENT);
  168.                                 SEGMENT_ON(BOTTOM_RIGHT_SEGMENT);
  169.                                 SEGMENT_ON(BOTTOM_SEGMENT);
  170.                                 SEGMENT_ON(BOTTOM_LEFT_SEGMENT);
  171.                                 SEGMENT_ON(TOP_LEFT_SEGMENT);
  172.                                 SEGMENT_ON(MIDDLE_SEGMENT);
  173.                         }
  174.                         break;
  175.                 case 7:
  176.                         {
  177.                                 SEGMENT_ON(TOP_SEGMENT);
  178.                                 SEGMENT_ON(TOP_RIGHT_SEGMENT);
  179.                                 SEGMENT_ON(BOTTOM_RIGHT_SEGMENT);
  180.                                 SEGMENT_OFF(BOTTOM_SEGMENT);
  181.                                 SEGMENT_OFF(BOTTOM_LEFT_SEGMENT);
  182.                                 SEGMENT_OFF(TOP_LEFT_SEGMENT);
  183.                                 SEGMENT_OFF(MIDDLE_SEGMENT);
  184.                         }
  185.                         break;
  186.                 case 8:
  187.                         {
  188.                                 SEGMENT_ON(TOP_SEGMENT);
  189.                                 SEGMENT_ON(TOP_RIGHT_SEGMENT);
  190.                                 SEGMENT_ON(BOTTOM_RIGHT_SEGMENT);
  191.                                 SEGMENT_ON(BOTTOM_SEGMENT);
  192.                                 SEGMENT_ON(BOTTOM_LEFT_SEGMENT);
  193.                                 SEGMENT_ON(TOP_LEFT_SEGMENT);
  194.                                 SEGMENT_ON(MIDDLE_SEGMENT);
  195.                         }
  196.                         break;
  197.                 case 9:
  198.                         {
  199.                                 SEGMENT_ON(TOP_SEGMENT);
  200.                                 SEGMENT_ON(TOP_RIGHT_SEGMENT);
  201.                                 SEGMENT_ON(BOTTOM_RIGHT_SEGMENT);
  202.                                 SEGMENT_ON(BOTTOM_SEGMENT);
  203.                                 SEGMENT_OFF(BOTTOM_LEFT_SEGMENT);
  204.                                 SEGMENT_ON(TOP_LEFT_SEGMENT);
  205.                                 SEGMENT_ON(MIDDLE_SEGMENT);
  206.                         }
  207.                         break;
  208.                 default:
  209.                         {
  210.                                 SEGMENT_OFF(TOP_SEGMENT);
  211.                                 SEGMENT_OFF(TOP_RIGHT_SEGMENT);
  212.                                 SEGMENT_OFF(BOTTOM_RIGHT_SEGMENT);
  213.                                 SEGMENT_OFF(BOTTOM_SEGMENT);
  214.                                 SEGMENT_OFF(BOTTOM_LEFT_SEGMENT);
  215.                                 SEGMENT_OFF(TOP_LEFT_SEGMENT);
  216.                                 SEGMENT_OFF(MIDDLE_SEGMENT);
  217.                         }
  218.                         break;
  219.         };
  220. }
  221.  
  222. void SetNumberToDisplay(int16_t number)
  223. {
  224. #if DIGIT_SELECT_NUM == 4
  225.         GDisplayDigits[0] = number / 1000;
  226.         number -= GDisplayDigits[0]*1000;
  227.         GDisplayDigits[1] = number / 100;
  228.         number -= GDisplayDigits[1]*100;
  229.         GDisplayDigits[2] = number / 10;
  230.         number -= GDisplayDigits[2]*10;
  231.         GDisplayDigits[3] = number / 1;
  232. #elif DIGIT_SELECT_NUM == 3
  233.         GDisplayDigits[0] = number / 100;
  234.         number -= GDisplayDigits[0]*100;
  235.         GDisplayDigits[1] = number / 10;
  236.         number -= GDisplayDigits[1]*10;
  237.         GDisplayDigits[2] = number / 1;
  238. #else
  239.         #error digit select num define not 3 or 4
  240. #endif
  241. }
  242.  
  243. void DisplayCurrentNumber()
  244. {      
  245.         for (BYTE digit = 0; digit < DIGIT_SELECT_NUM; ++digit)
  246.         {
  247.                 SelectDigit(digit);
  248.                 DisplayNumberOnSelectedDigit(GDisplayDigits[digit]);
  249.                 _delay_us(DISPLAY_BRIGHTNESS);
  250.         }
  251.  
  252.         SelectDigit(-1);
  253. }
  254.  
  255. int ADCsingleREAD(uint8_t adcToUse)
  256. {
  257.         int ADCval;
  258.  
  259.         ADMUX &= (0b11111000); //Clear out the channels we're reading
  260.         ADMUX |= adcToUse;     //Set the new channel we're going to read
  261.        
  262.         ADCSRA |= (1 << ADSC);    // Start the ADC conversion
  263.  
  264.         while(!(ADCSRA & (1 << ADIF)));      // Wait for the ADC to finish
  265.        
  266.         //Clear ADIF by writing one to it
  267.         ADCSRA|=(1<<ADIF);
  268.  
  269.         ADCval = ADCL;
  270.         ADCval = (ADCH << 8) + ADCval;    // ADCH is read so ADC can be updated again
  271.  
  272.         return ADCval;
  273. }
  274.  
  275. int main(void)
  276. {
  277.         DDRD = TOP_SEGMENT | TOP_RIGHT_SEGMENT | BOTTOM_RIGHT_SEGMENT | BOTTOM_SEGMENT | BOTTOM_LEFT_SEGMENT | TOP_LEFT_SEGMENT | MIDDLE_SEGMENT;
  278.         DDRB = DIGIT_SELECT_ONE | DIGIT_SELECT_TWO | DIGIT_SELECT_THREE | DIGIT_SELECT_FOUR;
  279.         PORTD = 0;
  280.         PORTB = 0;
  281.        
  282.         //Initialize the analog to digital converter
  283.         ADMUX = (1 << REFS0); // use AVcc as the reference
  284.         ADMUX &= ~(1 << ADLAR);   // clear for 10 bit resolution
  285.         ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1); // 64 prescale for 8Mhz and enabled the ADC with ADEN
  286.        
  287.         while(1)
  288.     {
  289.                 int moistureSensorValue = ADCsingleREAD(ADC5D);
  290. #if DIGIT_SELECT_NUM == 4
  291.                 if (moistureSensorValue > 9999 || moistureSensorValue < 0)
  292.                         moistureSensorValue = 9999;
  293. #elif DIGIT_SELECT_NUM == 3            
  294.                 if (moistureSensorValue > 999 || moistureSensorValue < 0)
  295.                         moistureSensorValue = 999;
  296. #else
  297. #error unknown digit select num
  298. #endif
  299.                
  300.                 const float runningAverageLERP = 0.95f;
  301.                 float moistureSensorValueAve = runningAverageLERP*moistureSensorValueAve + (1.0f-runningAverageLERP)*moistureSensorValue;
  302.                 SetNumberToDisplay((int16_t)moistureSensorValueAve);
  303.                 DisplayCurrentNumber();
  304.     }
  305. }

Reply to "Untitled"

Here you can reply to the paste above

codebin.org 2012
faq | twitter