void main()
{
.......................................................
    MDR_RST_CLK->PER_CLOCK|=(1<<20)|(1<<23)|(1<<24);
    MDR_PORTD->ANALOG|=(1<<2)|(1<<6);              
    MDR_PORTD->FUNC=0x2020;                                        
    MDR_PORTD->PWR|=0x3030;                           
    MDR_PORTD->OE|=(1<<6);                          
    // PS! PD5 is broken! Not work!
    MDR_PORTC->ANALOG|=1|(1<<1);                    
    MDR_PORTC->FUNC=0x0F;                    
    MDR_PORTC->PWR|=0x0F;                              
    MDR_RST_CLK->SSP_CLOCK|=(1<<25);                 // Enable SSP2
           MDR_SSP2->CR0=15|(1<<4);                        
    MDR_SSP2->CR1|=1<<2;                                 // Slave
    MDR_SSP2->CR1|=1<<1;                                 // Start SSP2
...................................................................
}

    while (1)
    {
...............
    while((MDR_SSP2->SR&4)==0);
    tx=MDR_SSP2->DR;
    while((MDR_UART1->FR&64)!=0);
    MDR_UART1->DR=tx;
...............
         }

0
1
2
3
4
5
6
7
8
9
10
11
12
13
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
0
1
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
0
1
2
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
0
1
2
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
0
1
2
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
0
1
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
0
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
0
1
2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
37
38
39
40
41
42
43
44
45
46
47

void main()
{
void main()
{
   int i;
  
   MDR_RST_CLK->HS_CONTROL=3;                                          
   while (MDR_RST_CLK->CLOCK_STATUS==0);  
   MDR_RST_CLK->PLL_CONTROL=(11<<8)|(1<<2);                                    
   MDR_RST_CLK->CPU_CLOCK=0x106;                                    //CPU_CLK=HSE+PLL


   MDR_RST_CLK->PER_CLOCK|=(1<<20)|(1<<23)|(1<<24); // Open clk for SSP2, PORTC, PORTD
   MDR_PORTC->ANALOG|=1|(1<<1)|(1<<2);              // PC0 - FSS, PC1 - CLK, PC2 - RX
   MDR_PORTC->FUNC=0x3F;                                    // ReAF - PC0, PC1, PC2
   MDR_PORTC->PWR=0x3F;                               //
   MDR_PORTC->OE=0;
   /*MDR_PORTD->ANALOG|=(1<<6);                     // PD6 - TX
   MDR_PORTD->FUNC=0x2000;                                  // AF - PD6
   MDR_PORTD->PWR|=0x3000;                            //
   MDR_PORTD->OE|=(1<<6);                           // PD6 - output
   */
   MDR_RST_CLK->SSP_CLOCK|=(1<<25);                 // Enable SSP2
   MDR_SSP2->CR0=15|(1<<4);                         // 16 bits, SPI TI page 339
   MDR_SSP2->CR1|=(1<<3)|(1<<2)|(1<<1);  
      
   MDR_RST_CLK->PER_CLOCK|=1<<21;                                        
   MDR_PORTA->ANALOG|=(1<<6)|(1<<7);  
   MDR_PORTA->FUNC|=(15<<12);                                                
   MDR_PORTA->PWR|=(15<<12);                                                    
   MDR_PORTA->OE|=1<<7;                                                    
   MDR_RST_CLK->PER_CLOCK|=(1<<6)|(1<<7);                                      
   MDR_RST_CLK->UART_CLOCK=(1<<24)|(1<<25);                                  
   MDR_UART1->IBRD=41;                          
   MDR_UART1->LCR_H=(3<<5)|(1<<4);                                          
   MDR_UART1->CR=(1<<8)|(1<<9)|(1<<0);                                        

  
   while (1)
   {
     if((MDR_SSP2->SR&4)>0)
      {
         tx=MDR_SSP2->DR;
         while((MDR_UART1->FR&64)!=0);
         MDR_UART1->DR=tx;
      }
   }
}

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
57
58
59
60
61
62
63
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
59
60
61
62
63
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
51
52
53
54
55
56
57
58
59
60
61
62
63
0
1
2
3
4
5
6
7
9
10
11
12
13
14
15
16
52
53
54
55
56
57
58
59
60
61
62
63
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
53
54
55
56
57
58
59
60
61
62
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
55
56
57
58
59
60
61
62
63
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
56
57
58
59
60
61
62
63
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
57
58
59
60
61
62
63
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
59
60
61
62
63
0
1
2
3
4
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
51
52
53
54
55
56
57
58
59
60
61
62
63

    RST_CLK_PCLKcmd((RST_CLK_PCLK_SSP2 | RST_CLK_PCLK_PORTB | RST_CLK_PCLK_PORTF),ENABLE);
    SSP_InitTypeDef sSSP;

    SSP_DeInit(MDR_SSP2);
    SSP_BRGInit(MDR_SSP2,SSP_HCLKdiv1);
    SSP_StructInit (&sSSP);

    sSSP.SSP_SCR  = 0x1;
    sSSP.SSP_CPSDVSR = 2;
    sSSP.SSP_Mode = SSP_ModeMaster;
    sSSP.SSP_WordLength = SSP_WordLength16b;
    sSSP.SSP_SPH = SSP_SPH_2Edge;    // фаза сигнала SSPCLKOUT
    sSSP.SSP_SPO = SSP_SPO_Low;        // полярность сигнала SSPCLKOUT
    sSSP.SSP_FRF = SSP_FRF_SPI_Motorola;
    sSSP.SSP_HardwareFlowControl = SSP_HardwareFlowControl_None;
    SSP_Init (MDR_SSP2,&sSSP);

    SSP_Cmd(MDR_SSP2, ENABLE);