Описание библиотеки микросхемы 5023ВС016 процессора "Спутник"
test_memory.c
См. документацию.
1 
29 #include "memory.h"
30 #include "chip_5023BC016.h"
31 #include "string.h"
32 #include "test_memory.h"
33 
34 
35 
36 
37 /*****************************************************************************
38  * Частные функции
39  ****************************************************************************/
40 
41 
42 
43 /* Запись блока данных в память*/
44 void MEMTest_Write(uint32_t Addr, TEST_RADIX Radix, uint32_t Word)
45 {
46  switch(Radix)
47  {
48  case 4:
49  MEM_Write32( Addr, Word);
50  break;
51  case 2:
52  MEM_Write16( Addr, (uint16_t)Word);
53  break;
54 
55  case 1:
56  MEM_Write8( Addr, (uint8_t)Word);
57  break;
58  }
59 }
60 
61 /* Чтение блока данных из памяти*/
62 uint32_t MEMTest_Read(uint32_t Addr, TEST_RADIX Radix)
63 {
64  switch(Radix)
65  {
66  case 4:
67  return MEM_Read32(Addr);
68  case 2:
69  return MEM_Read16(Addr);
70  case 1:
71  return MEM_Read8(Addr);
72  }
73  return 0;
74 }
75 
76 /* Зануление блока данных в память*/
77 void MEMTest_ZeroBlock(uint32_t Addr, uint32_t Size)
78 {
79 
80  for( uint32_t StartAddr = Addr; StartAddr < Size/sizeof(uint32_t); StartAddr++)
81  {
82  MEM_Write32( StartAddr, 0);
83  }
84 }
85 
86 /* Тест памяти "Счетчик"*/
87 bool MEMTEST_Counter(PTEST_MEM pMEMTest)
88 {
89  TEST_RADIX Radix = pMEMTest->param.radix;
90  uint32_t Addr = pMEMTest->block.Addr;
91  uint32_t Size = pMEMTest->block.Size;
92 
93  uint32_t Mask = 0;
94 
95  for(uint8_t i = 0; i < Radix; i++)
96  {
97  Mask|= 0xFF<<(i*8);
98  }
99 
100  uint32_t Count = 0;
101  uint32_t Errors = 0;
102 
103  for(uint32_t StartAddr = Addr; StartAddr < Size/Radix; StartAddr++)
104  {
105  MEMTest_Write(StartAddr, Radix, Count);
106  Count+=1;
107  }
108 
109  Count = 0;
110 
111  for(uint32_t StartAddr = Addr; StartAddr < Size/Radix; StartAddr++)
112  {
113  uint32_t r = MEMTest_Read(StartAddr, Radix);
114 
115  if((Count&Mask)!=r)
116  {
117  Errors+=1;
118  }
119  Count+=1;
120  }
121  pMEMTest->errors.Errors = Errors;
122  return (Errors)?false:true;
123 
124 }
125 
126 /* Тест памяти "Галоп"*/
127 bool MEMTEST_Gallop(PTEST_MEM pMEMTest)
128 {
129  TEST_RADIX Radix = pMEMTest->param.radix;
130  uint32_t Addr = pMEMTest->block.Addr;
131  uint32_t Size = pMEMTest->block.Size;
132  uint32_t Mask = 0;
133  uint32_t Pattern0 = 0;
134  uint32_t PatternF = 0;
135  for(uint8_t i = 0; i < Radix; i++)
136  {
137  Mask|= 0xFF<<(i*8);
138  }
139  PatternF = Mask;
140  uint32_t Errors = 0;
141  MEMTest_ZeroBlock( Addr, Size);
142 
143  for( uint32_t Addr_w = Addr; Addr_w < Size/Radix; Addr_w++)
144  {
145  MEMTest_Write( Addr_w, Radix, PatternF);
146  for( uint32_t Addr_r = Addr; Addr_r < Size/Radix; Addr_r++)
147  {
148  if(Addr_w!=Addr_r)
149  {
150  if(MEMTest_Read(Addr_r, Radix)!=Pattern0)
151  {
152  Errors+=1;
153  }
154  }
155  }
156  if(!Errors)
157  {
158  MEMTest_Write( Addr_w, Radix, Pattern0);
159  }
160  else
161  {
162  MEMTest_ZeroBlock( Addr, Size);
163  }
164  }
165 
166  pMEMTest->errors.Errors = Errors;
167  return (Errors)?false:true;
168 }
169 
170 /* Тест памяти "Маршевый тест"*/
171 bool MEMTEST_Marsch(PTEST_MEM pMEMTest)
172 {
173 
174  TEST_RADIX Radix = pMEMTest->param.radix;
175  uint32_t Addr = pMEMTest->block.Addr;
176  uint32_t Size = pMEMTest->block.Size;
177  uint32_t Mask = 0;
178  uint32_t Pattern0 = 0;
179  uint32_t PatternF = 0;
180  for(uint8_t i = 0; i < Radix; i++)
181  {
182  Mask|= 0xFF<<(i*8);
183  }
184 
185  PatternF = Mask;
186  uint32_t Errors = 0;
187  MEMTest_ZeroBlock( Addr, Size);
188  for( uint32_t StartAddr = Addr; StartAddr < Size/Radix; StartAddr++)
189  {
190  if(MEMTest_Read(StartAddr, Radix)!=Pattern0)
191  {
192  Errors+=1;
193  }
194  MEMTest_Write( StartAddr, Radix, PatternF);
195  }
196  for( uint32_t StartAddr = Addr; StartAddr < Size/Radix; StartAddr++)
197  {
198  if(MEMTest_Read(StartAddr, Radix)!=PatternF)
199  {
200  Errors+=1;
201  }
202  }
203 
204  pMEMTest->errors.Errors = Errors;
205  return (Errors)?false:true;
206 }
207 
208 /*****************************************************************************
209  * Общие функции
210  ****************************************************************************/
211 
218 {
219 
220  switch(pMEMTest->param.type)
221  {
222  case TEST_GALOPPING:
223  return MEMTEST_Gallop(pMEMTest);
224  case TEST_COUNTER:
225  return MEMTEST_Counter(pMEMTest);
226  case TEST_MARCHAL:
227  return MEMTEST_Marsch(pMEMTest);
228  break;
229  case TEST_CHESS:
230  default:
231  return true;
232  break;
233  }
234 }
235 
Этот файл содержит структуры, макросы и функции необходимые для работы с памятью. ...
bool MEMTEST_Gallop(PTEST_MEM pMEMTest)
Тест памяти "Галоп".
Definition: test_memory.c:127
bool MEMTEST_Counter(PTEST_MEM pMEMTest)
Тест памяти "Счетчик".
Definition: test_memory.c:87
Этот файл содержит описание адресного пространства микроконтроллера 5023ВС016.
void MEMTest_Write(uint32_t Addr, TEST_RADIX Radix, uint32_t Word)
Запись блока данных в память
Definition: test_memory.c:44
TEST_BLOCK block
Definition: test_memory.h:90
TEST_TYPE type
Definition: test_memory.h:71
bool MEMTEST_Marsch(PTEST_MEM pMEMTest)
Тест памяти "Маршевый тест".
Definition: test_memory.c:171
uint32_t MEMTest_Read(uint32_t Addr, TEST_RADIX Radix)
Чтение блока данных из памяти
Definition: test_memory.c:62
uint32_t Addr
Definition: test_memory.h:62
uint32_t MEM_Read32(uint32_t Addr)
Чтение четырех байтного слова
Definition: memory.c:274
uint16_t MEM_Read16(uint32_t Addr)
Чтение двух байтного слова
Definition: memory.c:264
void MEM_Write16(uint32_t Addr, uint16_t Data)
Запись двух байтного слова
Definition: memory.c:234
void MEM_Write8(uint32_t Addr, uint8_t Data)
Запись байтного слова
Definition: memory.c:224
bool MEMTEST_generic(PTEST_MEM pMEMTest)
Чтение байтного слова
Definition: test_memory.c:217
uint32_t Size
Definition: test_memory.h:63
TEST_RADIX
Тип разрядность слова
Definition: test_memory.h:50
void MEM_Write32(uint32_t Addr, uint32_t Data)
Запись четырех байтного слова
Definition: memory.c:244
TEST_ERRORS errors
Definition: test_memory.h:92
void MEMTest_ZeroBlock(uint32_t Addr, uint32_t Size)
Зануление блока данных в память
Definition: test_memory.c:77
Этот файл содержит структуры, макросы и функции необходимые для тестов памяти.
TEST_RADIX radix
Definition: test_memory.h:72
Структура для проведения тестирования памяти
Definition: test_memory.h:88
uint8_t MEM_Read8(uint32_t Addr)
Чтение байтного слова
Definition: memory.c:254
uint32_t Errors
Definition: test_memory.h:82
TEST_CFG param
Definition: test_memory.h:91