File content as of revision 15:d6cc57c4e23d:

/*----------------------------------------------//------------------------------
    student   : m-moore
    class     : external SPI interface
    directory : mmSPI
    file      : mmSPI.cpp
------------------------------------------------//----------------------------*/
    #include "mmSPI.h"
/*----------------------------------------------//------------------------------
------------------------------------------------//----------------------------*/
//==============================================//==============================
//  consider resetting the fpga around here, because
//  the micro may be wiggling these signals before here.
    mmSPI::mmSPI()                              // constructor.
    {
      allocations();                            // object allocations.
      
      *pSCLK   = 0;                             // initialize.
      *pCPUclk = 0;                             // initialize.
    }
//----------------------------------------------//------------------------------    
    mmSPI::~mmSPI()                             // destructor.
    {
                                                // deallocations.
      if (pMOSI)   {delete pMOSI;   pMOSI   = NULL;}
      if (pMISO)   {delete pMISO;   pMISO   = NULL;}
      if (pSCLK)   {delete pSCLK;   pSCLK   = NULL;}
      if (pCPUclk) {delete pCPUclk; pCPUclk = NULL;}
    } 
//----------------------------------------------//------------------------------
    void mmSPI::allocations(void)               // object allocations.
    {
      pMOSI   = new DigitalOut(mmSPI_MOSI);       // SPI MOSI pin object.
      if (!pMOSI) error("\n\r mmSPI::allocations : FATAL malloc error for pMOSI. \n\r"); 
      
      pMISO   = new DigitalOut(mmSPI_MISO);      // SPI MISO pin object.
      if (!pMISO) error("\n\r mmSPI::allocations : FATAL malloc error for pMISO. \n\r"); 
    
      pSCLK   = new DigitalOut(mmSPI_SCLK);       // SPI SCLK pin object.
      if (!pSCLK) error("\n\r mmSPI::allocations : FATAL malloc error for pSCLK. \n\r"); 
      
      pCPUclk = new DigitalOut(mmCPU_CLK);          // SPI SCLK pin object.
      if (!pCPUclk) error("\n\r mmSPI::allocations : FATAL malloc error for pCPUclk. \n\r");
    } 
//----------------------------------------------//------------------------------    
    void mmSPI::setSPIfrequency(float fFreq)    // set SPI clock frequency.
    {
      fSPIfreq = fFreq;                         // promote to object scope.
      if (fSPIfreq < .05)                       // don't get near divide-by-zero.
      error("\n\r mmSPI::setSPIfrequency : FATAL SPI frequency set too low. \n\r"); 
      fSPIquarterP = (1 / fSPIfreq) / 4;        // figure quarter-cycle period.
    }
//----------------------------------------------//------------------------------
//  we're not going for speed, so lets go for good setup / hold.

                                                // send/receive a byte over SPI.
                                                // MSB out/in first.
    void mmSPI::transceive_byte(char *cReceive, char *cSend)
    {
      *cReceive = 0;                            // clear receive byte.                                    
      for (dLoop01 = 7; dLoop01 >= 0; dLoop01--)// loop for 8 bits in the byte.
      {
        *pSCLK = 0;                             // SPI clock negedge.
        wait(fSPIquarterP);                     // until middle of clock low.
        *pMOSI = (*cSend >> dLoop01) & 1;       // assert MOSI.
                                                // capture MISO.
        *cReceive = *cReceive | (*pMISO << dLoop01);        
        wait(fSPIquarterP);                     // finish-out cycle.
        *pSCLK = 1;                             // SPI clock posedge.
        wait(fSPIquarterP);                     // finish-out cycle.
        wait(fSPIquarterP);                     // finish-out cycle.
      }
    }
//----------------------------------------------//------------------------------
                                                // transceive a character array.
                                                // limit is 256 characters.
                                                // MSB out/in first.
    void mmSPI::transceive_vector(char *cReceive, char *cSend, char cNumBytes)
    {       
                                                // the first SPI pulse after the
                                                // CPU clock goes low is used for
                                                // parallel-load of the SPI shadow
                                                // registers, not for shifting.
      if (0)
      {
        *pSCLK = 1;                              
        wait(fSPIquarterP); 
        wait(fSPIquarterP); 
        *pSCLK = 0;
        wait(fSPIquarterP); 
        wait(fSPIquarterP); 
      }
    
      for (dLoop02 = (cNumBytes - 1); dLoop02 >= 0; dLoop02--)
      transceive_byte(&(cReceive[dLoop02]), &(cSend[dLoop02]));
      
   
      
      *pCPUclk = 1;                             // pulse the CPU clock.
      wait(fSPIquarterP); 
      wait(fSPIquarterP);     
      *pCPUclk = 0;  
      wait(fSPIquarterP); 
      wait(fSPIquarterP); 
    }
//----------------------------------------------//------------------------------
                                                // transceive a character array.
                                                // limit is 256 characters.
                                                // MSB out/in first.
    void mmSPI::test_toggle_cpu_clock(void)
    {    
      DigitalOut led0(LED4);
      while (1)
      {
        *pCPUclk = 1;  led0 = 1;
        wait(1.0);
        *pCPUclk = 0;  led0 = 0;
        wait(1.0);
      }
    }
//----------------------------------------------//------------------------------
    void mmSPI::force_write(char cDataHIgh, char cDataLow, char cAddress)
    {
      char pcReceive[8];
      char pcSend   [8];
      int  dLoop;
      
      for (dLoop = 0; dLoop < 8; dLoop++) pcSend[dLoop] = 0;
      
      
                                                // high data to R2.
      pcSend[7] = 0x02; pcSend[1] = 0xA8; pcSend[0] = cDataHIgh;   
      transceive_vector(pcReceive, pcSend, 8);


                                                 // low  data to R1.
      pcSend[7] = 0x02; pcSend[1] = 0xA4; pcSend[0] = cDataLow; 
      transceive_vector(pcReceive, pcSend, 8);  
        
        
                                                // address to R3.
      pcSend[7] = 0x02; pcSend[1] = 0xAC; pcSend[0] = cAddress; 
      transceive_vector(pcReceive, pcSend, 8);
        
        
                                                     
      pcSend[7] = 0x02; pcSend[1] = 0x02;  pcSend[0] = 0;   // WE high.
      transceive_vector(pcReceive, pcSend, 8);
        
      pcSend[7] = 0x02; pcSend[1] = 0x00;   pcSend[0] = 0;  // WE low. 
      transceive_vector(pcReceive, pcSend, 8);

    }
//----------------------------------------------//------------------------------

    void mmSPI::force_read(char cAddress)
    {
      char pcReceive[8];
      char pcSend   [8];
      int  dLoop;
      
      for (dLoop = 0; dLoop < 8; dLoop++) pcSend[dLoop] = 0;
      
 
        
        
                                                // address to R3.
      pcSend[7] = 0x02; pcSend[1] = 0xAC; pcSend[0] = cAddress; 
      transceive_vector(pcReceive, pcSend, 8);
        
                                                // R2 gets data-H from memory.
      pcSend[7] = 0x02; pcSend[1] = 0xC8; pcSend[0] = cAddress; 
      transceive_vector(pcReceive, pcSend, 8);
      
                                                // R1 gets data-L from memory.
      pcSend[7] = 0x02; pcSend[1] = 0xC4; pcSend[0] = cAddress; 
      transceive_vector(pcReceive, pcSend, 8);
      
      
      
      
 //       pcSend[7] = 0x02;                       // force IR.
//        pcSend[1] = 0xA4;                       // R1 <- immediate.
//        pcSend[0] = 0xEE;                       // immediate value.
 ///       transceive_vector(pcReceive, pcSend, 8);     
      
      
      
                                                // no-op scan.
      pcSend[7] = 0x02; pcSend[1] = 0x0; pcSend[0] = 0;  
      transceive_vector(pcReceive, pcSend, 8);
  
    }
//----------------------------------------------//------------------------------