Всем добра.
Помогите разобраться с кодом.
Подозрение на то что неверная ширина SYNC. 

Осциллограф видит RGB и Синхру, но синхра визуально как будто задом наперед и шиворот на вы ворот. 

https://forum.arduino.cc/t/arduino-uno-colour-ntsc-output-with-ad725-bad-colours-issue/612007

[code]
/*
Adapted by phizone from:

Arduino Tv framebuffer
Alastair Parker
2007

Modified for use on NTSC monitors and displays
2009
Michael Pilcher

*/

// Video out voltage levels
#define  _SYNC  B00000000
#define _BLACK  B00000010
#define _RED    B00000110
#define _GREEN  B00001010
#define _BLUE   B00010010
#define _YELLOW B00001110
#define _PINK   B00010110
#define _CYAN   B00011010
#define _WHITE  B00011110

// dimensions of the screen
#define WIDTH 35  // sets # of columns 0-34. Column 34 is oversized on some displays
#define HEIGHT 15  // sets # of rows 0-14. row 0 wrapped around to the bottom

//number of lines to display
#define DISPLAY_LINES 255

//video pins
#define BLUE_PIN 12
#define GREEN_PIN 11
#define RED_PIN 10
#define SYNC_PIN 9

// the video frameBuffer
byte frameBuffer[WIDTH][HEIGHT];

// loop indices
byte index, index2;

// video line loop
byte line;
// current drawing line in framebuffer
byte newLine;


void setREDPixel(byte x,byte y)
{
 frameBuffer[x][y]= _RED;
}

void setGREENPixel(byte x,byte y)
{
 frameBuffer[x][y]= _GREEN;
}

void setBLUEPixel(byte x,byte y)
{
 frameBuffer[x][y]= _BLUE;
}

void setYELLOWPixel(byte x,byte y)
{
 frameBuffer[x][y]= _YELLOW;
}

void setPINKPixel(byte x,byte y)
{
 frameBuffer[x][y]= _PINK;
}

void setCYANPixel(byte x,byte y)
{
 frameBuffer[x][y]= _CYAN;
}




void setPixel(byte x,byte y)
{
 frameBuffer[x][y]= _WHITE;
}



// draw a black pixel to the buffer
void clearPixel(byte x,byte y)
{
 frameBuffer[x][y]= _BLACK;
}


//draw BANDS TEST PATTERNS
void drawScreen()
{
  
   for (int x=0; x <= 34; x++){
     for (int y=0; y <= 14; y++){
        if ((x>=0) && (x<=4)) frameBuffer[x][y]= _WHITE;
        if ((x>=5) && (x<=8)) frameBuffer[x][y]= _YELLOW;
        if ((x>=9) && (x<=12)) frameBuffer[x][y]= _CYAN;
        if ((x>=13) && (x<=16)) frameBuffer[x][y]= _GREEN;
        if ((x>=17) && (x<=20)) frameBuffer[x][y]= _PINK;
        if ((x>=21) && (x<=24)) frameBuffer[x][y]= _RED;
        if ((x>=25) && (x<=28)) frameBuffer[x][y]= _BLUE;
        if ((x>=29) && (x<=32)) frameBuffer[x][y]= _BLACK;
     } 
   } 


}


/*

//draw RANDOM PIXELS
void drawScreen()
{
  
   for (int x=0; x <= 34; x++){
     for (int y=0; y <= 14; y++){
       byte ran = random(8);
       
        if (ran==0) frameBuffer[x][y]= _WHITE;
        if (ran==1) frameBuffer[x][y]= _YELLOW;
        if (ran==2) frameBuffer[x][y]= _CYAN;
        if (ran==3) frameBuffer[x][y]= _GREEN;
        if (ran==4) frameBuffer[x][y]= _PINK;
        if (ran==5) frameBuffer[x][y]= _RED;
        if (ran==6) frameBuffer[x][y]= _BLUE;
        if (ran==7) frameBuffer[x][y]= _BLACK;
     } 
   } 


}

*/

/*

//draw CHESSBOARD
void drawScreen()
{
 // possible unusable column. may appear too wide on some displays
 setPixel(34,0);
 setPixel(34,1);
 setPixel(34,2);
 setPixel(34,3);
 setPixel(34,4);
 setPixel(34,5);
 setPixel(34,6);  
 setPixel(34,7);
 setPixel(34,8);
 setPixel(34,9);
 setPixel(34,10);
 setPixel(34,11);
 setPixel(34,12);
 setPixel(34,13);
 setPixel(34,14);
 
 // row 0, this row displays at the bottom of the screen not the top
 setPixel(1,0);
 setPixel(2,0);
 setPixel(3,0);
 setPixel(4,0);
 setPixel(5,0);
 setPixel(6,0);
 setPixel(7,0);
 setPixel(8,0);
 setPixel(9,0);
 setPixel(10,0);
 setPixel(11,0);
 setPixel(12,0);
 setPixel(13,0);
 setPixel(14,0);
 setPixel(15,0);
 setPixel(16,0);
 setPixel(17,0);
 setPixel(18,0);
 setPixel(19,0);
 setPixel(20,0);
 setPixel(21,0);
 setPixel(22,0);
 setPixel(23,0);
 setPixel(24,0);
 setPixel(25,0);
 setPixel(26,0);
 setPixel(27,0);
 setPixel(28,0);
 setPixel(29,0);
 setPixel(30,0);
 setPixel(31,0);
 setPixel(32,0);
 setPixel(33,0);
 
 // checked test pattern, CHANGE THESE TO BUILD YOUR IMAGE
 setPixel(0,2);
 setPixel(0,4);
 setPixel(0,6);  
 setPixel(0,8);
 setPixel(0,10);
 setPixel(0,12);
 setPixel(0,14);
 setPixel(1,1);
 setPixel(1,3);
 setPixel(1,5);
 setPixel(1,7);
 setPixel(1,9);
 setPixel(1,11);
 setPixel(1,13);
 setPixel(2,2);
 setPixel(2,4);
 setPixel(2,6);
 setPixel(2,8);
 setPixel(2,10);
 setPixel(2,12);
 setPixel(2,14);
 setPixel(3,1);
 setPixel(3,3);
 setPixel(3,5);
 setPixel(3,7);
 setPixel(3,9);
 setPixel(3,11);
 setPixel(3,13);
 setPixel(4,2);
 setPixel(4,4);
 setPixel(4,6);
 setPixel(4,8);
 setPixel(4,10);
 setPixel(4,12);
 setPixel(4,14);
 setPixel(5,1);
 setPixel(5,3);
 setPixel(5,5);
 setPixel(5,7);
 setPixel(5,9);
 setPixel(5,11);
 setPixel(5,13);
 setPixel(6,2);
 setPixel(6,4);
 setPixel(6,6);
 setPixel(6,8);
 setPixel(6,10);
 setPixel(6,12);
 setPixel(6,14);
 setPixel(7,1);
 setPixel(7,3);
 setPixel(7,5);
 setPixel(7,7);
 setPixel(7,9);
 setPixel(7,11);
 setPixel(7,13);
 setPixel(8,2);
 setPixel(8,4);
 setPixel(8,6);
 setPixel(8,8);
 setPixel(8,10);
 setPixel(8,12);
 setPixel(8,14);
 setPixel(9,1);
 setPixel(9,3);
 setPixel(9,5);
 setPixel(9,7);
 setPixel(9,9);
 setPixel(9,11);
 setPixel(9,13);
 setPixel(10,2);
 setPixel(10,4);
 setPixel(10,6);
 setPixel(10,8);
 setPixel(10,10);
 setPixel(10,12);
 setPixel(10,14);
 setPixel(11,1);
 setPixel(11,3);
 setPixel(11,5);
 setPixel(11,7);
 setPixel(11,9);
 setPixel(11,11);
 setPixel(11,13);
 setPixel(12,2);
 setPixel(12,4);
 setPixel(12,6);
 setPixel(12,8);
 setPixel(12,10);
 setPixel(12,12);
 setPixel(12,14);
 setPixel(13,1);
 setPixel(13,3);
 setPixel(13,5);
 setPixel(13,7);
 setPixel(13,9);
 setPixel(13,11);
 setPixel(13,13);
 setPixel(14,2);
 setPixel(14,4);
 setPixel(14,6);
 setPixel(14,8);
 setPixel(14,10);
 setPixel(14,12);
 setPixel(14,14);
 setPixel(15,1);
 setPixel(15,3);
 setPixel(15,7);
 setPixel(15,5);
 setPixel(15,9);
 setPixel(15,11);
 setPixel(15,13);
 setPixel(16,2);
 setPixel(16,4);
 setPixel(16,6);
 setPixel(16,8);
 setPixel(16,10);
 setPixel(16,12);
 setPixel(16,14);
 setPixel(17,1);
 setPixel(17,3);
 setPixel(17,5);
 setPixel(17,7);
 setPixel(17,9);
 setPixel(17,11);
 setPixel(17,13);
 setPixel(18,2);
 setPixel(18,4);
 setPixel(18,6);
 setPixel(18,8);
 setPixel(18,10);
 setPixel(18,12);
 setPixel(18,14);
 setPixel(19,1);
 setPixel(19,3);
 setPixel(19,5);
 setPixel(19,7);
 setPixel(19,9);
 setPixel(19,11);
 setPixel(19,13);
 setPixel(20,2);
 setPixel(20,4);
 setPixel(20,6);
 setPixel(20,8);
 setPixel(20,10);
 setPixel(20,12);
 setPixel(20,14);
 setPixel(21,1);
 setPixel(21,3);
 setPixel(21,5);
 setPixel(21,7);
 setPixel(21,9);
 setPixel(21,11);
 setPixel(21,13);
 setPixel(22,2);
 setPixel(22,4);
 setPixel(22,6);
 setPixel(22,8);
 setPixel(22,10);
 setPixel(22,12);
 setPixel(22,14);
 setPixel(23,1);
 setPixel(23,3);
 setPixel(23,5);
 setPixel(23,7);
 setPixel(23,9);
 setPixel(23,11);
 setPixel(23,13);
 setPixel(24,2);
 setPixel(24,4);
 setPixel(24,6);
 setPixel(24,8);
 setPixel(24,10);
 setPixel(24,12);
 setPixel(24,14);
 setPixel(25,1);
 setPixel(25,3);
 setPixel(25,5);
 setPixel(25,7);
 setPixel(25,9);
 setPixel(25,11);
 setPixel(25,13);
 setPixel(26,2);
 setPixel(26,4);
 setPixel(26,6);
 setPixel(26,8);
 setPixel(26,10);
 setPixel(26,12);
 setPixel(26,14);
 setPixel(27,1);
 setPixel(27,3);
 setPixel(27,5);
 setPixel(27,7);
 setPixel(27,9);
 setPixel(27,11);
 setPixel(27,13);
 setPixel(28,2);
 setPixel(28,4);
 setPixel(28,6);
 setPixel(28,8);
 setPixel(28,10);
 setPixel(28,12);
 setPixel(28,14);
 setPixel(29,1);
 setPixel(29,3);
 setPixel(29,5);
 setPixel(29,7);
 setPixel(29,9);
 setPixel(29,11);
 setPixel(29,13);
 setPixel(30,2);
 setPixel(30,4);
 setPixel(30,6);
 setPixel(30,8);
 setPixel(30,10);
 setPixel(30,12);
 setPixel(30,14);
 setPixel(31,1);
 setPixel(31,3);
 setPixel(31,5);
 setPixel(31,7);
 setPixel(31,9);
 setPixel(31,11);
 setPixel(31,13);
 setPixel(32,2);
 setPixel(32,4);
 setPixel(32,6);
 setPixel(32,8);
 setPixel(32,10);
 setPixel(32,12);
 setPixel(32,14);
 setPixel(33,1);
 setPixel(33,3);
 setPixel(33,5);
 setPixel(33,7);
 setPixel(33,9);
 setPixel(33,11);
 setPixel(33,13);
 
 
}
*/

// clear the screen
void clearScreen()
{
 for (index = 0; index < WIDTH; index++)
   for (index2 = 0; index2< HEIGHT; index2++)
 {
     frameBuffer[index][index2] = _BLACK;
 }
/*clears stray pixel at (34,0) that doesn't get cleared
   by the above for() loops. If the loop that reads
   for (index = 0; index < WIDTH; index++)
   reads
   for (index = 0; index <= WIDTH; index++)
   the timing is thrown off and the image gets scrambled
 */
 frameBuffer[35][0] = _BLACK;
}

// the setup routine
void setup()
{
cli();
pinMode (SYNC_PIN, OUTPUT);
pinMode (RED_PIN, OUTPUT);
pinMode (GREEN_PIN, OUTPUT);
pinMode (BLUE_PIN, OUTPUT);
digitalWrite (SYNC_PIN, HIGH);
digitalWrite (RED_PIN, HIGH);
digitalWrite (GREEN_PIN, HIGH);
digitalWrite (BLUE_PIN, HIGH);
clearScreen();
drawScreen();
}

void loop()
{
 // iterate over the lines on the tv
 for ( line =0;line< DISPLAY_LINES;++line)
 {

   // HSync
   // front porch (1.5 us)
   PORTB = _BLACK;
   delayMicroseconds(1.5);
   //sync (4.7 us)
   PORTB = _SYNC;
   delayMicroseconds(4.7);
   // breezeway (.6us) + burst (2.5us) + colour back borch (1.6 us)
   PORTB = _BLACK;
   delayMicroseconds(4.7);

   //calculate which line to draw to
   newLine = line >>4;
   delayMicroseconds(1);

   //display the array for this line
   // a loop would have been smaller, but it messes the timing up
   PORTB = frameBuffer[0][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[1][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[2][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[3][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[4][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[5][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[6][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[7][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[8][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[9][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[10][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[11][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[12][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[13][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[14][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[15][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[16][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[17][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[18][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[19][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[20][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[21][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[22][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[23][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[24][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[25][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[26][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[27][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[28][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[29][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[30][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[31][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[32][newLine];
   delayMicroseconds(1);
   PORTB = frameBuffer[33][newLine];
    delayMicroseconds(1);
   PORTB = frameBuffer[34][newLine];
   delayMicroseconds(1);
   // klugdge to correct timings

   PORTB = PORTB;
   delayMicroseconds(1);
   PORTB = PORTB;

   delayMicroseconds(1);
   PORTB = PORTB;
   PORTB = PORTB;
   PORTB = PORTB;
   delayMicroseconds(1);

 }

//vsync
PORTB = _SYNC;

// wait for the remainder of the sync period

delayMicroseconds(125);

}

[/code]