API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 29th, 2016
69
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 15.07 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  *  RFC 1521 base64 encoding/decoding
  3.  *
  4.  *  Copyright (C) 2006-2010, Brainspark B.V.
  5.  *
  6.  *  This file is part of PolarSSL (http://www.polarssl.org)
  7.  *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
  8.  *
  9.  *  All rights reserved.
  10.  *
  11.  *  This program is free software; you can redistribute it and/or modify
  12.  *  it under the terms of the GNU General Public License as published by
  13.  *  the Free Software Foundation; either version 2 of the License, or
  14.  *  (at your option) any later version.
  15.  *
  16.  *  This program is distributed in the hope that it will be useful,
  17.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  *  GNU General Public License for more details.
  20.  *
  21.  *  You should have received a copy of the GNU General Public License along
  22.  *  with this program; if not, write to the Free Software Foundation, Inc.,
  23.  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  24.  */
  25.  
  26.  
  27. #include "base64.h"
  28. #include <stdio.h>
  29. #include <uart.h>
  30. #include <system/peripherals.h>
  31. #include <libacc.h>
  32.  
  33. // im Feld "base64_test_dec" werden 237 Byte initialisiert!
  34. //#define MSG_SIZE 237
  35. //#define ENC_MSG_SIZE 316
  36. #define MSG_SIZE 40
  37. #define ENC_MSG_SIZE 56
  38.  
  39. //unsigned char buf[64];
  40.  
  41. static const unsigned char base64_enc_map[64] =
  42. {
  43.     'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
  44.     'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
  45.     'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
  46.     'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
  47.     'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
  48.     'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
  49.     '8', '9', '+', '/'
  50. };
  51.  
  52. static const unsigned char base64_dec_map[128] =
  53. {
  54.     127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
  55.     127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
  56.     127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
  57.     127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
  58.     127, 127, 127,  62, 127, 127, 127,  63,  52,  53,
  59.      54,  55,  56,  57,  58,  59,  60,  61, 127, 127,
  60.     127,  64, 127, 127, 127,   0,   1,   2,   3,   4,
  61.       5,   6,   7,   8,   9,  10,  11,  12,  13,  14,
  62.      15,  16,  17,  18,  19,  20,  21,  22,  23,  24,
  63.      25, 127, 127, 127, 127, 127, 127,  26,  27,  28,
  64.      29,  30,  31,  32,  33,  34,  35,  36,  37,  38,
  65.      39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
  66.      49,  50,  51, 127, 127, 127, 127, 127
  67. };
  68.  
  69.  
  70. // Das Feld "base64_test_dec" wird hier mit 237 Byte initialisiert!
  71. static const unsigned char base64_test_dec[MSG_SIZE] =
  72. {
  73.  0x53, 0x6f, 0x2b, 0x4c, 0x6f, 0x6e, 0x67, 0x2c,
  74.  0x2b, 0x61, 0x6e, 0x64, 0x2b, 0x54, 0x68, 0x61,
  75.  0x6e, 0x6b, 0x73, 0x2b, 0x66, 0x6f, 0x72, 0x2b,
  76.  0x41, 0x6c, 0x6c, 0x2b, 0x74, 0x68, 0x65, 0x2b,
  77.  0x46, 0x69, 0x73, 0x68, 0x00, 0x00, 0x00, 0x00
  78. //  0x41, 0x6E, 0x2B, 0x43, 0x68, 0x61, 0x72, 0x6C,
  79. //  0x6F, 0x74, 0x74, 0x65, 0x2B, 0x76, 0x6F, 0x6E,
  80. //  0x2B, 0x53, 0x74, 0x65, 0x69, 0x6E, 0x2B, 0x2B,
  81. //  0x57, 0x6F, 0x68, 0x65, 0x72, 0x2B, 0x73, 0x69,
  82. //  0x6E, 0x64, 0x2B, 0x77, 0x69, 0x72, 0x2B, 0x67,
  83. //  0x65, 0x62, 0x6F, 0x72, 0x65, 0x6E, 0x2B,
  84. //  0x41, 0x75, 0x73, 0x2B, 0x4C, 0x69, 0x65, 0x62,
  85. //  0x2B, 0x57, 0x69, 0x65, 0x2B, 0x77, 0x61,
  86. //  0x65, 0x72, 0x65, 0x6E, 0x2B, 0x77, 0x69, 0x72,
  87. //  0x2B, 0x76, 0x65, 0x72, 0x6C, 0x6F, 0x72, 0x65,
  88. //  0x6E, 0x2B, 0x4F, 0x68, 0x6E, 0x2B, 0x4C,
  89. //  0x69, 0x65, 0x62, 0x2B, 0x57, 0x61, 0x73,
  90. //  0x2B, 0x68, 0x69, 0x6C, 0x66, 0x74, 0x2B, 0x75,
  91. //  0x6E, 0x73, 0x2B, 0x75, 0x65, 0x62, 0x65, 0x72,
  92. //  0x77, 0x69, 0x6E, 0x64, 0x65, 0x6E, 0x2B,
  93. //  0x44, 0x69, 0x65, 0x2B, 0x4C, 0x69, 0x65, 0x62,
  94. //  0x2B, 0x4B, 0x61, 0x6E, 0x6E, 0x2B, 0x6D,
  95. //  0x61, 0x6E, 0x2B, 0x61, 0x75, 0x63, 0x68, 0x2B,
  96. //  0x4C, 0x69, 0x65, 0x62, 0x65, 0x2B, 0x66, 0x69,
  97. //  0x6E, 0x64, 0x65, 0x6E, 0x2B, 0x44, 0x75,
  98. //  0x72, 0x63, 0x68, 0x2B, 0x4C, 0x69, 0x65, 0x62,
  99. //  0x2B, 0x57, 0x61, 0x73, 0x2B, 0x6C, 0x61,
  100. //  0x65, 0x73, 0x73, 0x74, 0x2B, 0x6E, 0x69, 0x63,
  101. //  0x68, 0x74, 0x2B, 0x6C, 0x61, 0x6E, 0x67, 0x65,
  102. //  0x2B, 0x77, 0x65, 0x69, 0x6E, 0x65, 0x6E, 0x2B,
  103. //  0x44, 0x69, 0x65, 0x2B, 0x4C, 0x69, 0x65,
  104. //  0x62, 0x2B, 0x57, 0x61, 0x73, 0x2B, 0x73,
  105. //  0x6F, 0x6C, 0x6C, 0x2B, 0x75, 0x6E, 0x73, 0x2B,
  106. //  0x73, 0x74, 0x65, 0x74, 0x73, 0x2B, 0x76, 0x65,
  107. //  0x72, 0x65, 0x69, 0x6E, 0x65, 0x6E, 0x2B,
  108. //  0x44, 0x69, 0x65, 0x2B, 0x4C, 0x69, 0x65, 0x62
  109.    
  110. };
  111.  
  112. static const unsigned char base64_test_enc[] = "U28rTG9uZywrYW5kK1RoYW5rcytmb3IrQWxsK3RoZStGaXNoAAAAAA==";
  113.  
  114. //         "QW4rQ2hhcmxvdHRlK3ZvbitTdGVpbisrV29oZXIrc2luZCt3aX"
  115. //   "IrZ2Vib3JlbitBdXMrTGllYitXaWUrd2FlcmVuK3dpcit2ZXJsb"
  116. //   "3JlbitPaG4rTGllYitXYXMraGlsZnQrdW5zK3VlYmVyd2luZGVuK"
  117. //   "0RpZStMaWViK0thbm4rbWFuK2F1Y2grTGllYmUrZmluZGVuK0R1"
  118. //   "cmNoK0xpZWIrV2FzK2xhZXNzdCtuaWNodCtsYW5nZSt3ZWluZW4r"
  119. //   "RGllK0xpZWIrV2FzK3NvbGwrdW5zK3N0ZXRzK3ZlcmVpbmVuK0"
  120. //   "RpZStMaWVi";
  121.  
  122. // "U28rTG9uZywrYW5kK1RoYW5rcytmb3IrQWxsK3RoZStGaXNo"
  123. // "So+Long,+and+Thanks+for+All+the+Fish"
  124. // 0x53, 0x6f, 0x2b, 0x4c, 0x6f, 0x6e, 0x67, 0x2c,
  125. // 0x2b, 0x61, 0x6e, 0x64, 0x2b, 0x54, 0x68, 0x61,
  126. // 0x6e, 0x6b, 0x73, 0x2b, 0x66, 0x6f, 0x72, 0x2b,
  127. // 0x41, 0x6c, 0x6c, 0x2b, 0x74, 0x68, 0x65, 0x2b,
  128. // 0x46, 0x69, 0x73, 0x68
  129.  
  130. /*
  131.  * Encode a buffer into base64 format
  132.  */
  133. int base64_encode( unsigned char *dst, uint32_t *dlen,
  134.                    const unsigned char *src, uint32_t slen)
  135. {
  136.     uint32_t i, n;
  137.     unsigned int C1, C2, C3;
  138.     unsigned char *p;
  139.  
  140.     if( slen == 0 )
  141.         return( 0 );
  142.  
  143.     //printf("\r\nslen: %d n: %d\r\n",slen,n);
  144.  
  145.     n = (slen << 3);
  146.     //printf("\r\nn: %d\r\n",n);
  147.     n = n / 6;
  148.    
  149.     //printf("\r\nn: %d\r\n",n);
  150.  
  151.     switch( (slen << 3) - (n * 6) )
  152.     {
  153.         case  2: n += 3; break;
  154.         case  4: n += 2; break;
  155.         default: break;
  156.     }
  157.     //printf("\r\nn: %d\r\n",n);
  158.    
  159.     //printf("\r\n*dlen: %d n: %d\r\n",*dlen,n);
  160.  
  161.     if( *dlen < n + 1 )
  162.     {
  163.     printf("\r\n *dlen %d, n %d",*dlen,n);          
  164.         *dlen = n + 1;
  165.         return( POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL );
  166.     }
  167.  
  168.     n = (slen / 3) * 3;
  169.     //printf("\r\nnew n: %d\r\n",n);
  170.    
  171.     //printf("\r\nbuf: %X ",buf);
  172.     p = dst;
  173.     //printf("p: %X \r\n",p);
  174.      //return 1;
  175.  
  176.     for( i = 0; i < n; i += 3 )
  177.     {
  178.        //NO_SYNTHESIS;
  179.        C1 = *src++;
  180.        C2 = *src++;
  181.        C3 = *src++;
  182.  
  183.        *p++ = base64_enc_map[(C1 >> 2) & 0x3F];
  184.        *p++ = base64_enc_map[(((C1 &  3) << 4) + (C2 >> 4)) & 0x3F];
  185.        *p++ = base64_enc_map[(((C2 & 15) << 2) + (C3 >> 6)) & 0x3F];
  186.        *p++ = base64_enc_map[C3 & 0x3F];
  187.       // *p++ = base64_enc_map[i];
  188.       // *p++ = base64_enc_map[i+1];
  189.       // *p++ = base64_enc_map[i+2];
  190.       // *p++ = base64_enc_map[i+3];
  191.         //printf("last C1: %d C2: %d\r\n",C1,C2);
  192.        // printf("last loop p: %X *p: %d\r\n",p,*p);
  193.     }
  194.  
  195.  
  196.  
  197.     if( i < slen )
  198.     {
  199.         //printf("i:%d slen:%d \r\n",i,slen);
  200.         C1 = *src++;
  201.         C2 = ((i + 1) < slen) ? *src++ : 0;
  202.  
  203.         *p++ = base64_enc_map[(C1 >> 2) & 0x3F];
  204.         *p++ = base64_enc_map[(((C1 & 3) << 4) + (C2 >> 4)) & 0x3F];
  205.          //printf("last p: %X *p: %d\r\n",p,*p);
  206.  
  207.         if( (i + 1) < slen )
  208.              *p++ = base64_enc_map[((C2 & 15) << 2) & 0x3F];
  209.         else *p++ = '=';
  210.  
  211.         *p++ = '=';
  212.          //printf("very last p: %X *p: %d\r\n",p,*p);
  213.     }
  214.  
  215.     *dlen = p - dst;
  216.     *p = 0;
  217.  
  218.     return( 0 );
  219. }
  220.  
  221. /*
  222.  * Decode a base64-formatted buffer
  223.  */
  224.  
  225. int base64_decode(unsigned char* dst, uint32_t *dlen, const unsigned char *src, uint32_t slen)
  226. {
  227.     uint32_t n;
  228.     uint32_t j;
  229.     int i;
  230.    
  231.     unsigned int reg_h,reg_l,tmp;
  232.     unsigned char *p;
  233.     unsigned char value;
  234.  
  235.    
  236.     for( i = j = n = 0; i < slen; i++ )
  237.     {
  238.         //NO_SYNTHESIS;
  239.         if( ( slen - i ) >= 2 &&
  240.             src[i] == '\r' && src[i + 1] == '\n' )
  241.             continue;
  242.  
  243.         if( src[i] == '\n' )
  244.             continue;
  245.  
  246.         if( src[i] == '=' && ++j > 2 ) {
  247.             //printf("\r\n err 1 i: %d",i);          
  248.             return( POLARSSL_ERR_BASE64_INVALID_CHARACTER );
  249.         }
  250.  
  251.         if( src[i] > 127 || base64_dec_map[src[i]] == 127 ) {
  252.             //printf("\r\n err 2 i: %d ",i);          
  253.             return( POLARSSL_ERR_BASE64_INVALID_CHARACTER );
  254.         }
  255.  
  256.         if( base64_dec_map[src[i]] < 64 && j != 0 ) {
  257.             //printf("\r\n err 3 i: %d",i);          
  258.             return( POLARSSL_ERR_BASE64_INVALID_CHARACTER );
  259.         }
  260.  
  261.         n++;
  262.     }
  263.  
  264.     if( n == 0 ) {
  265.         printf("\r\n No String found");
  266.         return( 0 );
  267.     }
  268.  
  269.     n = ((n * 6) + 7) >> 3;
  270.  
  271.     if( *dlen < n )
  272.     {
  273.         //printf("\r\n dlen: %d n: %d\r\n",*dlen, n);
  274.         *dlen = n;
  275.         return( POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL );
  276.     }
  277.     //printf("return chk\r\n");
  278.  
  279.  
  280.  
  281.    reg_l = 0;
  282.    reg_h = 0;
  283.    tmp = 0;
  284.    //printf("start decode...\r\n");
  285.    
  286.    p = dst;
  287.    j = 3;
  288.    n = 0;
  289.  
  290.    for(i = slen ; i > 0; i--, src++ )
  291.    {
  292.        //printf ("i: %d\n\r", i);
  293.         //NO_SYNTHESIS;      
  294.         if( *src == '\r' || *src == '\n' )
  295.             continue;
  296. //
  297. //        //printf("\r\ndecmap: %d %d\r\n",dec_map[81],dec_map[87]);
  298. //        //printf("\r\nadr decmap: %X\r\n",base64_dec_map);
  299. //
  300.     value = base64_dec_map[*src];
  301.     j -= ( value == 64 );
  302.        
  303.     reg_h = reg_h << 6;
  304.         tmp = reg_l >> 12;
  305.     reg_h = reg_h | tmp;
  306.     reg_l = (reg_l << 6) | ( value & 0x3F );
  307. //
  308. //        //printf("regh %X, regl %X, tmp ", reg_h, reg_l);
  309. //        //printf("%X value d'%d",tmp, value);
  310. //        printf(" src %X src* %d\r\n",src, *src);
  311. //
  312.         //n++;
  313.  
  314.         if( ++n == 4 )
  315.         {
  316.             n = 0;
  317.             if( j > 0 ) {
  318.         tmp = reg_l >> 16;
  319.         tmp = (reg_h << 2) | tmp;
  320.         value = tmp & 0xFF;
  321.                 //printf(">0 %X",value);
  322.    
  323.             *p++ = value;
  324.             }          
  325.         if( j > 1 ) {
  326.          value = (reg_l >> 8) & 0xFF;
  327.                 //printf(">1 %X",value);
  328.          
  329.          *p++ = value;
  330.         }
  331.             if( j > 2 ) {
  332.         value = reg_l & 0xFF;      
  333.                 //printf(">2 %X",value);
  334.    
  335.          *p++ = value;
  336.             }
  337.     }
  338.     }
  339.  
  340.     *dlen = p - dst;
  341.     printf("dst: %s\r\n",dst);
  342.     printf("p: %s\r\n",p);
  343.     return 0;
  344. }
  345.  
  346.  
  347.  
  348. /*
  349.  * main routine
  350.  */
  351. int main()
  352. {
  353.     stdio_uart_open(UART_LIGHT_0);
  354.         int err;
  355.         uint32_t len;
  356.         unsigned char *src;
  357.         unsigned char *ptr;
  358.         unsigned char buf[64];
  359.     TIMER_0->limit = 131072;    //2^17    = 0x20000
  360.     TIMER_1->limit = 262143;    //2^18 -1 = 0x3ffff  
  361.         TIMER_0->control |= TIMER_CNT_RST;
  362.     TIMER_0->control &= !TIMER_CNT_RST;
  363.     TIMER_1->control |= TIMER_CNT_RST;
  364.     TIMER_1->control &= !TIMER_CNT_RST;
  365.  
  366.  
  367.         printf("\r\n\n===  Base64 Encoding/Decoding Test ===\r\n");
  368.         int i;
  369.  
  370.     //len = sizeof( buffer );
  371.         src = (unsigned char *) base64_test_dec;
  372.     ptr = (unsigned char *) base64_test_dec;
  373.  
  374.     // HW execution
  375.     libacc_enable_accels();
  376.     printf("\r\nExample Original message:");
  377.     printf("\r\n---------------------------------------------------\r\n");
  378.     for(i=0;i<MSG_SIZE;i++) {
  379.         printf("%X ",ptr[i]);
  380.     }
  381.         printf("%s",ptr);
  382.     printf("\r\n---------------------------------------------------\r\n");
  383.     ptr = (unsigned char *) base64_test_enc;
  384.        
  385.     printf("\r\nExample Encoded message:");
  386.     printf("\r\n---------------------------------------------------\r\n");
  387.         printf("%s",ptr);
  388.     printf("\r\n---------------------------------------------------\r\n");
  389.  
  390.         // invalidate buffer
  391.     for (i=0;i<sizeof(buf);i++) {
  392.             NO_SYNTHESIS;
  393.         buf[i] = 0;
  394.     }
  395.     len = sizeof( buf );
  396.  
  397.     printf("\r\nHW encoding...");
  398.     // encode
  399.         TIMER_0->control |= TIMER_CNT_RST;
  400.     TIMER_0->control &= !TIMER_CNT_RST;
  401.     TIMER_1->control |= TIMER_CNT_RST;
  402.     TIMER_1->control &= !TIMER_CNT_RST;
  403.     TIMER_1->control = TIMER_EN;
  404.     TIMER_0->control = TIMER_EN;
  405.         //printf("buffer: %X *: %d\r\n",buf,*buf);
  406.     err = base64_encode(buf, &len, src, MSG_SIZE);
  407.         TIMER_0->control = 0;
  408.     TIMER_1->control = 0;
  409.     if(err) {
  410.             printf(" failed\r\n");
  411.     }
  412.         //ptr = (unsigned char *) buf;
  413.     printf("\r\nHW Encoded message:");
  414.     printf("\r\n---------------------------------------------------\r\n");
  415.         printf("%s",buf);
  416.     printf("\r\n---------------------------------------------------\r\n");
  417.    
  418.     //len = sizeof( buffer );
  419.     if(err) {
  420.             printf(" failed\r\n");
  421.     }
  422.  
  423.         len = sizeof(buf);
  424.         src = (unsigned char *) base64_test_enc;
  425.  
  426.     printf("\r\n\nHW decoding...");
  427.         // invalidate buffer
  428.     for (i=0;i<sizeof(buf);i++) {
  429.             NO_SYNTHESIS;
  430.         buf[i] = 0;
  431.     }
  432.     // decode
  433.     TIMER_1->control = TIMER_EN;
  434.     TIMER_0->control = TIMER_EN;
  435.         err = base64_decode(buf, &len, src, ENC_MSG_SIZE);
  436.         TIMER_0->control = 0;
  437.     TIMER_1->control = 0;
  438.     if(err) {
  439.         printf("failed: %d\r\n", err);
  440.     }
  441.         //ptr = (unsigned char *) buf;
  442.     printf("\r\nHW Decoded message:");
  443.     printf("\r\n---------------------------------------------------\r\n");
  444.         printf("%s",buf);
  445.     printf("\r\n---------------------------------------------------\r\n\n");
  446.  
  447.     printf("\r\n HW timer value: %6u",TIMER_0->value);
  448.     printf("\r\n HW overflows:   %6u\r\n\n",TIMER_1->value);
  449.     printf("\r\nHW ready\r\n");
  450.  
  451.    
  452.     //=========================================================================
  453.     // SW Execution
  454.        
  455.         // invalidate buffer
  456.     for (i=0;i<sizeof(buf);i++) {
  457.             NO_SYNTHESIS;
  458.         buf[i] = 0;
  459.     }
  460.         len = sizeof(buf);
  461.        
  462.         src = (unsigned char *) base64_test_dec;
  463.     ptr = (unsigned char *) base64_test_dec;
  464.    
  465.     printf("\r\nSW encoding...");
  466.     // encode
  467.         TIMER_0->control |= TIMER_CNT_RST;
  468.     TIMER_0->control &= !TIMER_CNT_RST;
  469.     TIMER_1->control |= TIMER_CNT_RST;
  470.     TIMER_1->control &= !TIMER_CNT_RST;
  471.     TIMER_1->control = TIMER_EN;
  472.     TIMER_0->control = TIMER_EN;
  473.     err = base64_encode(buf, &len, src, MSG_SIZE);
  474.         TIMER_0->control = 0;
  475.     TIMER_1->control = 0;
  476.     if(err) {
  477.             printf(" failed\r\n");
  478.     }
  479.         //ptr = (unsigned char *) buf;
  480.     printf("\r\nSW Encoded message:");
  481.     printf("\r\n---------------------------------------------------\r\n");
  482.         printf("%s",buf);
  483.     printf("\r\n---------------------------------------------------\r\n");
  484.        
  485.         len = sizeof( buf );
  486.         src = (unsigned char *) base64_test_enc;
  487.  
  488.     printf("\r\n\nSW decoding...");
  489.         len = sizeof(buf);
  490.         // invalidate buffer
  491.     for (i=0;i<sizeof(buf);i++) {
  492.             NO_SYNTHESIS;
  493.         buf[i] = 0;
  494.     }
  495.     // decode
  496.     TIMER_1->control = TIMER_EN;
  497.     TIMER_0->control = TIMER_EN;
  498.         //err = base64_decode_chk( &len, src, ENC_MSG_SIZE, base64_dec_map);
  499.         err = base64_decode(buf, &len, src, ENC_MSG_SIZE);
  500.         TIMER_0->control = 0;
  501.     TIMER_1->control = 0;
  502.     if(err) {
  503.         printf("failed: %d\r\n", err);
  504.     }
  505.         //ptr = (unsigned char *) buf;
  506.     printf("\r\nSW Decoded message:");
  507.     printf("\r\n---------------------------------------------------\r\n");
  508.         printf("%s",buf);
  509.     printf("\r\n---------------------------------------------------\r\n\n");
  510.  
  511.     printf("\r\nSW timer value: %6u",TIMER_0->value);
  512.     printf("\r\nSW overflows:   %6u\r\n\n",TIMER_1->value);
  513.     printf("\r\nSW ready\r\n");
  514.  
  515.  
  516.     while(1);
  517.         return  0;
  518. }
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!