Accessing the serial port in assembly comes in the form of macros (READSER and WRITSER). These macros allow for multiple bytes of data to be written to the serial port buffer at a time.

The core file allows up to 126 characters to be stored in the input and output buffers. No checks to protect against buffer overflows are made, so do not allow the input and output buffers to overflow. (The length of the buffers can be changed by changing ser_rxlen and ser_txlen values in the core.asm file.) The buffers are 127 characters long; however, the code cannot distinguish between a completely-full and completely-empty buffer. Therefore, only 126 characters can be stored in the buffers.

It is easy to check if the input or output buffers in memory are empty. The input buffer can be checked by comparing the values stored in the memory locations srx_head and srx_tail; if both memory locations hold the same value, the input buffer is empty. Likewise, the output buffer can be checked by comparing the values stored in memory locations stx_head and stx_tail. The number of characters in the buffer can be computed by subtracting the head pointer from the tail pointer; add the length of the buffer (normally 127) if the resulting distance is negative.

1 .copy "v:\54x\dsplib\core.asm" 
2 
3       .sect ".data" 
4 hold  .word 0 
5 
6       .sect ".text" 
7 main 
8       stm #hold,AR3       ; Read to hold location  
9 
10      READSER 1          ; Read one byte from serial port 
11          
12      cmpm AR1,#1        ; Did we get a character? 
13      bc main,NTC        ; if not, branch back to start 
14 
15      stm #hold,AR3      ; Write from hold location 
16      WRITSER 1          ; ... one byte 
17 
18      b main 
            

.copy "v:\ece320\54x\dsplib\core.asm" 
                                    
                                    
        .sect ".data" 
value_1 .word 0 
value_2 .word 0 
                    
                    
        .sect ".text" 
main: 
                    
loop: 
        WAITDATA 
                
        call #get_data      ; call function to get serial port data 
                    
        stm #BlockLen-1, BRC 
        rptb endblock-1 
                
        ;******your code goes here
                    
endblock: 
        b loop 


                    
get_data: 
        pshm AR0            ; we save all registers that are used in 
        pshm AR2            ; this function - note that accumulator 
        pshm AR3            ; B IS OVERWRITTEN! 
        pshm BK 
                    
        mvdm #srx_head, AR2 ; srx_head, defined in core.asm, points 
                            ; to one element past the last value 
                            ; recieved in the serial recieve buffer 
                                            
        stm #ser_rxlen, BK  ; set BK to length of receive buffer 
                        
        mar *+AR2(-4)%      ; AR2 now points to the most recently 
                            ; received block of 24 bits, i.e. one 8 
                            ; bit value and one 16 bit value 
                   
        stm #1, AR0         ; set increment 
                        
        stm #value_1, AR3   ; get first value 
        mvdd *AR2+0%, *AR3  ; save at value_1 
                        
        stm #value_2, AR3   ; get second value 
        ld *AR2+%, 8, B     ; place first 8 bits in high part of B 
        or *AR2+%, B        ; combine last 8 bits in low part of B 
        stl B, *AR3         ; save at value_2 
                    
        popm BK 
        popm AR3 
        popm AR2 
        popm AR0 
        ret
                

There are several functions for transmitting and receiving serial data within the C environment:

1   #include "v:/ece320/54x/dspclib/core.h" /* Declarations for core file */ 
2 
3   main() 
4   { 
5       int *Rcvptr, *Xmitptr; /* pointers to Xmit and Rcv Bufs */ 
6       int i; 
7  
8       while(1) 
9       { 
10          WaitAudio(&Rcvptr, &Xmitptr); 
11 
12          for(i=0; i < BlockLen; i++) 
13          { 
14              Xmitptr[6*i] = Rcvptr[4*i]; 
15              Xmitptr[6*i+1] = Rcvptr[4*i]; 
16              Xmitptr[6*i+2] = Rcvptr[4*i]; 
17              Xmitptr[6*i+3] = Rcvptr[4*i+2]; 
18              Xmitptr[6*i+4] = Rcvptr[4*i+2];         
19              Xmitptr[6*i+5] = Rcvptr[4*i+2]; 
20          } 
21 
22          i = SerialRX(); /* Check serial port */ 
23          if (i > 0) 
24              SerialTX(i); /* Echo received byte */ 
25 
26      } 
27  } 
            

1   #include "v:/ece320/54x/dspclib/core.h" /* Declarations for core file */ 
2 
3   main() 
4   { 
5       int *Rcvptr, *Xmitptr; /* pointers to Xmit and Rcv Bufs */ 
6       int i; 
7       int array[10]; 
8 
9       while(1) 
10      { 
11          WaitAudio(&Rcvptr,&Xmitptr); 
12 
13          for(i=0; i < BlockLen; i++) 
14          { 
15              Xmitptr[6*i] = Rcvptr[4*i]; 
16              Xmitptr[6*i+1] = Rcvptr[4*i]; 
17              Xmitptr[6*i+2] = Rcvptr[4*i]; 
18              Xmitptr[6*i+3] = Rcvptr[4*i+2]; 
19              Xmitptr[6*i+4] = Rcvptr[4*i+2]; 
20              Xmitptr[6*i+5] = Rcvptr[4*i+2];             
21          } 
22 
23          if ( SerialRXBufCheck() >= 10 ) 
24              SerialRXm(10,array); /* copy serial receive data into array1 */ 
25              SerialTXm(10,array); /* echo all ten bytes */ 
26 
27      } 
28  } 
                

Before accessing the serial port, it must be initialized through MATLAB. This is done with this code:

    % Set serial port mode 
    !mode com2:38400,n,8,1
                

    % open com port for data transfer 
    fid = fopen('com2:','w'); 
                

    fwrite(fid,data,'int8'); 
                

Before finishing a function, or before executing a read from the serial port, the port MUST BE CLOSED. Failure to close the port, will result in blocking access to other functions and apps on the machine that need to use the port. A reset pulse is sent before closing. The port is closed with the fclose command:

    % send reset pulse 
    fwrite(fid,255,'int8'); 
    % close com port connection 
    fclose(fid); 
                

Although MATLAB is supposed to support both writing and reading data from the serial port, reading data seems to either produce no result, generate an error, or crash MATLAB. To remedy the situation GetSerialData() has been written. This function will allow you to get vectors of data from the serial port buffer.

    mex GetSerialData.cpp
                    

        y = GetSerialData('port', baud, size); 
                    

        GetSerialData('help'); 
                    

%In the MATLAB terminal: 

y = GetSerialData('com2', 38400, 6) 

y = 
    
        7 8 9 10 11 12 
                    

y = getSerialData('com2', 38400, 6, 1) 

y = 

        125 126 127 0 -1 -2                     
                    

1   % ser_set: Initialize serial port and create three sliders 
2 
3   % Set serial port mode 
4   !mode com2:38400,n,8,1 
5 
6   % open a blank figure for the slider 
7   Fig = figure(1); 
8 
9   % open sliders 
10 
11  % first slider 
12  sld1 = uicontrol(Fig,'units','normal','pos',[.2,.7,.5,.05],... 
13  'style','slider','value',4,'max',254,'min',0,'callback','wrt_slid'); 
14
15  % second slider 
16  sld2 = uicontrol(Fig,'units','normal','pos',[.2,.5,.5,.05],... 
17  'style','slider','value',4,'max',254,'min',0,'callback','wrt_slid'); 
18 
19  % third slider 
20  sld3 = uicontrol(Fig,'units',normal','pos',[.2,.3,.5,.05],... 
21  'style','slider','value',4,'max',254,'min',0,'callback','wrt_slid');  
                

Lines 12 through the end create the three sliders for the user interface. Several parameters are used to specify the behavior of each slider. The first parameter, Fig, tells the slider to create itself in the window we created in Line 7. The rest of the parameters are property/value pairs:

1   % wrt_slid: write values of sliders out to com port 
2 
3   % open com port for data transfer 
4   fid = fopen('com2:','w'); 
5 
6   % send data from each slider 
7   v = round(get(sld1,'value')); 
8   fwrite(fid,v,'int8'); 
9 
10  v = round(get(sld2,'value')); 
11  fwrite(fid,v,'int8'); 
12
13  v = round(get(sld3,'value')); 
14  fwrite(fid,v,'int8'); 
15 
16  % send reset pulse 
17  fwrite(fid,255,'int8'); 
18 
19  % close com port connection 
20  fclose(fid);  
                

Line 7 retrieves the value from the slider using the get function to retrieve the value property. The value is then rounded off to create an integer, and the integer is sent as an 8-bit quantity to the DSP in Line 8. (The number that is sent at this step will appear when the serial port is read with READSER or a C equivalent in your code.) The other two sliders are sent in the same way. Line 17 sends 0xFF (255) to the DSP, which can be used to indicate that the three previously-transmitted values represent a complete set of data points. This can be used to prevent the DSP and Matlab from losing synchronization if a transmitted character is not received by the DSP.

The slider example shows some basic features of the gui tools. The file descriptor is generated into the workspace so that it can be used for writing. But other elements, such as text boxes cannot be dealt with as easily. The Parameters from these can be accessed through their returned handles. Some examples:

%GUI.m
%****Sample GUI, Text and a Button***

%open a blank figure
Fig = figure(1);
set(Fig,'Name','Test GUI');

%Space to enter text
ed2 = uicontrol(Fig,'backgroundcolor','white','units','Normalized','pos',[.1,.6,.4,.05],...
                'string','Default Text','style','edit');

%Button
but1 = uicontrol(Fig,'foregroundcolor','blue','units','Normalized','pos',[.1,.4,.5,.1],...
                'string','Press Me!','style','pushbutton','callback','SampleGUI');
            

%SampleGUI.m

%Get Text
testText = get(ed2,'string')