diff --git a/display_stockach_i2c b/display_stockach_i2c
new file mode 100644
index 0000000..9c69718
--- /dev/null
+++ b/display_stockach_i2c
@@ -0,0 +1,10 @@
+maximilian@ironhero:~/ad9984a_bo$ sudo i2cdump -y -r 0-127 2 0x50 b
+     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f    0123456789abcdef
+00: 00 ff ff ff ff ff ff 00 1e 6d d5 59 04 45 09 00    ........?m?Y?E?.
+10: 03 17 01 03 68 35 1e 78 ea 33 31 a4 57 51 a0 26    ????h5?x?31?WQ?&
+20: 10 50 54 a7 6b 80 b3 00 81 80 95 00 71 4f a9 c0    ?PT?k??.???.qO??
+30: 81 00 81 c0 90 40 02 3a 80 18 71 38 2d 40 58 2c    ?.???@?:??q8-@X,
+40: 45 00 09 25 21 00 00 1e 00 00 00 fd 00 38 4b 1e    E.?%!..?...?.8K?
+50: 53 0f 00 0a 20 20 20 20 20 20 00 00 00 fc 00 32    S?.?      ...?.2
+60: 34 45 4e 33 33 0a 20 20 20 20 20 20 00 00 00 ff    4EN33?      ....
+70: 00 33 30 33 4e 44 51 41 48 56 34 39 32 0a 00 f1    .303NDQAHV492?.?
diff --git a/display_stockach_parsed b/display_stockach_parsed
new file mode 100644
index 0000000..e14fe73
--- /dev/null
+++ b/display_stockach_parsed
@@ -0,0 +1,69 @@
+maximilian@ironhero:~/ad9984a_bo$ sudo python2.7 parse_display_ddc.py 
+[sudo] password for maximilian: 
+Header:
+7789
+  Manufacturer: GSM
+  Product code: 22997
+  Serial number: 607492
+  Week: 3
+  Year: 2013
+  Edid version 1, revision 3
+  Analog input
+  Levels: +.7/0]
+  Separate sync supported
+  Horizontal screen size: 53cm
+  Vertical screen size: 30cm
+  Display gamma: 2.200
+  DPMS standby supported
+  DPMS suspend supported
+  DPMS active-off supported
+  Display type (analog): RGB color
+  Preferred timing mode in descriptor block 1
+Chromaticity coordinates:  r: (0.641, 0.343), g: (0.316, 0.628), b: (0.148, 0.065), w: (0.312, 0.329)
+Established timings:
+  720x400 @ 70 Hz (VGA)
+  640x480 @ 60 Hz (VGA)
+  640x480 @ 75 Hz
+  800x600 @ 56 Hz
+  800x600 @ 60 Hz
+  800x600 @ 75 Hz
+  832x624 @ 75 Hz (Apple Macintosh II)
+  1024x768 @ 60 Hz
+  1024x768 @ 75 Hz
+  1280x1024 @ 75 Hz
+  1152x870 @ 75 Hz (Apple Macintosh II)
+Standard timing information:
+  X res: 1680, aspect 16:10, Y res (derived): 1050), vertical frequency: 60
+  X res: 1280, aspect 5:4, Y res (derived): 1024), vertical frequency: 60
+  X res: 1440, aspect 16:10, Y res (derived): 900), vertical frequency: 60
+  X res: 1152, aspect 4:3, Y res (derived): 864), vertical frequency: 75
+  X res: 1600, aspect 16:9, Y res (derived): 900), vertical frequency: 60
+  X res: 1280, aspect 16:10, Y res (derived): 800), vertical frequency: 60
+  X res: 1280, aspect 16:9, Y res (derived): 720), vertical frequency: 60
+  X res: 1400, aspect 4:3, Y res (derived): 1050), vertical frequency: 60
+Descriptor 1: Detailed timing descriptor:
+  Pixel clock: 148500kHz
+  Horizontal active pixels: 1920
+  Horizontal blanking pixels: 280
+  Vertical active lines: 1080
+  Vertical blanking lines: 45
+  Horizontal front porch pixels: 88
+  Horizontal sync pulse pixels: 44
+  Vertical front porch lines: 4
+  Vertical sync pulse lines: 5
+  Horizontal image size: 521mm
+  Vertical image size: 293mm
+  Horizontal border pixels: 0
+  Vertical border lines: 0
+  Digital separate sync
+  VSync serration
+  Positive horizontal sync polarity
+Descriptor 2: Display range limits
+  Minimum vertical field rate 56Hz
+  Maximum vertical field rate 75Hz
+  Minimum horizontal field rate 30Hz
+  Maximum horizontal field rate 83Hz
+  Maximum pixel clock rate: 150Mhz
+  Default GTF
+Descriptor 3: Display name 24EN33
+Descriptor 4: Display serial number 303NDQAHV492
diff --git a/edid_stockach.json b/edid_stockach.json
index a4dee2b..df1343e 100644
--- a/edid_stockach.json
+++ b/edid_stockach.json
@@ -8,17 +8,19 @@
     "edid_version": 1,
     "edid_revision": 3
   },
-  "video_input_parameters": {
-    "input_type": "analog",
-    "levels": {
-      "upper": 0.7,
-      "lower": 0.0
+  "basic_display_parameters": {
+    "video_input_parameters": {
+      "input_type": "analog",
+      "levels": {
+        "upper": 0.7,
+        "lower": 0.0
+      },
+      "blank_to_black": false,
+      "seperate_sync": true,
+      "composite_sync": false,
+      "sync_on_green": false,
+      "vsync_serrated": false
     },
-    "blank_to_black": false,
-    "seperate_sync": true,
-    "composite_sync": false,
-    "sync_on_green": false,
-    "vsync_serrated": false,
     "horizontal_screen_size": 53,
     "vertical_screen_size": 30,
     "gamma": 2.2,
@@ -33,5 +35,15 @@
       "preferred_timing_mode": true,
       "continuous_timings": false
     }
+  },
+  "chromaticity_coordinates": {
+    "red_x": 0.641,
+    "red_y": 0.343,
+    "green_x": 0.316,
+    "green_y": 0.628,
+    "blue_x": 0.148,
+    "blue_y": 0.065,
+    "white_x": 0.3125,
+    "white_y": 0.329
   }
 }
diff --git a/main b/main
index 0eb9f1d..765140e 100755
Binary files a/main and b/main differ
diff --git a/main.c b/main.c
index 5fca178..1703eb1 100644
--- a/main.c
+++ b/main.c
@@ -69,16 +69,16 @@ typedef struct __attribute__ (( packed )) {
    *  blue, and white point, 10 bytes */
   struct __attribute__ (( packed )) {
     struct __attribute__ (( packed )) {
-      uint8_t red_x   : 2;
-      uint8_t red_y   : 2;
-      uint8_t green_x : 2;
       uint8_t green_y : 2;
+      uint8_t green_x : 2;
+      uint8_t red_y   : 2;
+      uint8_t red_x   : 2;
     } red_green_lsbs;
     struct __attribute__ (( packed )) {
-      uint8_t blue_x  : 2;
-      uint8_t blue_y  : 2;
-      uint8_t white_x : 2;
       uint8_t white_y : 2;
+      uint8_t white_x : 2;
+      uint8_t blue_y  : 2;
+      uint8_t blue_x  : 2;
     } blue_white_lsbs;
     uint8_t red_x_msbs;
     uint8_t red_y_msbs;
@@ -88,7 +88,7 @@ typedef struct __attribute__ (( packed )) {
     uint8_t blue_y_msbs;
     uint8_t white_x_msbs;
     uint8_t white_y_msbs;
-  } chromacity_cordinates;
+  } chromaticity_coordinates;
   /*! Established timing bitmap. Supported bitmap for (formerly) very common
       timing modes. 3 bytes */
   struct __attribute__ (( packed )) {
@@ -122,6 +122,11 @@ typedef struct __attribute__ (( packed )) {
   uint8_t checksum;
 } edid_t;
 
+static int stp_round(const float in)
+{
+  return (int)(in < 0 ? (in - 0.5) : (in + 0.5));
+}
+
 /**
  * @brief test function to show buffer
  */
@@ -162,13 +167,6 @@ static void generate_preamble(edid_t* edid)
   memset((uint8_t*)&(edid->header.preamble)+0, 0x00, 1);
   memset((uint8_t*)&(edid->header.preamble)+1, 0xFF, 6);
   memset((uint8_t*)&(edid->header.preamble)+7, 0x00, 1);
-/*memset( edid + EDID_BYTES_OFFSET_HEADER_PREAMBLE,
-          0x00, 1);
-  memset( edid + EDID_BYTES_OFFSET_HEADER_PREAMBLE + 1,
-          0xFF, 6);
-  memset( edid + EDID_BYTES_OFFSET_HEADER_PREAMBLE + 7,
-          0x00, 1);
-*/
 }
 
 static int generate_header(edid_t* edid, unsigned char* json_str, size_t json_len)
@@ -234,17 +232,21 @@ static int generate_basic_display_parameters( edid_t* edid,
 
   if (edid && json_str) {
     // Input type analog or digital
-    json_scanf( json_str, json_len, "{video_input_parameters: {input_type: %Q}",
+    json_scanf( json_str, json_len,
+                "{basic_display_parameters: {video_input_parameters: \
+                {input_type: %Q}}}",
                 &multi_use_str);
     if (strcmp(multi_use_str, "analog") == 0) {
       edid->basic_display_parameters.video_input_parameters
         .analog.input_type = 0;
       // Levels
       json_scanf( json_str, json_len,
-                  "{video_input_parameters: {levels: {upper: %f}}}",
+                  "{basic_display_parameters: {video_input_parameters: \
+                  {levels: {upper: %f}}}",
                   &multi_use_flt0);
       json_scanf( json_str, json_len,
-                  "{video_input_parameters: {levels: {lower: %f}}}",
+                  "{basic_display_parameters: {video_input_parameters: \
+                  {levels: {lower: %f}}}",
                   &multi_use_flt1);
       if (multi_use_flt0 == 0.7f && multi_use_flt1 == -0.3f) {
         multi_use_int = 0;
@@ -262,31 +264,35 @@ static int generate_basic_display_parameters( edid_t* edid,
         .analog.levels = 0x3 & multi_use_int;
       // Blank to black
       json_scanf( json_str, json_len,
-                  "{video_input_parameters: {blank_to_black: %B}}",
+                  "{basic_display_parameters: {video_input_parameters: \
+                  {blank_to_black: %B}}}",
                   &multi_use_bool);
       edid->basic_display_parameters.video_input_parameters
         .analog.blank_to_black = 0x1 & multi_use_bool;
       // Seperate sync
       json_scanf( json_str, json_len,
-                  "{video_input_parameters: {seperate_sync: %B}}",
+                  "{basic_display_parameters: {video_input_parameters: \
+                  {seperate_sync: %B}}}",
                   &multi_use_bool);
       edid->basic_display_parameters.video_input_parameters
         .analog.seperate_sync = 0x1 & multi_use_bool;
       // Composite sync
       json_scanf( json_str, json_len,
-                  "{video_input_parameters: {composite_sync: %B}}",
+                  "{basic_display_parameters: {video_input_parameters: \
+                  {composite_sync: %B}}}",
                   &multi_use_bool);
       edid->basic_display_parameters.video_input_parameters
         .analog.composite_sync = 0x1 & multi_use_bool;
       // Sync on green
       json_scanf( json_str, json_len,
-                  "{video_input_parameters: {sync_on_green: %B}}",
+                  "{basic_display_parameters: {video_input_parameters: \
+                  {sync_on_green: %B}}}",
                   &multi_use_bool);
       edid->basic_display_parameters.video_input_parameters
         .analog.sync_on_green = 0x1 & multi_use_bool;
       // Vsync serrated
       json_scanf( json_str, json_len,
-                  "{video_input_parameters: {blank_to_black: %B}}",
+                  "{video_input_parameters: {sync_on_green: %B}}",
                   &multi_use_bool);
       edid->basic_display_parameters.video_input_parameters
         .analog.blank_to_black = 0x1 & multi_use_bool;
@@ -302,40 +308,40 @@ static int generate_basic_display_parameters( edid_t* edid,
     free(multi_use_str);
     // Horizontal screen size
     json_scanf( json_str, json_len,
-                "{video_input_parameters: {horizontal_screen_size: %d}}",
+                "{basic_display_parameters: {horizontal_screen_size: %d}}",
                 &multi_use_int);
     edid->basic_display_parameters
       .horizontal_screen_size = multi_use_int;
     // Vertical screen size
     json_scanf( json_str, json_len,
-                "{video_input_parameters: {vertical_screen_size: %d}}",
+                "{basic_display_parameters: {vertical_screen_size: %d}}",
                 &multi_use_int);
     edid->basic_display_parameters
       .vertical_screen_size = multi_use_int;
     // Horizontal screen size
     json_scanf( json_str, json_len,
-                "{video_input_parameters: {gamma: %f}}",
+                "{basic_display_parameters: {gamma: %f}}",
                 &multi_use_flt0);
     edid->basic_display_parameters
       .gamma = (multi_use_flt0-1)*100;
     // Display Power Management Signaling (DPMS)
     // Standby
     json_scanf( json_str, json_len,
-                "{video_input_parameters: {features: {dpms: \
+                "{basic_display_parameters: {features: {dpms: \
                 {standby_supported: %B}}}}",
                 &multi_use_bool);
     edid->basic_display_parameters
       .features.dpms_standby_supported = 0x1 & multi_use_bool;
     // Suspend
     json_scanf( json_str, json_len,
-                "{video_input_parameters: {features: {dpms: \
+                "{basic_display_parameters: {features: {dpms: \
                 {suspend_supported: %B}}}}",
                 &multi_use_bool);
     edid->basic_display_parameters
       .features.dpms_suspend_supported = 0x1 & multi_use_bool;
     // Active-off
     json_scanf( json_str, json_len,
-                "{video_input_parameters: {features: {dpms: \
+                "{basic_display_parameters: {features: {dpms: \
                 {active_off_supported: %B}}}}",
                 &multi_use_bool);
     edid->basic_display_parameters
@@ -344,7 +350,7 @@ static int generate_basic_display_parameters( edid_t* edid,
     char a_str[] = "analog";
     char d_str[] = "digital";
     json_scanf( json_str, json_len,
-                "{video_input_parameters: {features: {display_type: %Q}}}",
+                "{basic_display_parameters: {features: {display_type: %Q}}}",
                 &multi_use_str);
     // Create substrings for comparison
     memcpy(a_str, multi_use_str, strlen(a_str));
@@ -380,19 +386,20 @@ static int generate_basic_display_parameters( edid_t* edid,
     free(multi_use_str);
     // Standard sRGB
     json_scanf( json_str, json_len,
-                "{video_input_parameters: {features: {standard_srgb: %B}}}",
+                "{basic_display_parameters: {features: {standard_srgb: %B}}}",
                 &multi_use_bool);
     edid->basic_display_parameters
       .features.standard_srgb = 0x1 & multi_use_bool;
     // Prefered timing mode
     json_scanf( json_str, json_len,
-                "{video_input_parameters: {features: {preferred_timing_mode: %B}}}",
+                "{basic_display_parameters: {features: \
+                {preferred_timing_mode: %B}}}",
                 &multi_use_bool);
     edid->basic_display_parameters
       .features.preferred_timing_mode = 0x1 & multi_use_bool;
     // Continuous timings
     json_scanf( json_str, json_len,
-                "{video_input_parameters: {features: {continuous_timings: %B}}}",
+                "{basic_display_parameters: {features: {continuous_timings: %B}}}",
                 &multi_use_bool);
     edid->basic_display_parameters
       .features.continuous_timings = 0x1 & multi_use_bool;
@@ -403,6 +410,79 @@ static int generate_basic_display_parameters( edid_t* edid,
   return 0;
 }
 
+static int generate_chromaticity_coordinates( edid_t* edid,
+                                              unsigned char* json_str,
+                                              size_t json_len)
+{
+  float multi_use_flt;
+  unsigned int multi_use_int;
+
+  if (edid && json_str) {
+    // Red x
+    json_scanf( json_str, json_len,
+                "{chromaticity_coordinates: {red_x:  %f}}",
+                &multi_use_flt);
+    multi_use_int = stp_round(1024.0f * multi_use_flt);
+    edid->chromaticity_coordinates.red_green_lsbs.red_x = 0x3 & multi_use_int;
+    edid->chromaticity_coordinates.red_x_msbs = 0xFF & multi_use_int >> 2;
+    // Red y
+    json_scanf( json_str, json_len,
+                "{chromaticity_coordinates: {red_y:  %f}}",
+                &multi_use_flt);
+    multi_use_int = stp_round(1024.0f * multi_use_flt);
+    edid->chromaticity_coordinates.red_green_lsbs.red_y = 0x3 & multi_use_int;
+    edid->chromaticity_coordinates.red_y_msbs = 0xFF & multi_use_int >> 2;
+    // Green x
+    json_scanf( json_str, json_len,
+                "{chromaticity_coordinates: {green_x:  %f}}",
+                &multi_use_flt);
+    multi_use_int = stp_round(1024.0f * multi_use_flt);
+    edid->chromaticity_coordinates.red_green_lsbs.green_x = 0x3 & multi_use_int;
+    edid->chromaticity_coordinates.green_x_msbs = 0xFF & multi_use_int >> 2;
+    // Green y
+    json_scanf( json_str, json_len,
+                "{chromaticity_coordinates: {green_y:  %f}}",
+                &multi_use_flt);
+    multi_use_int = stp_round(1024.0f * multi_use_flt);
+    edid->chromaticity_coordinates.red_green_lsbs.green_y = 0x3 & multi_use_int;
+    edid->chromaticity_coordinates.green_y_msbs = 0xFF & multi_use_int >> 2;
+    // Blue x
+    json_scanf( json_str, json_len,
+                "{chromaticity_coordinates: {blue_x:  %f}}",
+                &multi_use_flt);
+    multi_use_int = stp_round(1024.0f * multi_use_flt);
+    edid->chromaticity_coordinates.blue_white_lsbs.blue_x = 0x3 & multi_use_int;
+    edid->chromaticity_coordinates.blue_x_msbs = 0xFF & multi_use_int >> 2;
+    // Blue y
+    json_scanf( json_str, json_len,
+                "{chromaticity_coordinates: {blue_y:  %f}}",
+                &multi_use_flt);
+    multi_use_int = stp_round(1024.0f * multi_use_flt);
+    edid->chromaticity_coordinates.blue_white_lsbs.blue_y = 0x3 & multi_use_int;
+    edid->chromaticity_coordinates.blue_y_msbs = 0xFF & multi_use_int >> 2;
+    // White x
+    json_scanf( json_str, json_len,
+                "{chromaticity_coordinates: {white_x:  %f}}",
+                &multi_use_flt);
+    multi_use_int = stp_round(1024.0f * multi_use_flt);
+    printf("white_y>%f, %d\n", multi_use_flt, multi_use_int);
+    edid->chromaticity_coordinates.blue_white_lsbs.white_x = 0x3 & multi_use_int;
+    edid->chromaticity_coordinates.white_x_msbs = 0xFF & multi_use_int >> 2;
+    // White y
+    json_scanf( json_str, json_len,
+                "{chromaticity_coordinates: {white_y:  %f}}",
+                &multi_use_flt);
+    multi_use_int = stp_round(1024.0f * multi_use_flt);
+    printf("white_y>%f, %d\n", multi_use_flt, multi_use_int);
+    edid->chromaticity_coordinates.blue_white_lsbs.white_y = 0x3 & multi_use_int;
+    edid->chromaticity_coordinates.white_y_msbs = 0xFF & multi_use_int >> 2;
+  } else {
+    printf("Error: One of either edid or json_str is NULL.\n");
+    return 1;
+  }
+  return 0;
+}
+
 int main(void)
 {
   //uint8_t edith[EDID_LENGTH];
@@ -419,6 +499,7 @@ int main(void)
   }
   generate_header(&edith, mystr, len);
   generate_basic_display_parameters(&edith, mystr, len);
+  generate_chromaticity_coordinates(&edith, mystr, len);
   disp_buf((uint8_t*)&edith, EDID_LENGTH);
   return 0;
 }