API tools faq
paste
Advertisement
ikastolero

Arduino SRAM test v1.2

ikastolero
Nov 16th, 2017
236
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 13.96 KB | None | 0 0
raw download clone embed print report
  1. #include <LiquidCrystal.h>
  2.  
  3. const int rs = 7, en = 6, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
  4. LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
  5.  
  6. int Address[] = {45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30}; // This is the array for the address.
  7.  
  8. int delayValue = 1; // Delay Value (microseconds)
  9.  
  10.   int OE = 26; // Output Enable
  11.   int WE = 27; // Write Enable
  12.   int CE = 28; // Chip Enable
  13.  
  14.   int IO1 = 46; // Data Input/Output 1
  15.   int IO2 = 47; // Data Input/Output 2
  16.   int IO3 = 48; // Data Input/Output 3
  17.   int IO4 = 49; // Data Input/Output 4
  18.  
  19.   int val1 = 0; // Readed data IO1
  20.   int val2 = 0; // Readed data IO2
  21.   int val3 = 0; // Readed data IO3
  22.   int val4 = 0; // Readed data IO4
  23.  
  24.   int I1LOW = 0; // Write data IO1 for LOW
  25.   int I2LOW = 0; // Write data IO2 for LOW
  26.   int I3LOW = 0; // Write data IO3 for LOW
  27.   int I4LOW = 0; // Write data IO4 for LOW
  28.  
  29.   int I1HIGH = 0; // Write data IO1 for HIGH
  30.   int I2HIGH = 0; // Write data IO2 for HIGH
  31.   int I3HIGH = 0; // Write data IO3 for HIGH
  32.   int I4HIGH = 0; // Write data IO4 for HIGH
  33.  
  34.  
  35.  
  36.   int BAD = 0;
  37.   int BADLED = 10; //Error LED at pin 10
  38.   int GOODLED = 12; //Finnish LED at pin 12
  39.  
  40.   int LCDreg = A0;
  41.  
  42.  
  43.  
  44. void setup() {
  45.  
  46.   lcd.begin(16, 2);
  47.  
  48.   lcd.print("SRAM Test");
  49.  
  50.   pinMode(LCDreg, OUTPUT);
  51.  
  52.   analogWrite(LCDreg, 100);
  53.  
  54. I1LOW = LOW; // Assign LOW value to I1LOW
  55. I2LOW = LOW; // Assign LOW value to I2LOW
  56. I3LOW = LOW; // Assign LOW value to I3LOW
  57. I4LOW = LOW; // Assign LOW value to I4LOW
  58.  
  59. I1HIGH = HIGH; //Assign HIGH value to I1LOW
  60. I2HIGH = HIGH; //Assign HIGH value to I2LOW
  61. I3HIGH = HIGH; //Assign HIGH value to I3LOW
  62. I4HIGH = HIGH; //Assign HIGH value to I4LOW
  63.  
  64. BAD = LOW;
  65.  
  66.  
  67.   Serial.begin(19200); //Starting the serial
  68.  
  69. {
  70. int i = 0;
  71.   for ( i = 0; i < 16; i++)
  72.     pinMode(Address[i], OUTPUT);
  73. }
  74.   pinMode (OE, OUTPUT); // Set OE as OUTPUT
  75.   pinMode (WE, OUTPUT); // Set WE as OUTPUT
  76.   pinMode (CE, OUTPUT); // Set CE as OUTPUT
  77.   pinMode (BADLED, OUTPUT); // Set BADLED as OUTPUT
  78.   pinMode (GOODLED, OUTPUT); // Set GOODLED as OUTPUT
  79.  
  80.   digitalWrite (BADLED, LOW); // Assign BADLED a LOW start status
  81.   digitalWrite (GOODLED, LOW); // Assign GOODLED a LOW start status
  82.  
  83.    
  84. }
  85.  
  86. void loop() {
  87. val1 = 0;
  88. val2 = 0;
  89. val3 = 0;
  90. val4 = 0;
  91.  
  92.  
  93.  
  94. {
  95.   digitalWrite(CE, HIGH); //FIRST we need to put the control pins to HIGH (they are inverted).
  96.  
  97.   digitalWrite(OE, HIGH);
  98.  
  99.   digitalWrite(WE, HIGH);
  100.  
  101.  
  102.  
  103.    
  104.  
  105.  
  106.  int i = 0, j=0;
  107.  
  108.   for ( i = 0; i < 65535; i++)
  109.   {
  110.      for ( j = 0; j < 16; j++)
  111.      {
  112.        if ( ( (i >> j) & 1 )  == 1 )
  113.            digitalWrite(Address[j], HIGH);
  114.        else digitalWrite(Address[j], LOW);
  115.          
  116.         __asm__("nop\n\t");
  117.  
  118.  
  119.             {
  120.              Serial.println(F("Another loop")); // This is to know when the program makes a loop.
  121.             }
  122.  
  123.  
  124.              pinMode (IO1, OUTPUT); // First, we put the I/O data pins as OPUTPUT
  125.              pinMode (IO2, OUTPUT);
  126.              pinMode (IO3, OUTPUT);
  127.              pinMode (IO4, OUTPUT);
  128.  
  129.              digitalWrite(IO1, I1LOW); // Filling the data output as LOW
  130.              digitalWrite(IO2, I2LOW);
  131.              digitalWrite(IO3, I3LOW);
  132.              digitalWrite(IO4, I4LOW);
  133.  
  134.              __asm__("nop\n\t");
  135.  
  136.              digitalWrite(CE, LOW); // Enabling the chip
  137.  
  138.              __asm__("nop\n\t");
  139.  
  140.              digitalWrite(WE, LOW); // Enabling the writting on the chip
  141.  
  142.              __asm__("nop\n\t");  // Wait for the writting
  143.              
  144.  
  145.              digitalWrite(CE, HIGH); // Disable the chip
  146.  
  147.              __asm__("nop\n\t");
  148.  
  149.              digitalWrite(WE, HIGH); // Disable the writting on the chip
  150.  
  151.              __asm__("nop\n\t");
  152.  
  153.              digitalWrite(IO1, LOW); // This is for the previous tests. The arduino lefts the OUTPUT as HIGH.
  154.              digitalWrite(IO2, LOW); // Because the chip is disabled, we can change the data output, because the data was saved.
  155.              digitalWrite(IO3, LOW);
  156.              digitalWrite(IO4, LOW);
  157.  
  158.              pinMode (IO1, INPUT); // Then, we set the I/O as input.
  159.              pinMode (IO2, INPUT);
  160.              pinMode (IO3, INPUT);
  161.              pinMode (IO4, INPUT);
  162.  
  163.              __asm__("nop\n\t");
  164.  
  165.              digitalWrite(CE, LOW); // Enabling the chip
  166.  
  167.              __asm__("nop\n\t");
  168.  
  169.              digitalWrite(OE, LOW); // Enabling the output
  170.  
  171.              __asm__("nop\n\t");
  172.  
  173.              val1 = digitalRead(IO1); // Now, we are reading the data of each out.
  174.              val2 = digitalRead(IO2);
  175.              val3 = digitalRead(IO3);
  176.              val4 = digitalRead(IO4);
  177.  
  178.              digitalWrite(OE, HIGH); // Disabling the output
  179.  
  180.              digitalWrite(CE, HIGH); // Disabling the chip
  181.               {
  182.                if((val1 == I1LOW) && (val2 == I2LOW) && (val3 == I3LOW) && (val4 == I4LOW))
  183.  
  184.                Serial.println(F("Fill-0000 OK")); // (It cheks the input values and the read values are the same)
  185.  
  186.  
  187.  
  188.                else Serial.println(F("Fill-0000 FAIL")), BAD = HIGH; // (If they aren't, it shows a message in the serial monitor, and the BADLED turns on.
  189.                
  190.               }
  191.              pinMode (IO1, OUTPUT); // Now, we are making the same thing again, but with other values.
  192.              pinMode (IO2, OUTPUT);
  193.              pinMode (IO3, OUTPUT);
  194.              pinMode (IO4, OUTPUT);
  195.  
  196.              digitalWrite(IO1, I1HIGH);
  197.              digitalWrite(IO2, I2HIGH);
  198.              digitalWrite(IO3, I3HIGH);
  199.              digitalWrite(IO4, I4HIGH);
  200.  
  201.              __asm__("nop\n\t");
  202.  
  203.              digitalWrite(CE, LOW);
  204.  
  205.              __asm__("nop\n\t");
  206.  
  207.              digitalWrite(WE, LOW);
  208.  
  209.              __asm__("nop\n\t");
  210.  
  211.              digitalWrite(CE, HIGH);
  212.  
  213.              __asm__("nop\n\t");
  214.  
  215.              digitalWrite(WE, HIGH);
  216.  
  217.              __asm__("nop\n\t");
  218.  
  219.              digitalWrite(IO1, LOW);
  220.              digitalWrite(IO2, LOW);
  221.              digitalWrite(IO3, LOW);
  222.              digitalWrite(IO4, LOW);
  223.  
  224.              pinMode (IO1, INPUT);
  225.              pinMode (IO2, INPUT);
  226.              pinMode (IO3, INPUT);
  227.              pinMode (IO4, INPUT);
  228.  
  229.              __asm__("nop\n\t");
  230.  
  231.              digitalWrite(CE, LOW);
  232.  
  233.              __asm__("nop\n\t");
  234.  
  235.              digitalWrite(OE, LOW);
  236.  
  237.              __asm__("nop\n\t");
  238.  
  239.              val1 = digitalRead(IO1);
  240.              val2 = digitalRead(IO2);
  241.              val3 = digitalRead(IO3);
  242.              val4 = digitalRead(IO4);
  243.  
  244.              digitalWrite(OE, HIGH);
  245.  
  246.              digitalWrite(CE, HIGH);
  247.               {
  248.                if((val1 == I1HIGH) && (val2 == I2HIGH) && (val3 == I3HIGH) && (val4 == I4HIGH))
  249.  
  250.                Serial.println(F("Fill-1111 OK"));
  251.  
  252.  
  253.  
  254.                else Serial.println(F("Fill-1111 FAIL")), BAD = HIGH;
  255.                
  256.               }
  257.              pinMode (IO1, OUTPUT);
  258.              pinMode (IO2, OUTPUT);
  259.              pinMode (IO3, OUTPUT);
  260.              pinMode (IO4, OUTPUT);
  261.  
  262.              digitalWrite(IO1, I1HIGH);
  263.              digitalWrite(IO2, I2LOW);
  264.              digitalWrite(IO3, I3HIGH);
  265.              digitalWrite(IO4, I4LOW);
  266.  
  267.              __asm__("nop\n\t");
  268.  
  269.              digitalWrite(CE, LOW);
  270.  
  271.              __asm__("nop\n\t");
  272.  
  273.              digitalWrite(WE, LOW);
  274.  
  275.              __asm__("nop\n\t");
  276.  
  277.              digitalWrite(CE, HIGH);
  278.  
  279.              __asm__("nop\n\t");
  280.  
  281.              digitalWrite(WE, HIGH);
  282.  
  283.              __asm__("nop\n\t");
  284.  
  285.              digitalWrite(IO1, LOW);
  286.              digitalWrite(IO2, LOW);
  287.              digitalWrite(IO3, LOW);
  288.              digitalWrite(IO4, LOW);
  289.  
  290.              pinMode (IO1, INPUT);
  291.              pinMode (IO2, INPUT);
  292.              pinMode (IO3, INPUT);
  293.              pinMode (IO4, INPUT);
  294.  
  295.              __asm__("nop\n\t");
  296.  
  297.              digitalWrite(CE, LOW);
  298.  
  299.              __asm__("nop\n\t");
  300.  
  301.              digitalWrite(OE, LOW);
  302.  
  303.              __asm__("nop\n\t");
  304.  
  305.              val1 = digitalRead(IO1);
  306.              val2 = digitalRead(IO2);
  307.              val3 = digitalRead(IO3);
  308.              val4 = digitalRead(IO4);
  309.  
  310.              digitalWrite(OE, HIGH);
  311.  
  312.              digitalWrite(CE, HIGH);
  313.               {
  314.                if((val1 == I1HIGH) && (val2 == I2LOW) && (val3 == I3HIGH) && (val4 == I4LOW))
  315.  
  316.                Serial.println(F("Fill-1010 OK"));
  317.  
  318.  
  319.  
  320.                else Serial.println(F("Fill-1010 FAIL")), BAD = HIGH;
  321.                
  322.               }
  323.              
  324.              pinMode (IO1, OUTPUT);
  325.              pinMode (IO2, OUTPUT);
  326.              pinMode (IO3, OUTPUT);
  327.              pinMode (IO4, OUTPUT);
  328.  
  329.              digitalWrite(IO1, I1LOW);
  330.              digitalWrite(IO2, I2HIGH);
  331.              digitalWrite(IO3, I3LOW);
  332.              digitalWrite(IO4, I4HIGH);
  333.  
  334.              __asm__("nop\n\t");
  335.  
  336.              digitalWrite(CE, LOW);
  337.  
  338.              __asm__("nop\n\t");
  339.  
  340.              digitalWrite(WE, LOW);
  341.  
  342.              __asm__("nop\n\t");
  343.  
  344.              digitalWrite(CE, HIGH);
  345.  
  346.              __asm__("nop\n\t");
  347.  
  348.              digitalWrite(WE, HIGH);
  349.  
  350.              __asm__("nop\n\t");
  351.  
  352.              digitalWrite(IO1, LOW);
  353.              digitalWrite(IO2, LOW);
  354.              digitalWrite(IO3, LOW);
  355.              digitalWrite(IO4, LOW);
  356.  
  357.              pinMode (IO1, INPUT);
  358.              pinMode (IO2, INPUT);
  359.              pinMode (IO3, INPUT);
  360.              pinMode (IO4, INPUT);
  361.  
  362.              __asm__("nop\n\t");
  363.  
  364.              digitalWrite(CE, LOW);
  365.  
  366.              __asm__("nop\n\t");
  367.  
  368.              digitalWrite(OE, LOW);
  369.  
  370.              __asm__("nop\n\t");
  371.  
  372.              val1 = digitalRead(IO1);
  373.              val2 = digitalRead(IO2);
  374.              val3 = digitalRead(IO3);
  375.              val4 = digitalRead(IO4);
  376.  
  377.              digitalWrite(OE, HIGH);
  378.  
  379.              digitalWrite(CE, HIGH);
  380.               {
  381.                if((val1 == I1LOW) && (val2 == I2HIGH) && (val3 == I3LOW) && (val4 == I4HIGH))
  382.  
  383.                Serial.println(F("Fill-0101 OK"));
  384.  
  385.  
  386.  
  387.                else Serial.println(F("Fill-0101 FAIL")), BAD = HIGH;
  388.                
  389.               }
  390.  
  391.              pinMode (IO1, OUTPUT);
  392.              pinMode (IO2, OUTPUT);
  393.              pinMode (IO3, OUTPUT);
  394.              pinMode (IO4, OUTPUT);
  395.  
  396.              digitalWrite(IO1, I1HIGH);
  397.              digitalWrite(IO2, I2HIGH);
  398.              digitalWrite(IO3, I3LOW);
  399.              digitalWrite(IO4, I4LOW);
  400.  
  401.              __asm__("nop\n\t");
  402.  
  403.              digitalWrite(CE, LOW);
  404.  
  405.              __asm__("nop\n\t");
  406.  
  407.              digitalWrite(WE, LOW);
  408.  
  409.              __asm__("nop\n\t");
  410.  
  411.              digitalWrite(CE, HIGH);
  412.  
  413.              __asm__("nop\n\t");
  414.  
  415.              digitalWrite(WE, HIGH);
  416.  
  417.              __asm__("nop\n\t");
  418.  
  419.              digitalWrite(IO1, LOW);
  420.              digitalWrite(IO2, LOW);
  421.              digitalWrite(IO3, LOW);
  422.              digitalWrite(IO4, LOW);
  423.  
  424.              pinMode (IO1, INPUT);
  425.              pinMode (IO2, INPUT);
  426.              pinMode (IO3, INPUT);
  427.              pinMode (IO4, INPUT);
  428.  
  429.              __asm__("nop\n\t");
  430.  
  431.              digitalWrite(CE, LOW);
  432.  
  433.              __asm__("nop\n\t");
  434.  
  435.              digitalWrite(OE, LOW);
  436.  
  437.              __asm__("nop\n\t");
  438.  
  439.              val1 = digitalRead(IO1);
  440.              val2 = digitalRead(IO2);
  441.              val3 = digitalRead(IO3);
  442.              val4 = digitalRead(IO4);
  443.  
  444.              digitalWrite(OE, HIGH);
  445.  
  446.              digitalWrite(CE, HIGH);
  447.               {
  448.                if((val1 == I1HIGH) && (val2 == I2HIGH) && (val3 == I3LOW) && (val4 == I4LOW))
  449.  
  450.                Serial.println(F("Fill-1100 OK"));
  451.  
  452.  
  453.  
  454.                else Serial.println(F("Fill-1100 FAIL")), BAD = HIGH;
  455.                
  456.               }
  457.              pinMode (IO1, OUTPUT);
  458.              pinMode (IO2, OUTPUT);
  459.              pinMode (IO3, OUTPUT);
  460.              pinMode (IO4, OUTPUT);
  461.  
  462.              digitalWrite(IO1, I1LOW);
  463.              digitalWrite(IO2, I2LOW);
  464.              digitalWrite(IO3, I3HIGH);
  465.              digitalWrite(IO4, I4HIGH);
  466.  
  467.              __asm__("nop\n\t");
  468.  
  469.              digitalWrite(CE, LOW);
  470.  
  471.              __asm__("nop\n\t");
  472.  
  473.              digitalWrite(WE, LOW);
  474.  
  475.              __asm__("nop\n\t");
  476.  
  477.              digitalWrite(CE, HIGH);
  478.  
  479.              __asm__("nop\n\t");
  480.  
  481.              digitalWrite(WE, HIGH);
  482.  
  483.              __asm__("nop\n\t");
  484.  
  485.              digitalWrite(IO1, LOW);
  486.              digitalWrite(IO2, LOW);
  487.              digitalWrite(IO3, LOW);
  488.              digitalWrite(IO4, LOW);
  489.  
  490.              pinMode (IO1, INPUT);
  491.              pinMode (IO2, INPUT);
  492.              pinMode (IO3, INPUT);
  493.              pinMode (IO4, INPUT);
  494.  
  495.              __asm__("nop\n\t");
  496.  
  497.              digitalWrite(CE, LOW);
  498.  
  499.              __asm__("nop\n\t");
  500.  
  501.              digitalWrite(OE, LOW);
  502.  
  503.              __asm__("nop\n\t");
  504.  
  505.              val1 = digitalRead(IO1);
  506.              val2 = digitalRead(IO2);
  507.              val3 = digitalRead(IO3);
  508.              val4 = digitalRead(IO4);
  509.  
  510.              digitalWrite(OE, HIGH);
  511.  
  512.              digitalWrite(CE, HIGH);
  513.               {
  514.                if((val1 == I1LOW) && (val2 == I2LOW) && (val3 == I3HIGH) && (val4 == I4HIGH))
  515.  
  516.                Serial.println(F("Fill-0011 OK"));
  517.  
  518.  
  519.  
  520.                else Serial.println(F("Fill-0011 FAIL")), BAD = HIGH;
  521.                
  522.               }
  523.              
  524. Serial.println(i); // Prints on serial console the number of test.
  525.  
  526. lcd.setCursor(0, 1);
  527.  
  528. lcd.print(i); // Print on LCD the number of test.
  529.  
  530. lcd.setCursor(9, 1);
  531.  
  532. if(BAD == HIGH){
  533.  
  534. lcd.print("Bad ");
  535. }
  536. else {
  537.   lcd.print("Good");
  538. }
  539.  
  540. if(BAD == HIGH){
  541.  
  542. digitalWrite(BADLED, HIGH);
  543. }
  544. else {
  545. digitalWrite(BADLED, LOW);
  546. }
  547.  
  548. if(i == 65535){ // If the test goes to 65535 (1111111111111111, or 2^16 - 1), the test is finnished.
  549. digitalWrite(GOODLED, HIGH), lcd.setCursor(10, 0), lcd.print("End"); // And the finnish LED turns on.
  550. }
  551. else {
  552.   delayMicroseconds(delayValue);
  553. }
  554.  
  555. // Ikastolero SN
  556. }
  557. }
  558. }
  559. }
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!