├── Makefile
├── README.md
├── find_scramblers.c
└── scramble.c


/Makefile:
--------------------------------------------------------------------------------
1 | all : scramble find_scramblers
2 | 
3 | find_scramblers : find_scramblers.c
4 | 	gcc -o find_scramblers find_scramblers.c -Wall -pedantic -O4
5 | 
6 | scramble : scramble.c
7 | 	gcc -o scramble scramble.c -Wall -pedantic -O4
8 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # lfsr_scramblers
 2 | Experiments with self-synchronizing LFSR scramblers.
 3 | 
 4 | Scramblers are useful to convert a a somewhat predictable sequence
 5 | of bits into what look like random bits, with approximately even 
 6 | numbers of '1's and '0's (so minimal DC bias).
 7 | 
 8 | This allows them to be easily transmitted and recoverd (e.g. over radio or optics)
 9 | 
10 | The structure of the LFSR scrambler is such that it self-synchronizes between
11 | encoder and decoder, and that RX errors will quickly clear from the receiver.
12 | 
13 | ## The two programs
14 | 
15 | find_scramblers.c : Search for 1-tap maximal LFSRs (repeat period is 2^n-1)
16 | 
17 | scramble.c : Show a scrambler in action or can be used to gnerate test vectors
18 | 


--------------------------------------------------------------------------------
/find_scramblers.c:
--------------------------------------------------------------------------------
 1 | /********************************************************************
 2 |  * find_scramblers.c : Find maximal LFSR shift registers with 1 tap
 3 |  *
 4 |  * (c) 2020 Mike Field <hamster@snap.net.nz>
 5 |  *
 6 |  *******************************************************************/
 7 | #include <stdio.h>
 8 | #include <stdint.h>
 9 | #include <stdlib.h>
10 | #include <memory.h>
11 | #include <assert.h>
12 | 
13 | uint32_t state = 1;
14 | uint8_t seen[64*1024*1024];
15 | 
16 | uint8_t doit(int len, int tap1) {
17 |    uint8_t out = ((state>>(len-1)) ^ (state>>(len-tap1))) & 1;
18 |    state = (state <<1) | out;
19 |    state &= (1<<len)-1;
20 |    return out;
21 | }
22 | 
23 | int test(int len, int tap1) {
24 |    int cycle=0;
25 | 
26 |    assert(1<<(len-3) <= sizeof(seen));
27 |    memset(seen,0, 1<<(len-3));
28 |    state = 1;
29 |    for(int j = 0; (seen[state/8] & (1<<(state&7)))==0; ++j, ++cycle) {
30 |       seen[state/8] |= 1<<(state&7);
31 |       doit(len, tap1);
32 |    }
33 |    return (cycle == (1<<len)-1);
34 | }
35 | 
36 | int main(int argc, char *argv[]) {
37 |    for(int len = 3; len < 30; ++len) {
38 |       for(int tap = 0; tap < len; ++tap) {
39 |          if(test(len,tap)) { 
40 |             printf("Len %i tap %i: GOOD\n", len, tap);
41 | //         } else {
42 |  //           printf("Len %i tap %i: bad\n", len, tap);
43 |          }
44 |       }
45 |    }
46 | }
47 | 


--------------------------------------------------------------------------------
/scramble.c:
--------------------------------------------------------------------------------
 1 | /********************************************************************
 2 |  * scramble.c : Investigate LFSR based scramblers
 3 |  *
 4 |  * (c) 2020 Mike Field <hamster@snap.net.nz>
 5 |  *
 6 |  *******************************************************************/
 7 | #include <stdio.h>
 8 | #include <stdint.h>
 9 | #include <stdlib.h>
10 | #include <memory.h>
11 | 
12 | uint32_t state_s = 0xAAAAAAAA;
13 | uint32_t state_u = 0xFFFFFFF1;
14 | 
15 | 
16 | static uint8_t scramble(int len, int tap, uint8_t d) {
17 |    uint8_t out = ((state_s>>(len-1)) ^ (state_s>>(len-tap))) & 1;
18 |    out ^= d;
19 |    state_s = (state_s <<1) | out;
20 |    state_s &= (1<<len)-1;
21 |    return out;
22 | }
23 | 
24 | static uint8_t unscramble(int len, int tap, uint8_t d) {
25 |    uint8_t q = ((state_u>>(len-1)) ^ (state_u>>(len-tap))) & 1;
26 |    uint8_t out;
27 |    out = q ^ d;
28 |    state_u = (state_u <<1) | d;
29 |    state_u &= (1<<len)-1;
30 |    return out;
31 | }
32 | 
33 | int main(int argc, char *argv[]) {
34 |    uint64_t data = 0xFFFFFFFFFFFE487FL;
35 |    int w=0;
36 |    char d_str[80];
37 |    char s_str[80];
38 |    char u_str[80];
39 | 
40 |    int length = 15;
41 |    int tap = 2;
42 | 
43 |    for(int len = 3; len < 1000; ++len) {
44 |       uint8_t d, s, u;
45 |       d = data&1;
46 |       s = scramble(length, tap, d);
47 |       u = unscramble(length, tap, s);
48 |       data = (data>>1) | (data<<63);
49 | 
50 |       d_str[w] = d ? '1' : '0';
51 |       s_str[w] = s ? '1' : '0';
52 |       u_str[w] = u ? '1' : '0';
53 |       w++;
54 |       if(w == 70) {
55 | 	 d_str[w] = 0;
56 | 	 s_str[w] = 0;
57 | 	 u_str[w] = 0;
58 |          printf("Data        : %s\n",d_str); 
59 |          printf("Scrambled   : %s\n",s_str); 
60 |          printf("Unscrambled : %s\n",u_str); 
61 | 	 printf("\n");
62 | 	 w = 0;
63 |       }
64 |    }
65 |    if(w != 0) {
66 |       d_str[w] = 0;
67 |       s_str[w] = 0;
68 |       u_str[w] = 0;
69 |       printf("Data        : %s\n",d_str); 
70 |       printf("Scrambled   : %s\n",s_str); 
71 |       printf("Unscrambled : %s\n",u_str); 
72 |       printf("\n");
73 |       w = 0;
74 |    }
75 | }
76 | 


--------------------------------------------------------------------------------