API tools faq
paste
Advertisement
anticlown

firmware prototype for memory check

anticlown
Nov 19th, 2023 (edited)
1,042
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 10.02 KB | None | 0 0
raw download clone embed print report
  1. #include <mega328p.h>
  2. #include <delay.h>
  3. #include <stdlib.h>
  4.  
  5. //заменили названия портов микроконтроллера названиями контактов платы, к которым ведут порты
  6. #define E PORTB.4
  7. #define D PORTC.5
  8. #define W PORTD.4
  9. #define Q PORTD.5
  10.  
  11. #define A5 PORTC.0
  12. #define A6 PORTC.1
  13. #define A9 PORTC.2
  14. #define A8 PORTC.3
  15. #define A7 PORTC.4
  16.  
  17. #define A4 PORTB.5
  18. #define A3 PORTB.0
  19. #define A2 PORTB.1
  20. #define A1 PORTB.2
  21. #define A0 PORTB.3
  22.  
  23.  
  24. #define A11 PORTD.6
  25. #define A10 PORTD.7
  26.  
  27.  
  28.  
  29. #define ACmp(Value) if(Value != 0){\
  30.     Value = 1;\
  31. }
  32.  
  33. //процедура для побитового выставления адреса в каждый из портов адреса
  34. #define A(offset) A0 = offset & 0b00000000000000000000000000000001; ACmp(A0); \
  35.    A1 = offset & 0b00000000000000000000000000000010; ACmp(A1); \
  36.     A2 = offset & 0b00000000000000000000000000000100; ACmp(A2); \
  37.     A3 = offset & 0b00000000000000000000000000001000; ACmp(A3); \
  38.     A4 = offset & 0b00000000000000000000000000010000; ACmp(A4); \
  39.     A5 = offset & 0b00000000000000000000000000100000; ACmp(A5); \
  40.     A6 = offset & 0b00000000000000000000000001000000; ACmp(A6); \
  41.     A7 = offset & 0b00000000000000000000000010000000; ACmp(A7); \            
  42.     A8 = offset & 0b00000000000000000000000100000000; ACmp(A8); \
  43.     A9 = offset & 0b00000000000000000000001000000000; ACmp(A9); \
  44.    A10 = offset & 0b00000000000000000000010000000000; ACmp(A10); \
  45.    A11 = offset & 0b00000000000000000000100000000000; ACmp(A11);  
  46.    
  47. #define DELAY(maxValue)  for(delayVar = 0; delayVar < maxValue; delayVar++);  //Макрос для задержек, меньших 1мс
  48.  
  49. #define BLINK(range) for (counter = 0; counter < range * 2; counter++) { \  //Макрос для моргания светодиодом. BLINK(1) - одно моргание(вкл + выкл)                                                                          
  50.         delay_ms(500); \
  51.         PORTB.5 = PORTB.5 ^ 1; }
  52.  
  53.  
  54. unsigned  delayVar;
  55.  
  56. void writeCycle(const unsigned value, const unsigned diapasonStart, const unsigned diapasonEnd) { //Запись в память с offset = diapasonStart по offset = diapasonEnd значения = Value
  57.     unsigned dataOffset = diapasonStart; //dataOffset хранит адрес текущей ячейки памяти  
  58.     D = value;
  59.     E = 0;    
  60.    
  61.     while (dataOffset <= diapasonEnd) { //записываем, пока смещение не дойдет до нужной ячейки
  62.         E = 1;                  //  \
  63.                                  //   \
  64.         W = 1;                  //    \
  65.                                 //     \
  66.                                   //      - значения на портах E,D,Q,W выставляются в соответствии с временной диаграммой
  67.         A(dataOffset)           //     /
  68.         E = 0;                  //    /
  69.                                   //   /
  70.         W = 0;                  //  /
  71.    
  72.        
  73.         dataOffset = dataOffset + 1; //увеличиваем смещение на 1, dataOffset хранит адрес следующей ячейки
  74.     }
  75. }
  76.  
  77. unsigned checkIsCorrect(const unsigned value,  unsigned diapasonStart, unsigned diapasonEnd) { //Все ли значения равны заданному value, возвращает количество ошибок
  78.                                                                                               //( 0 - нет ошибок, все значения ячеек сошлись)
  79.     unsigned errorCounterPTR = 0; //переменная для подсчета количества ошибок
  80.     unsigned dataOffset = diapasonStart; //dataOffset хранит адрес текущей ячейки памяти      
  81.     E = 0;
  82.     W = 1;
  83.  
  84.     while (dataOffset <= diapasonEnd) {  //считываем, пока смещение не дойдет до нужной ячейки
  85.         E = 1;
  86.         DELAY(100);
  87.         A(dataOffset)  
  88.         DELAY(100);          
  89.         E = 0;            
  90.         DELAY(1000);
  91.        
  92.         if (Q != value) //если значение на порте входа данных не сходится с тем, что проверяем
  93.                         //(Например, если на Q сигнал 0, а мы проверяем на value = 1, то увеличиваем счетчик ошибок на 1)
  94.             errorCounterPTR = errorCounterPTR + 1;
  95.                            
  96.         DELAY(100);
  97.         dataOffset = dataOffset + 1;
  98.         DELAY(100);
  99.     }
  100.     return errorCounterPTR;
  101. }
  102.  
  103. void main(void)
  104. {
  105.     unsigned numberOfErrors; //указатель на число для хранения количества ошибок
  106.     unsigned counter; //счетчик, используемый в BLINK()  
  107.        
  108.        
  109. // Crystal Oscillator division factor: 1
  110. #pragma optsize-
  111. CLKPR=(1<<CLKPCE);
  112. CLKPR=(0<<CLKPCE) | (0<<CLKPS3) | (0<<CLKPS2) | (0<<CLKPS1) | (0<<CLKPS0);
  113. #ifdef _OPTIMIZE_SIZE_
  114. #pragma optsize+
  115. #endif
  116.  
  117. // Input/Output Ports initialization
  118. // Port B initialization
  119. // Function: Bit7=Out Bit6=Out Bit5=Out Bit4=Out Bit3=Out Bit2=Out Bit1=Out Bit0=Out
  120. DDRB=(1<<DDB7) | (1<<DDB6) | (1<<DDB5) | (1<<DDB4) | (1<<DDB3) | (1<<DDB2) | (1<<DDB1) | (1<<DDB0);
  121. // State: Bit7=0 Bit6=0 Bit5=0 Bit4=0 Bit3=0 Bit2=0 Bit1=0 Bit0=0
  122. PORTB=(0<<PORTB7) | (0<<PORTB6) | (0<<PORTB5) | (0<<PORTB4) | (0<<PORTB3) | (0<<PORTB2) | (0<<PORTB1) | (0<<PORTB0);
  123.  
  124. // Port C initialization
  125. // Function: Bit6=Out Bit5=Out Bit4=Out Bit3=Out Bit2=Out Bit1=Out Bit0=Out
  126. DDRC=(1<<DDC6) | (1<<DDC5) | (1<<DDC4) | (1<<DDC3) | (1<<DDC2) | (1<<DDC1) | (1<<DDC0);
  127. // State: Bit6=0 Bit5=0 Bit4=0 Bit3=0 Bit2=0 Bit1=0 Bit0=0
  128. PORTC=(0<<PORTC6) | (0<<PORTC5) | (0<<PORTC4) | (0<<PORTC3) | (0<<PORTC2) | (0<<PORTC1) | (0<<PORTC0);
  129.  
  130. // Port D initialization
  131. // Function: Bit7=Out Bit6=Out Bit5=In Bit4=Out Bit3=Out Bit2=Out Bit1=Out Bit0=Out
  132. DDRD=(1<<DDD7) | (1<<DDD6) | (0<<DDD5) | (1<<DDD4) | (1<<DDD3) | (1<<DDD2) | (1<<DDD1) | (1<<DDD0);
  133. // State: Bit7=0 Bit6=0 Bit5=T Bit4=0 Bit3=0 Bit2=0 Bit1=0 Bit0=0
  134. PORTD=(0<<PORTD7) | (0<<PORTD6) | (0<<PORTD5) | (0<<PORTD4) | (0<<PORTD3) | (0<<PORTD2) | (0<<PORTD1) | (0<<PORTD0);
  135.  
  136.  
  137. // Timer/Counter 0 initialization
  138. // Clock source: System Clock
  139. // Clock value: Timer 0 Stopped
  140. // Mode: Normal top=0xFF
  141. // OC0A output: Disconnected
  142. // OC0B output: Disconnected
  143. TCCR0A=(0<<COM0A1) | (0<<COM0A0) | (0<<COM0B1) | (0<<COM0B0) | (0<<WGM01) | (0<<WGM00);
  144. TCCR0B=(0<<WGM02) | (0<<CS02) | (0<<CS01) | (0<<CS00);
  145. TCNT0=0x00;
  146. OCR0A=0x00;
  147. OCR0B=0x00;
  148.  
  149. // Timer/Counter 1 initialization
  150. // Clock source: System Clock
  151. // Clock value: Timer1 Stopped
  152. // Mode: Normal top=0xFFFF
  153. // OC1A output: Disconnected
  154. // OC1B output: Disconnected
  155. // Noise Canceler: Off
  156. // Input Capture on Falling Edge
  157. // Timer1 Overflow Interrupt: Off
  158. // Input Capture Interrupt: Off
  159. // Compare A Match Interrupt: Off
  160. // Compare B Match Interrupt: Off
  161. TCCR1A=(0<<COM1A1) | (0<<COM1A0) | (0<<COM1B1) | (0<<COM1B0) | (0<<WGM11) | (0<<WGM10);
  162. TCCR1B=(0<<ICNC1) | (0<<ICES1) | (0<<WGM13) | (0<<WGM12) | (0<<CS12) | (0<<CS11) | (0<<CS10);
  163. TCNT1H=0x00;
  164. TCNT1L=0x00;
  165. ICR1H=0x00;
  166. ICR1L=0x00;
  167. OCR1AH=0x00;
  168. OCR1AL=0x00;
  169. OCR1BH=0x00;
  170. OCR1BL=0x00;
  171.  
  172. // Timer/Counter 2 initialization
  173. // Clock source: System Clock
  174. // Clock value: Timer2 Stopped
  175. // Mode: Normal top=0xFF
  176. // OC2A output: Disconnected
  177. // OC2B output: Disconnected
  178. ASSR=(0<<EXCLK) | (0<<AS2);
  179. TCCR2A=(0<<COM2A1) | (0<<COM2A0) | (0<<COM2B1) | (0<<COM2B0) | (0<<WGM21) | (0<<WGM20);
  180. TCCR2B=(0<<WGM22) | (0<<CS22) | (0<<CS21) | (0<<CS20);
  181. TCNT2=0x00;
  182. OCR2A=0x00;
  183. OCR2B=0x00;
  184.  
  185. // Timer/Counter 0 Interrupt(s) initialization
  186. TIMSK0=(0<<OCIE0B) | (0<<OCIE0A) | (0<<TOIE0);
  187.  
  188. // Timer/Counter 1 Interrupt(s) initialization
  189. TIMSK1=(0<<ICIE1) | (0<<OCIE1B) | (0<<OCIE1A) | (0<<TOIE1);
  190.  
  191. // Timer/Counter 2 Interrupt(s) initialization
  192. TIMSK2=(0<<OCIE2B) | (0<<OCIE2A) | (0<<TOIE2);
  193.  
  194. // External Interrupt(s) initialization
  195. // INT0: Off
  196. // INT1: Off
  197. // Interrupt on any change on pins PCINT0-7: Off
  198. // Interrupt on any change on pins PCINT8-14: Off
  199. // Interrupt on any change on pins PCINT16-23: Off
  200. EICRA=(0<<ISC11) | (0<<ISC10) | (0<<ISC01) | (0<<ISC00);
  201. EIMSK=(0<<INT1) | (0<<INT0);
  202. PCICR=(0<<PCIE2) | (0<<PCIE1) | (0<<PCIE0);
  203.  
  204. // USART initialization
  205. // USART disabled
  206. UCSR0B=(0<<RXCIE0) | (0<<TXCIE0) | (0<<UDRIE0) | (0<<RXEN0) | (0<<TXEN0) | (0<<UCSZ02) | (0<<RXB80) | (0<<TXB80);
  207.  
  208. // Analog Comparator initialization
  209. // Analog Comparator: Off
  210. // The Analog Comparator's positive input is
  211. // connected to the AIN0 pin
  212. // The Analog Comparator's negative input is
  213. // connected to the AIN1 pin
  214. ACSR=(1<<ACD) | (0<<ACBG) | (0<<ACO) | (0<<ACI) | (0<<ACIE) | (0<<ACIC) | (0<<ACIS1) | (0<<ACIS0);
  215. ADCSRB=(0<<ACME);
  216. // Digital input buffer on AIN0: On
  217. // Digital input buffer on AIN1: On
  218. DIDR1=(0<<AIN0D) | (0<<AIN1D);
  219.  
  220. // ADC initialization
  221. // ADC disabled
  222. ADCSRA=(0<<ADEN) | (0<<ADSC) | (0<<ADATE) | (0<<ADIF) | (0<<ADIE) | (0<<ADPS2) | (0<<ADPS1) | (0<<ADPS0);
  223.  
  224. // SPI initialization
  225. // SPI disabled
  226. SPCR=(0<<SPIE) | (0<<SPE) | (0<<DORD) | (0<<MSTR) | (0<<CPOL) | (0<<CPHA) | (0<<SPR1) | (0<<SPR0);
  227.  
  228. // TWI initialization
  229. // TWI disabled
  230. TWCR=(0<<TWEA) | (0<<TWSTA) | (0<<TWSTO) | (0<<TWEN) | (0<<TWIE);  
  231.    
  232.    
  233.     //c 0 по 10 ячейки пишем 0, с 11 по 20 пишем
  234.     writeCycle(0, 0, 10);
  235.     writeCycle(1, 11, 20);                      
  236.         //подсчитываем, сколько раз данные в ячейках не сошлись с ожидаемыми
  237.     // В данном случае проверяем на 0, должно бытть 10 ошибок(т.к. с 11 по 20 ячейки записаны единицы)
  238.     numberOfErrors = checkIsCorrect(1, 0, 20);
  239.                                
  240.     //моргаем светодиодом столько раз, сколько было ошибок  
  241.     BLINK(numberOfErrors);
  242. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!