1.     Previous Content

This blog details experimentation and investigation of the Digilent BASYS MX3 board as part of the BASYS MX3 Trainer Board and I will be writing a roadtest report on this product in the following weeks based on these more detailed blogs. My previous blog posts on this board were to give an overview of Microchip PIC Microcontrollers (MCU) and to explore the initial software install and development cycles associated with the board:

 

2.     Aims of This Blog #2

For this blog #2 I would like to:

  • Explore the twelve projects detailed in the DigilentLibPack library to show what they do
  • To discuss and gain an understanding of how these projects use the LibPack libraries
  • To consolidate my understanding of the non-RTOS based projects
  • To ensure I am confident compiling and programming this board with MPLAB X IDE or IPE

 

3.     The LibPack Projects

As mentioned, there are twelve projects, and I am going to run through each in turn. I'll try and include some of the source code and videos. The purpose of some of the projects is not clear from the name and the first task for each will be to delve into the main.c and try and follow the code through until it becomes obvious. For each project I will then compile and download to the BASYS MX3 board. If possible I will try and include a video of the board in operation at each stage. Finally I will discuss the code operation for each.

 

3.1     ACL Demo - the 3-axis accelerometer

Software: the main.c function makes use of the acl.h and i2c.h libraries. This example reads the current six bytes from the device with 2-bytes per axis of freedom. Each 2-bytes of raw data is then converts to a suitable value representative of a G-force on that axis, and displayed on the LCD.

Functionality: this demo displays data from the onboard 3-axis accelerometer. When downloaded the display shows values for X, Y and Z which change slightly with system noise. Physically demonstrating the changes if actually quite difficult as the board is powered by the USB-DEBUG and I don't really want to start waving it around (I've ripped a USB connector off a previous roadtest board and it was not a happy feeling). A thump of the desk makes the z-axis reading jump from approx 1 up to 2 units.

Circuitry: the BASYS MX3 uses the NXP MMA8652FCR1 device for measuring acceleration. This device is a tiny DFN-10 package and I already am thinking of buying some to include in my future board designs. This device allows a wide range of additional functions not really explored in this simple demo including programmable interrupts and four separate modes of pre-filtering the data: freefall, motion, transient and tap detection. The 65-page device datasheet will prove very useful when experimenting further with this accelerometer.

Code Snippet:

//copied from Digilent BASYS MX3 LibPack
void ACLDemo(){
    float rgACLGVals[3];  
    char strMsg[80];    
    unsigned int baseCnt = 0;
    ACL_Init();
    LCD_Init(); 
    LCD_WriteStringAtPos("ACL Demo", 0, 0);
    LCD_WriteStringAtPos("Digilent", 1, 0);

    while(1)
    {
       //perform ACL readings only once in a while, to be able to visualize the results
        if(++baseCnt == 400000)
       {
            baseCnt = 0;        
            ACL_ReadGValues(rgACLGVals);
            //display on the LCD screen the X values, first row
            sprintf(strMsg, "ACLDemo X:%6.3f", rgACLGVals[0]);
            LCD_WriteStringAtPos(strMsg, 0, 0);
            //display on the LCD screen the Y and Z values, second row
            sprintf(strMsg, "Y:%6.3fZ:%6.3f", rgACLGVals[1], rgACLGVals[2]);            
            LCD_WriteStringAtPos(strMsg, 1, 0);     
        }
    }  
}

 

3.2     AIC Demo - reading the potentiometer

Software: looking through the initial main.c there is a comment that this code uses the ADC and AIC functions to read an analog pin. The libraries used are adc.h and aic.h with actual very little functionality in the aic library files.

Functionality:

Circuitry:

Code Snippet:

//copied from Digilent BASYS MX3 LibPack
AICDemo(){
    //libraries initialization for the used IO modules
    char strMsg[80];    
    int valPot;
    LCD_Init(); 
    AIC_Init(); 
    while(1)
    {    
        valPot = AIC_Val();
        sprintf(strMsg, "Pot:%04d", valPot);
        LCD_WriteStringAtPos(strMsg, 0, 0);
        LCD_WriteStringAtPos("AIC Demo", 1, 0);
    }    
}



 

3.3     Audio Demo

Software: looking through the code the comments  detail this demo's operation: The demo undertakes some audio tasks based on the slide switch positions.

  • SW0     Generate a sinewave tone
  • SW1     Mirror the microphone signal to the loudspeaker
  • SW2     Start recording from the microphone into a circular buffer
  • SW3     Playback to the loudspeaker from the circular buffer

The code uses several of the LibPack library functions to achieve a high level of abstraction. These are adh.h, audio.h, lcd.h, led.h, mic.h and swt.h

Functionality: the video below shows it operating in these four modes with the SW1 being similar to a Theremin due to the speaker-microphone feedback.

Code Snippet:

//copied from Digilent BASYS MX3 LibPack
void AudioDemo()
{
    unsigned int baseCnt = 0;
    LCD_Init();
    SWT_Init();
    LED_Init();
    LCD_WriteStringAtPos("Audio Demo", 0, 0);
    LCD_WriteStringAtPos("Digilent", 1, 0);
      
    while(1)
    {
       if(++baseCnt == 500000) // ensure timing by dividing the frequency of while loops
        {
            baseCnt = 0;
  
            // check the switches status
            if(SWT_GetValue(0))
            {
                if(AUDIO_GetAudioMode() != 0)
                {
                    LED_SetValue(0, 1);
                    AUDIO_Init(0);  // start play sin
                }
            }
            else
            {
                LED_SetValue(0, 0);
                if(AUDIO_GetAudioMode() == 0)
                {
                    AUDIO_Close();  // close play sin
                }
            }
            if(SWT_GetValue(1))
            {
                if(AUDIO_GetAudioMode() != 1)
                {
                    LED_SetValue(1, 1);
                    AUDIO_Init(1);  // start mirror
                }
            }
            else
            {
               LED_SetValue(1, 0);
                if(AUDIO_GetAudioMode() == 1)
                {
                    AUDIO_Close();  // close mirror
                }     
            }
            if(SWT_GetValue(2))
            {
                if(AUDIO_GetAudioMode() != 2)
                {
                    LED_SetValue(2, 1);
                    AUDIO_Init(2);  // start record
                }
            }
            else
            {
                LED_SetValue(2, 0);
                if(AUDIO_GetAudioMode() == 2)
                {
                    AUDIO_Close();  // close record
                }    
            }
            if(SWT_GetValue(3))
            {
                if(AUDIO_GetAudioMode() != 3)
                {
                    LED_SetValue(3, 1);
                    AUDIO_Init(3);  // start play recorded
                }
            }
            else
            {
                LED_SetValue(3, 0);
                if(AUDIO_GetAudioMode() == 3)
                {
                    AUDIO_Close();  // close play recorded
                }    
            }
       }
    }
}

 

3.4     Basic IO Demo

Software: the software shows that this program will read several of the push buttons and depending upon their values switch the RGB LED to a particular colour. I previously modified the code to add their buttons and colours as shown in Digilent BASYS MX3: #1 Software Setup and Development Cycle

Functionality: this demo was the one I modified earlier. As each push button is pressed the RGB LED colour changes accordingly. The button to colour combinations are:

  • left          green
  • right        magenta
  • up           red
  • down      cyan
  • centre     blue

 

Code Snippet:

//copied from Digilent BASYS MX3 Lib
void BasicIODemo(){
    //libraries initialization for the used IO modules
    LCD_Init(); 
    LED_Init(); 
    SWT_Init();
    BTN_Init();
    RGBLED_Init();
    //welcome message displayed on the LCD screen
    LCD_WriteStringAtPos("BasicIO Demo", 0, 0);
    LCD_WriteStringAtPos("Digilent", 1, 0);
    while(1)
    {    
        //set the LEDs value according to the SWT positions: LED is lit when the corresponding SWT is on
        //usage of the Set and Get group Value functions for both SWT and LED libraries
        LED_SetGroupValue(SWT_GetGroupValue());
        //usage of the GetValue function of the SWT library and the SetValue function of the RGBLed library
        if (BTN_GetValue(0))
        {
            //set Red color if SW0 is on - not the maximum value, 255, but 200, close
            RGBLED_SetValue(200,0,0);
        }
        if (BTN_GetValue(1))
        {
            //set Green color if SW0 is on
            RGBLED_SetValue(0,200,0);
        }
        if (BTN_GetValue(2))
        {
            //set Blue color if SW0 is on
            RGBLED_SetValue(0,0,200);
        }      
        //added 14rhb: right press, I want Magenta
        if (BTN_GetValue(3))
        {
            //set Magenta color if SW3 is on
            RGBLED_SetValue(200,0,200);
        } 
        //added 14rhb: down press, I want Cyan
        if (BTN_GetValue(4))
        {
            //set Cyan color if SW4 is on
            RGBLED_SetValue(0,200,200);
        } 
    }    
}

3.5     Basic IO 2 Demo

Software: the code initially shows that the slide switches are read and directly used to set the eight green LED accordingly. The next part of the program then displays a crafted string that uses the switch number to select a character from the "ULCRD" string. The last part of the code, from the above example is now never executed.

Functionality: when run without pressing any buttons the bottom row indicates the five push switches as ULCRD (Up-Left-Centre-Right-Down). As each button is pressed that character is temporarily moved to the top row, as shown in the video. The end of the video also shows the slide switches being read and displayed on the green LEDs.

Code Snippet:

//copied from Digilent BASYS MX3 Lib
void BasicIODemo(){
    char strMsg[80];
    char strPressed[17];
    char strNotPressed[17];
    const char strLet[6] = "ULCRD";
    unsigned int baseCnt = 0;
    unsigned int valBtn, j;

    //libraries initialization for the used IO modules
    LCD_Init();
    LED_Init();
    SWT_Init();
    BTN_Init();
    RGBLED_Init();
    //welcome message displayed on the LCD screen
    LCD_WriteStringAtPos("BasicIO Demo 2", 0, 0);
    LCD_WriteStringAtPos("Digilent", 1, 0);
    LCD_DisplayClear();
    while(1)
    {
        LED_SetGroupValue(SWT_GetGroupValue());
         //write on the LCD the buttons that are pressed or released
        strcpy(strPressed, "Pressed:        ");
        strcpy(strNotPressed, "Released:       ");
        for(j = 0; j<5; j++)
        {
            //usage for the GetValue function of the BTN library
            valBtn = BTN_GetValue(j);
            if(valBtn)
            {
                strPressed[11+j] = strLet[j];
            }
            else
            {
                strNotPressed[11+j] = strLet[j];
            }               
        }

        LCD_WriteStringAtPos(strPressed, 0, 0);
        LCD_WriteStringAtPos(strNotPressed, 1, 0);
        //usage of the GetValue function of the SWT library and the SetValue function of the RGBLed library
        if (SWT_GetValue(0))
        {
            //set Red color if SW0 is on - not the maximum value, 255, but 200, close
            RGBLED_SetValue(200,0,0);
        }
        if (SWT_GetValue(1))
        {
            //set Green color if SW0 is on
            RGBLED_SetValue(0,200,0);
        }
         if (SWT_GetValue(2))
        {
            //set Blue color if SW0 is on
             RGBLED_SetValue(0,0,200);
        } 
    }
}

 

3.6     Basys_Mx3 User Demo

Software: this was the pre-installed demo and it is always a nice feeling to be able to restore a development board to the state it arrived in.

Functionality: I might have corrupted this code as the display did not quite display as expected, although I could not see any issues with it. The RGB LED steps through a sequence of colours, the 7-segment display scrolls along the numbers 0,2,4,6,8, the slide switches are echoed across to the green LED bank and the potentiometer value and accelerometer values are displayed on the LCD display.

Code Snippet:

//copied from Digilent BASYS MX3 Lib
int main(int argc, char** argv)
{
    unsigned char bSwtVal;
    float rgACLGVals[3];
    char strMsg[80];
    int valPot;

    LCD_Init();
    LCD_WriteStringAtPos(LCD_Strings[LCD_Line], 0, 0);
    LCD_WriteStringAtPos(LCD_Strings[LCD_Line+1], 1, 0);
    SWT_Init();
    LED_Init();
    ADC_Init();
    ACL_Init();
    BTN_Init();
    VisCtrlsTest();
    while(1)
    {
            bSwtVal = SWT_GetGroupValue();
            LED_SetGroupValue(bSwtVal);
       
            if(ACL_POT_EN==1){
                ACL_ReadGValues(rgACLGVals);
                valPot = POT_Val();
                sprintf(strMsg, "POT:%04dX:%6.3f", valPot, rgACLGVals[0]);
                LCD_WriteStringAtPos(strMsg, 0, 0);
                sprintf(strMsg, "Y:%6.3fZ:%6.3f", rgACLGVals[1], rgACLGVals[2]);       
                LCD_WriteStringAtPos(strMsg, 1, 0);
            }
            else if (UPDATE_DISP){
                UPDATE_DISP=0;
                LCD_Line+=2;
                LCD_Line%=LINES;
                LCD_WriteStringAtPos(LCD_Strings[LCD_Line], 0, 0);
                LCD_WriteStringAtPos(LCD_Strings[LCD_Line+1], 1, 0);
            }
            if(btn_down==0){//If button is released
                if(BTN_GetValue(0)){//U
                    btn_down=1;
                }
                else if(BTN_GetValue(1)){//L
                    btn_down=1;
                }
                else if(BTN_GetValue(2)){//C Toggle between Message and ACL/Potentiometer Display
                    btn_down=1;
                    ACL_POT_EN^=1;
                    if(!ACL_POT_EN){
                        LCD_WriteStringAtPos(LCD_Strings[LCD_Line], 0, 0);
                    }
                }
                else if(BTN_GetValue(3)){//R
                    btn_down=1;
                }
                else if(BTN_GetValue(4)){//D
                    btn_down=1;
                }
            }
            else{
                if (BTN_GetGroupValue()==0){
                    btn_down=0;
                }
            }
    }
    return (1);
}

 

3.7     Motor Demo

Software: it was not at first apparent what this code did until the MOT_SetPhEnMotor1 functions were also looked at. It was then seen that the code would spin two motors simultaneously and in different directions and at two different speeds.

Functionality: the J5 terminal block is particularly easy to use for a development board. There is a push latch beside each connection to allow a friction clamp to operate on the wire. I used a wooden skewer to push them and I suggest cocktail stick or used match rather than a metal item, which could damage the plastic latches and could slip and short the board. As my motor was only 3v I connected in an external 3v supply via the J11 power jack, whilst still running the board via the USB connector. The motor spun up as expected. I will do some more tests later, but for now I do not want to inadvertently damage the board. If you thought the video below looked a bit odd it is because I used the 'turbine' from my The Trickle Charger

Circuitry:

Code Snippets:

//copied from Digilent BASYS MX3 Lib
void MOT_Demo()
{
    MOT_Init(1);
    LCD_Init();
    LCD_WriteStringAtPos("Motor Demo PH/EN", 0, 0);
    LCD_WriteStringAtPos("1/128      0/255", 1, 0);
    MOT_SetPhEnMotor1(1, 128);
    MOT_SetPhEnMotor2(0, 255);
}

 

//copied from Digilent BASYS MX3 Lib
void MOT_SetPhEnMotor1(unsigned char bDir, unsigned char bSpeed)
{
    if(bMode)
    {
        // PH/EN mode
        lat_MOT_AIN1 =(bDir ? 1: 0);
        OC2RS = MOT_PhEnComputeOCFromSpeed(bSpeed);
    }
}

3.8     SPI Flash Demo

Software: recall that in addition to the 512KByte of program memory and 128KBytes of RAM within the PIC32MX370F512L this Digilent board has a massive 4MBytes of SPI Flash RAM. The code clears the entire SPI flash memory and then writes a page of 256 bytes. It then appears to cycle around that page reading back in the SPI RAM values. Additionally the value is written to the Seven Segment Display.

Functionality: as detailed above the demo writes and reads to the SPI Flash using a 256 byte page.

A short video of this is shown below:

Code Snippet:

//copied from Digilent BASYS MX3 Lib
void SPIFLASH_Demo()
{
    unsigned char spiFlashPageW[SPIFLASH_PROG_SIZE]; // 256 bytes
    unsigned char spiFlashPageR[SPIFLASH_PROG_SIZE]; // 256 bytes
    unsigned char valSpiFlash;
    float rgACLGVals[3];
    char strMsg[80];
    unsigned int wCnt = 0, baseCnt = 0, valPot, addrSpiFlash, addrInPage;
    LCD_Init();
    LCD_WriteStringAtPos("SPI Flash test", 0, 0);
    LCD_WriteStringAtPos("Erase Flash ...", 1, 0);
    SPIFLASH_Init();
        // erase all flash
    SPIFLASH_EraseAll();
    // initialize the write and read buffers
    for(addrInPage = 0; addrInPage < SPIFLASH_PROG_SIZE; addrInPage++)
    {
        spiFlashPageW[addrInPage] = addrInPage << 1; // address multiplied by 2
        spiFlashPageR[addrInPage] = 0xFF;           // this should be overwritten by read values
    }
    LCD_WriteStringAtPos("Write buffer ...", 1, 0);
    SPIFLASH_ProgramPage(SPIFLASH_PROG_ADDR, spiFlashPageW, SPIFLASH_PROG_SIZE);

    LCD_WriteStringAtPos("Read buffer ...", 1, 0);
    SPIFLASH_Read(SPIFLASH_PROG_ADDR, spiFlashPageR, SPIFLASH_PROG_SIZE);
    SSD_Init();

    while(1)
    {
        if(++baseCnt == 500000)
        {

            baseCnt = 0;   
//            addrInPage = wCnt & 0xFF;                         // available for SPIFLASH_PROG_SIZE = 256
//            addrInPage = wCnt & (SPIFLASH_PROG_SIZE - 1);     // available for SPIFLASH_PROG_SIZE power of 2
            addrInPage = wCnt % SPIFLASH_PROG_SIZE;                
            sprintf(strMsg, "ADDR:%02d  Val:%03d", addrInPage, spiFlashPageR[addrInPage]);   
            LCD_WriteStringAtPos(strMsg, 1, 0);
            SSD_WriteDigitsGrouped(wCnt++, 0);
        }
    }
}

 

3.9     SPI JA Demo

Software: this demo is meant to use the Digilent Pmod Digital to Analog conversion board but unfortunately I don't have one. The code appears to write two bytes to the SPI/Pmod the second being the value that is required for the analog output.

Functionality: connecting up an oscilloscope it is possible to still see the Tx data changing on the PmodA connector. The video below shows this and if you think how binary values increment you will be able to see they are indeed clocking upward in value as they are sent out to the Pmod board. The Digilent PmodDA board is also shown below:

Code Snippet:

//copied from Digilent BASYS MX3 Lib
void SPIJADemo()
{
    float dMaxValue = 3;
    float dMinValue = 0;
    float dStep = 0.05;
    float dValue;
    unsigned char bVal, bWrBytes[2], bRdBytes[2];

    float fConvConst = ((float)(1<<noBits))/ fRef;
    //perform modules initialization
    LCD_Init();
    SPIJA_Init();
    LCD_WriteStringAtPos("SPIJA Demo",0 ,0);
    while(1)
    {
        for(dValue = dMinValue; dValue < dMaxValue; dValue+= dStep)
        {
            //compute the value to be sent to the DA module. PmodDA1 has been used for this demo
            bVal = (unsigned char)(dValue * fConvConst);
            bWrBytes[0] = DACSPI1_CTRL_BYTE; // selecting convertor DAC A to be written
            bWrBytes[1] = bVal;              // value corresponding to the voltage to be represented
            // send bVal over SPI
            SPIJA_TransferBytes(2, bRdBytes, bWrBytes);
        }
    }
}

 

3.10     SSD Demo

Software: inspection of the code shows this demo uses a counter which clocks up to 10,000 and is displayed on the seven segment display. Pressing the centre pushbutton resets that value.

Functionality: indeed the operation is as expected. This example does show how an integer value can be displayed on the SSD as hexadecimal using the SSD_WriteDigitsGrouped function.

Code Snippet:

//copied from Digilent BASYS MX3 Lib
void SSDDemo()
{
    unsigned int wCnt = 0, baseCnt = 0;
    LCD_Init();
    SSD_Init();
    BTN_Init();
    LCD_WriteStringAtPos("SSD Demo", 0, 0);
    LCD_WriteStringAtPos("Digilent", 1, 0);

    while(1)
    {
       if(++baseCnt == 1000000)
        {
            //display the counter values on the 4 digits available
            SSD_WriteDigitsGrouped(wCnt++, 0);
            baseCnt = 0;   
            //if button C is pressed, reset the counter
            if (BTN_GetValue(2))
            {
                wCnt=0;
            }
        }
    }
}

 

3.11     Tmp3 Demo

Software: this code is aimed at the Digilent PMod Temperature Board as shown below. The code gets the temperature from the PMod accessory and displays the value on the LCD screen.

Functionality: unfortunately I cannot show the values being read via an oscilloscope as there is no board to read from. Seems like I need to buy a few Pmod boards as this isn't the first development board where they would be useful.

Code Snippet:

//copied from Digilent BASYS MX3 Lib
void Tmp3Demo(){
    float fVal;
    char strMsg[80];
    unsigned int baseCnt = 0;
    LCD_Init();
    LCD_WriteStringAtPos("PmodTMP3 Demo", 0, 0);
    LCD_WriteStringAtPos("Digilent", 1, 0);
    PMODTMP3_Init(TMP3_RES12);
    while(1)
    {
       //perform temperature readings only once in a while, to be able to visualize the results
        if(++baseCnt == 400000)
       {
            baseCnt = 0;   
            fVal = PMODTMP3_GetTemp();
            //display on the LCD screen the temperature value, on second row
            sprintf(strMsg, "Temp = %6.3f  C", fVal);
            strMsg[14] = (unsigned char)223;    // extended ASCII code for degree sign
            LCD_WriteStringAtPos(strMsg, 1, 0);
        }
    }
}

 

3.12     UART Demo

Software: there are three functions that can be called and I've decided to use the UARTDemoInt function.

Functionality: typically as the last example I could not get this to work completely. I was powering the BASYS-MX3 from the Debug UART and used the second UART port for this demo, which connected to COM18 on my PC. I used PuTTY and was able to get the UART messages. I even modified the code slightly to ensure I was seeing what I expected to. However adding the implicit CR and LF options in PuTTY did not result in the messages getting displayed on the BASYS MX3 LCD display. I think the issue is still with how I have setup PuTTY. The Tx LED by the UART flashed each time I send a character across so I believe it was echoing my values. Therefore this demo is nearly working but needs some slight investigation still to work as I believe it should.

Code Snippet:

//copied from Digilent BASYS MX3 Lib
int main(int argc, char** argv)
{
    //use either one of the functions to communicate via UART interface: interrupt based or polling
    UARTDemoInt();
    //UARTDemoPoll();
    //use the UARTJB lib to communicate via PmodJB using UART
    //UARTDemoPmod();
    return (1);
}
//copied from Digilent BASYS MX3 Lib
void UARTDemoInt(){

    char strTxti[cchRxMax];
    unsigned char cchi;
    //UART and LCD basic initializations
    UART_Init(9600);
    LCD_Init();
    //send a text to UART terminal on PC
    UART_PutString("UART Demo \n\r");
    UART_PutString("Send a text file\n\r");
    LCD_WriteStringAtPos(" UART Demo Int", 0, 0);
    LCD_DisplayClear();
    //when sending a text file, make sure the content ends with CR+LF and your terminal is also setup accordingly, to transmit both characters
    //otherwise, the file sending will not function correctly
    while(1){
        cchi = UART_GetString(strTxti, cchRxMax);
        if(cchi > 0)
        {
          //display the received string on the LCD
          LCD_WriteStringAtPos(strTxti, 0, 0);
          LCD_WriteStringAtPos("UART Int Demo", 1, 0);
          //send the content of the file back to UART to be visualized
          UART_PutString(strTxti);
        }
    }
}

 

4.     Summary

The majority of these LibPack demonstration projects worked very well. Only one had difficulties due I think to my PuTTY setup and a couple of demos required Pmod boards that I did not have. However they all showed how the LibPack source and header files were pulled into MPLAB X IDE and compiled/run.

 

Each demo project started the main.c with the standard C #include constructs. That was always followed by some #pragma statements: these setup the configuration bits for the device. I believe there are other ways of generating these including the Microchip Code Configurator and Production/Set Configuration Bits. If an alternate method is chosen it would be necessary to ensure the values are not duplicated and hence the wrong set is utilised.

 

I did report earlier that I was having trouble using the inbuilt device programmer in MPLAB X IDE and instead I used the MPLAB X IPE. Well that also soon started to have inconsistencies and failed to program even after the board was turned off. The IPE software only started working again after closing and restarting MPLAB X IPE. I tried the programmer that was built into MPLAB X IDE again and all seemed to work OK this time. I've circled the icon I use in the diagram below.

 

Regarding my aims for blog#2 I think I've achieved them all:

  • Explore all twelve projects in the Digilent LibPack library to show what they do
  • To discuss and gain an understanding of how these projects use the LibPack libraries
  • To consolidate my understanding of the non-RTOS based projects
  • To ensure I am confident compiling and programming this board with MPLAB X IDE or IPE

 

5.     What Next?

Next I will look at some of the associated training materials and experimenting with each of the Seattle University's workshop projects.

 

I then want to make my own project(s) using this board - I was not sure what and had thought a simple non-RTOS project and a more complex RTOS project would be great. However after seeing the Pmod I realise I did buy a CMPS2 PMod compass unit and I am keen to use that for my project.

 

If time allows I would also like to cover the debug operation of MPLAB X IDE and where the Digilent Analog Discovery can be used.

 

A final consolidation of my views will be found in the coming weeks when I publish a roadtest review of this Digilent BASYS MX3 board in BASYS MX3 Trainer Board

 

6.     Resources

 

7.     Buying the Board

If you want one of these boards you can purchase one from Farnell / Avnet Product LinkProduct Link

 

My final roadtest review can be seen BASYS MX3 Trainer Board - Review