Ecrã#
Introdução#
A classe screen é derivada da classe base brain. Controla a forma como o V5 Brain mostra texto, números e gráficos no seu ecrã táctil e como responde à entrada de toque.
Por defeito, o tipo de letra para impressão no Brain é monospaced small, que tem 12 linhas e 48 colunas.
Para desenho, a resolução do cérebro é de 480 x 240 pixéis.

Acesso#
The screen class can be accessed by:
Brain.Screen
Notas#
O objeto
screené fornecido pelo Cérebro. Não é construído diretamente.Os projetos utilizam um único objeto global
Brain, pelo que as funções de ecrã são chamadas utilizandoBrain.Screen.
Exemplo#
/* This constructor is required when using VS Code.
A Brain is generated automatically at the start of
VEXcode projects. */
// Create the V5 Brain
brain Brain = brain();
// Print text to the Brain screen
Brain.Screen.print("Hello!");
Funções de membro#
A classe screen inclui as seguintes funções membro:
print— Imprime texto formatado, números ou valores booleanos no ecrã do Brain.setCursor— Move o cursor de texto para uma linha e coluna especificadas.newLine— Limpa o resto da linha actual e move o cursor para a linha seguinte.clearLine— Limpa o resto da linha actual ou limpa uma linha especificada.row— Devolve a linha onde o texto será impresso.column— Retorna a coluna onde o texto será impresso.getStringHeight— Retorna a altura de uma string em pixéis utilizando a fonte actual.getStringWidth— Retorna a largura de uma string em pixéis utilizando a fonte actual.printAt— Imprime texto formatado numa localização de pixel x, y.clearScreen— Limpa todos os desenhos e textos do ecrã do Brain.setFont— Define o tipo de letra utilizado para impressão no ecrã.setPenWidth— Define a espessura das linhas desenhadas e dos contornos das formas.setPenColor— Define a cor do texto, os pixéis, as linhas e os contornos das formas.setFillColor— Define a cor de preenchimento para as formas desenhadas e para os fundos de texto impressos.setOrigin— Define a origem utilizada para as coordenadas do ecrã.setClipRegion— Restringe a saída do ecrã a uma região rectangular.drawPixel— Desenha um pixel numa coordenada.drawLine— Desenha uma linha entre dois pontos.drawRectangle— Desenha um rectângulo numa localização x, y com um tamanho especificado.drawCircle— Desenha um círculo numa localização x, y com um raio especificado.drawImageFromFile— Desenha uma imagem de um ficheiro de cartão SD no ecrã.render— Activa o buffer duplo ou renderiza o buffer traseiro no ecrã.pressing— Retorna se o ecrã está a ser pressionado no momento.xPosition— Retorna a coordenada x da pressão do ecrã mais recente.yPosition— Retorna a coordenada y da pressão do ecrã mais recente.pressed— Regista uma função de chamada de retorno a ser executada quando o ecrã é premida.released— Regista uma função de retorno de chamada para ser executada quando o ecrã for libertado após ser pressionado.
Antes de chamar qualquer função membro de screen , deve ser criada uma instância brain , como se mostra abaixo:
// Create the V5 Brain
brain Brain = brain();
print#
Apresenta texto, números ou valores booleanos no ecrã do V5 Brain.
Available Functions1 — Imprime texto formatado utilizando literais de cadeias ou cadeias de leitura de leitura apenas, no estilo C.
void print( const char* format, ... );
Parameters2 — Imprime texto formatado utilizando matrizes de caracteres modificáveis.
void print( char* format, ... );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
Uma string de formato fornecida como uma string literal ou string de leitura apenas no estilo C (por exemplo, |
|
|
Uma string de formatação fornecida como uma matriz de caracteres modificável. |
|
Um ou mais valores adicionais que são introduzidos na string de formato, separados por vírgulas. |
Esta função não devolve qualquer valor.
NotesA saída começa na posição actual do cursor (posição no ecrã.
O texto impresso utiliza a fonte do ecrã atual.
O texto impresso utiliza a cor de caneta atual cor.
O texto impresso com
printé sempre impresso com um fundo, e a cor do fundo é determinada pela cor de preenchimento actual .Quando se utiliza uma string de formato, o número e os tipos de valores passados devem corresponder aos especificadores de formato na string.
// Display a message at the starting cursor
Brain.Screen.print("Hello, Robot!");

setCursor#
Move o cursor para uma linha e coluna específicas no ecrã do V5 Brain. A próxima chamada print começará a imprimir nesse local.
void setCursor(
int32_t row,
int32_t col );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
A linha para a qual mover o cursor. |
|
|
A coluna para a qual deve mover o cursor. |
Esta função não devolve qualquer valor.
NotesAfeta onde a saída de texto subsequente começa quando se utiliza
print.As linhas e colunas baseiam-se na fonte de ecrã definida atualmente.
A fonte padrão (
mono20) utiliza 12 linhas e 48 colunas.A chamada de `
setCursor) apenas afecta a posição da saída de texto subsequente.
// Display text starting at Row 3 Column 12
Brain.Screen.setCursor(3, 12);
Brain.Screen.print("Row 3, Column 12");

newLine#
Move o cursor para o início da linha seguinte no ecrã do Brain.
Available Functionsvoid newLine();
Esta função não aceita qualquer parâmetro.
Return ValuesEsta função não devolve qualquer valor.
NotesSe o cursor estiver no meio de uma frase,
newLinelimpará o resto da linha após o cursor antes de passar para a linha seguinte.Após a chamada
newLine, o cursor é posicionado na primeira coluna da linha seguinte.A posição do cursor e a numeração das linhas são definidas através de
setCursor.
// Display two lines of text
Brain.Screen.print("Line 1");
Brain.Screen.newLine();
Brain.Screen.print("Line 2");

clearLine#
Limpa o texto de uma linha no ecrã do V5 Brain.
Available Functions1 — Limpa o resto da linha actual a partir da posição do cursor.
void clearLine();
2 — Limpa a linha especificada utilizando a cor de preenchimento actualmente configurada.
void clearLine( int number );
3 — Limpa a linha especificada utilizando um objeto de cor predefinido ou personalizado.
void clearLine( int number, const color& color );
4 — Limpa a linha especificada utilizando um valor de cor hexadecimal.
void clearLine( int number, const char* color );
Parameters5 — Limpa a linha especificada utilizando um valor de matiz.
void clearLine( int number, int hue );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
Número da linha a limpar. A numeração das linhas começa em |
|
|
Limpa a linha utilizando um objeto de cor
|
|
|
Limpa a linha utilizando um valor de cor hexadecimal (por exemplo, |
|
|
Limpa a linha utilizando um valor inteiro de matiz no intervalo de |
Esta função não devolve qualquer valor.
NotesApagar uma linha não altera a posição atual do cursor.
A posição do cursor e a numeração das linhas são definidas através de
setCursor.O valor do parâmetro de matiz
huebaseia-se num círculo cromático circular, como se mostra abaixo, em que os valores representam graus em torno do círculo (por exemplo, vermelho próximo de 0°, verde próximo de 120° e azul próximo de 240°).

// Display text on two rows
Brain.Screen.print("This text stays");
Brain.Screen.newLine();
Brain.Screen.print("This disappears");
// Wait 3 seconds before clearing row 2
wait(3, seconds);
Brain.Screen.clearLine(2);
row#
Retorna a linha onde o texto será impresso no ecrã do V5 Brain.
Available Functionsint32_t row();
Esta função não aceita qualquer parâmetro.
Return ValuesRetorna um valor int32_t que representa a linha onde o texto será impresso.
A numeração das linhas começa em 1.
NotesO valor devolvido indica onde aparecerá a próxima saída impressa.
O valor da linha muda quando o texto é impresso ou quando
setCursoré chamado.
// Display the cursor's current row
Brain.Screen.setCursor(3, 12);
Brain.Screen.print(Brain.Screen.row());

column#
Retorna a coluna onde o texto será impresso no ecrã do V5 Brain.
Available Functionsint32_t column();
Esta função não aceita qualquer parâmetro.
Return ValuesRetorna um valor int32_t que representa a coluna onde o texto será impresso.
A numeração das colunas começa em 1.
NotesO valor devolvido indica onde aparecerá a próxima saída impressa.
O valor da coluna altera-se quando o texto é impresso ou quando é chamado
setCursor.
// Display the cursor's current column
Brain.Screen.setCursor(5, 15);
Brain.Screen.print(Brain.Screen.column());

getStringHeight#
Devolve a altura, em pixéis, de uma string quando renderizada no ecrã do V5 Brain.
Available Functionsint32_t getStringHeight(
const char* cstr );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
O texto a medir, fornecido como uma string ao estilo C (por exemplo, |
Retorna um valor int32_t que representa a altura da string em pixéis quando renderizada no ecrã do Brain.
A altura devolvida depende da de ecrã atualmente selecionada.
Esta função mede a string sem a desenhar no ecrã.
A altura devolvida reflete como a string apareceria quando impressa.
getStringWidth#
Retorna a largura, em pixéis, de uma string quando renderizada no ecrã do V5 Brain.
Available Functionsint32_t getStringWidth(
const char* cstr );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
O texto a medir, fornecido como uma string ao estilo C (por exemplo, |
Retorna um valor int32_t que representa a largura da string em pixéis quando renderizada no ecrã do Brain.
A largura devolvida depende da de ecrã atualmente selecionada.
Esta função mede a string sem a desenhar no ecrã.
A largura devolvida reflete a forma como a string aparecerá quando impressa.
printAt#
Imprime texto, números ou valores booleanos numa coordenada específica no ecrã do V5 Brain.
Available Functions1 — Imprime a saída formatada na localização de pixel especificada.
void printAt( int32_t x, int32_t y, const char* format, ... );
Parameters2 — Imprime a saída formatada na localização de pixel especificada e define se o fundo do texto é opaco ou transparente.
void printAt( int32_t x, int32_t y, bool bOpaque, const char* format, ... );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
A posição x para impressão, referenciada à origem do ecrã. |
|
|
A posição y para impressão, em relação à origem do ecrã. |
|
|
Controla se o texto impresso é desenhado de forma opaca ou transparente:
|
|
|
Uma string de formatação que controla o que é impresso no ecrã (por exemplo, |
|
Um ou mais valores adicionais que são introduzidos na string de formato, separados por vírgulas. |
Esta função não devolve qualquer valor.
NotesAs coordenadas
xeysão relativas à origem do ecrã actual, que pode ser alterada através desetOrigin.O texto impresso utiliza a fonte do ecrã atual.
O texto impresso utiliza a cor de caneta atual cor.
Quando se utiliza uma string de formato, o número e os tipos de valores passados devem corresponder aos especificadores de formato na string.
// Print "Center" at the center of the screen
Brain.Screen.printAt(220, 120, "Center");

clearScreen#
Apaga todos os desenhos e textos do ecrã do Cérebro e reinicia a posição do cursor para a linha 1, coluna 1.
Available Functions1 — Limpa o ecrã, deixando-o preto.
void clearScreen();
2 — Limpa o ecrã utilizando um objeto de cor predefinido ou personalizado.
void clearScreen( const color& color );
3 — Limpa o ecrã utilizando um valor de cor hexadecimal.
void clearScreen( const char* color );
Parameters4 — Limpa o ecrã utilizando um valor de matiz.
void clearScreen( int hue );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
Limpa o ecrã utilizando um objeto de cor
|
|
|
Limpa o ecrã utilizando um valor de cor hexadecimal representado como uma string (por exemplo, |
|
|
Limpa o ecrã utilizando um valor inteiro de matiz no intervalo de |
Esta função não devolve qualquer valor.
NotesO valor do parâmetro de matiz
huebaseia-se num círculo cromático circular, como se mostra abaixo, em que os valores representam graus em torno do círculo (por exemplo, vermelho próximo de 0°, verde próximo de 120° e azul próximo de 240°).

// Clear screen after 2 seconds
Brain.Screen.print("VEXcode");
wait(2, seconds);
Brain.Screen.clearScreen();
// Clear screen to blue after 2 seconds
Brain.Screen.print("VEXcode");
wait(2, seconds);
Brain.Screen.clearScreen(blue);

setFont#
Define a fonte utilizada para o texto apresentado no ecrã do V5 Brain.
Isto controla a fonte aplicada à saída de texto subsequente quando se utilizam funções de texto no ecrã, como print.
void setFont(
fontType font );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
Define a fonte para uma das seguintes:
|
|
|
|
|---|---|---|
|
|
|
|
|
|
|
|
Esta função não devolve qualquer valor.
Examples// Print larger text
Brain.Screen.setFont(mono40);
Brain.Screen.print("VEX");

// Print in Chinese
Brain.Screen.setFont(fontType::cjk16);
Brain.Screen.print("VEX机器人");

setPenWidth#
Define a espessura das linhas desenhadas e dos contornos das formas.
Available Functionsvoid setPenWidth(
uint32_t width );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
A largura da caneta, em pixéis, varia de 0 a 32. |
Esta função não devolve qualquer valor.
NotesA largura da caneta aplica-se a funções de desenho como
drawLine,drawRectangleedrawCircle.
// Draw a rectangle with a pen width of 10
Brain.Screen.setPenWidth(10);
Brain.Screen.drawRectangle(50, 50, 130, 60);

setPenColor#
Define a cor do texto, dos pixéis, das linhas e dos contornos das formas.
Available Functions1 — Define a cor da caneta utilizando um objeto de cor predefinido ou personalizado.
void setPenColor( const color& color );
2 — Define a cor da caneta utilizando um valor de cor hexadecimal.
void setPenColor( const char* color );
Parameters3 — Define a cor da caneta utilizando um valor de matiz.
void setPenColor( int hue );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
Sets the pen color using a
|
|
|
Define a cor da caneta utilizando um valor de cor hexadecimal representado como uma string (por exemplo, |
|
|
Define a cor da caneta utilizando um valor inteiro de matiz no intervalo |
Esta função não devolve qualquer valor.
NotesA cor padrão da caneta no início de um projeto é
white.A cor da caneta é utilizada para contornos de formas (como com
drawCircleoudrawRectangle), saída de texto e numérica (comprinteprintAt), e pixels individuais desenhados comdrawPixel.O valor do parâmetro de matiz
huebaseia-se num círculo cromático circular, como se mostra abaixo, em que os valores representam graus em torno do círculo (por exemplo, vermelho próximo de 0°, verde próximo de 120° e azul próximo de 240°).

// Draw a rectangle with orange borders
Brain.Screen.setPenColor(orange);
Brain.Screen.drawRectangle(50, 50, 130, 60);

setFillColor#
Define a cor de preenchimento utilizada ao desenhar formas.
Available Functions1 — Define a cor de preenchimento utilizando um objeto de cor predefinido ou personalizado.
void setFillColor( const color& color );
2 — Define a cor de preenchimento utilizando um valor de cor hexadecimal.
void setFillColor( const char* color );
Parameters3 — Define a cor de preenchimento utilizando um valor de matiz.
void setFillColor( int hue );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
Define a cor de preenchimento utilizando um objeto de cor
|
|
|
Define a cor de preenchimento utilizando um valor de cor hexadecimal representado como uma string (por exemplo, |
|
|
Define a cor de preenchimento utilizando um valor inteiro de matiz no intervalo |
Esta função não devolve qualquer valor.
NotesA cor de preenchimento predefinida no início de um projeto é
black.A cor de preenchimento é utilizada para o interior das formas (como acontece com
drawCircleoudrawRectangle).A cor de preenchimento é utilizada como cor de fundo para o texto impresso (como em
printeprintAt).Se for utilizado
transparentcom texto impresso, o fundo seráblack.
O valor do parâmetro de matiz
huebaseia-se num círculo cromático circular, como se mostra abaixo, em que os valores representam graus em torno do círculo (por exemplo, vermelho próximo de 0°, verde próximo de 120° e azul próximo de 240°).

// Draw a rectangle filled with purple
Brain.Screen.setFillColor(purple);
Brain.Screen.drawRectangle(50, 100, 130, 60);

setOrigin#
Define a origem utilizada para o desenho e impressão baseada em coordenadas no ecrã do Brain.
Available Functionsvoid setOrigin(
int32_t x,
int32_t y );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
A posição x da origem em relação ao canto superior esquerdo do ecrã do Brain varia de 0 a 479. |
|
|
A posição y da origem em relação ao canto superior esquerdo do ecrã do Brain varia de 0 a 239. |
Esta função não devolve qualquer valor.
NotesA origem predefinida é o canto superior esquerdo do ecrã na coordenada (0, 0).
A origem aplica-se a funções de coordenadas como
drawLine,drawRectangle,drawCircleeprintAt.A origem permanece em vigor até ser novamente alterada ou o projeto ser reiniciado.
setClipRegion#
Define uma área retangular no ecrã onde serão apresentados todos os desenhos e textos. Qualquer conteúdo fora dessa região não será mostrado.
Available Functionsvoid setClipRegion(
int x,
int y,
int width,
int height );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
A coordenada x do canto superior esquerdo da região de recorte, dada como um número inteiro de 0 a 479. |
|
|
A coordenada y do canto superior esquerdo da região de recorte, dada como um número inteiro de 0 a 239. |
|
|
A largura da região de recorte em pixéis, dada como um número inteiro de 0 a 479. |
|
|
A altura da região de recorte em pixéis, dada como um número inteiro de 0 a 239. |
Esta função não devolve qualquer valor.
NotesAs funções de desenho são ainda executadas mesmo que estejam fora da região de recorte, mas apenas a porção dentro da região é visível.
As coordenadas
xeysão relativas à origem do ecrã actual, que pode ser alterada através desetOrigin.A região de recorte aplica-se apenas ao thread atual.
A definição de uma nova região de recorte substitui qualquer região de recorte definida anteriormente para o thread atual.
// Restrict text and drawings to a specific region
Brain.Screen.setClipRegion(0, 0, 120, 120);
Brain.Screen.drawRectangle(60, 60, 100, 100, red);
Brain.Screen.printAt(60, 60, "Cut off!");

drawPixel#
Desenha um pixel no ecrã do V5 Brain na localização de pixel x e y selecionada.
Available Functionsvoid drawPixel(
int x,
int y );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
A coordenada x onde o pixel será desenhado, fornecida como um número inteiro de 0 a 479. |
|
|
A coordenada y onde o pixel será desenhado, fornecida como um número inteiro de 0 a 239. |
Esta função não devolve qualquer valor.
NotesOs pixéis são desenhados utilizando a cor da caneta actual definida com
setPenColor.As coordenadas
xeysão relativas à origem do ecrã actual, que pode ser definida através desetOrigin.Se a localização do pixel especificada estiver fora dos limites do ecrã, o pixel não será desenhado.
// Draw the pixels marking the corners of a square
Brain.Screen.drawPixel(250, 100);
Brain.Screen.drawPixel(275, 100);
Brain.Screen.drawPixel(250, 125);
Brain.Screen.drawPixel(275, 125);
![]()
drawLine#
Desenha uma linha reta ligando dois pontos no ecrã do V5 Brain.
Available Functionsvoid drawLine(
int x1,
int y1,
int x2,
int y2 );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
A coordenada x inicial da linha, dada como um número inteiro de 0 a 479. |
|
|
A coordenada y inicial da linha, dada como um número inteiro de 0 a 239. |
|
|
A coordenada x final da recta, dada como um número inteiro de 0 a 479. |
|
|
A coordenada y final da recta, dada como um número inteiro de 0 a 239. |
Esta função não devolve qualquer valor.
NotesAs linhas são desenhadas utilizando a cor da caneta actual definida com
setPenColor.A largura da linha é determinada pela largura da caneta actual definida com
setPenWidth.As coordenadas
xeysão relativas à origem do ecrã actual, que pode ser definida através desetOrigin.Se alguma parte da linha estiver fora dos limites do ecrã, apenas a parte visível será desenhada.
// Draw a line from the top left to bottom right of the screen
Brain.Screen.drawLine(0, 0, 479, 239);

drawRectangle#
Desenha um retângulo no ecrã do V5 Brain na posição e tamanho especificados.
Available Functions1 — Desenha e preenche um retângulo utilizando a cor de preenchimento atualmente configurada.
void drawRectangle( int x, int y, int width, int height );
2 — Desenha e preenche um retângulo utilizando um objeto de cor pré-definido ou personalizado.
void drawRectangle( int x, int y, int width, int height, const color& color );
3 — Desenha e preenche um retângulo utilizando um valor de cor hexadecimal.
void drawRectangle( int x, int y, int width, int height, const char* color );
Parameters4 — Desenha e preenche um retângulo utilizando um valor de matiz.
void drawRectangle( int x, int y, int width, int height, int hue );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
A coordenada x do canto superior esquerdo do retângulo, dada como um número inteiro de 0 a 479. |
|
|
A coordenada y do canto superior esquerdo do retângulo, dada como um número inteiro de 0 a 239. |
|
|
A largura do retângulo, dada como um número inteiro de 0 a 479. |
|
|
A altura do retângulo, dada como um número inteiro de 0 a 239. |
|
|
Preenche o retângulo utilizando um objeto de cor
|
|
|
Preenche o retângulo utilizando um valor de cor hexadecimal (por exemplo, |
|
|
Preenche o retângulo utilizando um valor de matiz no intervalo de |
Esta função não devolve qualquer valor.
NotesO contorno do retângulo é desenhado utilizando a cor da caneta atual definida com
setPenColor.A espessura do contorno é determinada pela largura da caneta actual definida com
setPenWidth.Quando não é fornecido nenhum parâmetro de cor
color, o interior do retângulo é preenchido utilizando a cor de preenchimento atual definida comsetFillColor.As coordenadas
xeysão relativas à origem do ecrã actual, que pode ser alterada através desetOrigin.Se alguma parte do retângulo estiver fora dos limites do ecrã, apenas a parte visível será desenhada.
O valor do parâmetro de matiz
huebaseia-se num círculo cromático circular, como se mostra abaixo, em que os valores representam graus em torno do círculo (por exemplo, vermelho próximo de 0°, verde próximo de 120° e azul próximo de 240°).

// Draw a rectangle on the screen
Brain.Screen.drawRectangle(50, 50, 130, 60);

drawCircle#
Desenha um círculo no ecrã do V5 Brain na posição e raio especificados.
Available Functions1 — Desenha e preenche um círculo utilizando a cor de preenchimento actualmente configurada.
void drawCircle( int x, int y, int radius );
2 — Desenha e preenche um círculo utilizando um objeto de cor pré-definido ou personalizado.
void drawCircle( int x, int y, int radius, const color& color );
3 — Desenha e preenche um círculo utilizando um valor de cor hexadecimal.
void drawCircle( int x, int y, int radius, const char* color );
Parameters4 — Desenha e preenche um círculo utilizando um valor de matiz.
void drawCircle( int x, int y, int radius, int hue );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
A coordenada x do centro da circunferência, dada como um número inteiro de 0 a 479. |
|
|
A coordenada y do centro da circunferência, dada como um número inteiro de 0 a 239. |
|
|
O raio do círculo, dado como um número inteiro de 0 a 239 pixéis. |
|
|
Preenche o círculo utilizando um objeto de cor
|
|
|
Preenche o círculo utilizando um valor de cor hexadecimal (por exemplo, |
|
|
Preenche o círculo utilizando um valor de matiz no intervalo de |
Esta função não devolve qualquer valor.
NotesO contorno do círculo é desenhado utilizando a cor da caneta actual definida com
setPenColor.A espessura do contorno é determinada pela largura da caneta actual definida com
setPenWidth.Quando não é fornecido nenhum parâmetro de cor
color, o interior do círculo é preenchido utilizando a cor de preenchimento actual definida comsetFillColor.As coordenadas
xeysão relativas à origem do ecrã actual, que pode ser alterada através desetOrigin.O valor do parâmetro de matiz
huebaseia-se num círculo cromático circular, como se mostra abaixo, em que os valores representam graus em torno do círculo (por exemplo, vermelho próximo de 0°, verde próximo de 120° e azul próximo de 240°).

// Draw a circle on the screen
Brain.Screen.drawCircle(240, 120, 40);

drawImageFromFile#
Desenha uma imagem no ecrã do V5 Brain utilizando um ficheiro de imagem armazenado no cartão SD.
Available Functionsbool drawImageFromFile(
const char* name,
int x,
int y );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
O nome do ficheiro da imagem no cartão SD. O ficheiro deve ter a extensão |
|
|
A coordenada x, em pixéis de 0 a 479, na qual será desenhada a margem esquerda da imagem. |
|
|
A coordenada y, em pixéis de 0 a 239, na qual será desenhada a margem superior da imagem. |
Retorna um valor booleano indicando se a imagem foi desenhada com sucesso:
true— A imagem foi carregada e desenhada com sucesso no ecrã.false— A imagem não pôde ser desenhada (por exemplo, se o ficheiro não existir ou for inválido).
Os formatos de imagem suportados são
.bmpe.png.O tamanho do ficheiro de imagem não deve exceder
512 KB.Recomenda-se a codificação RLE de 8 bits para minimizar o tamanho do ficheiro.
As dimensões máximas de imagem suportadas são o tamanho do ecrã do Brain (aproximadamente 479 x 239 pixels).
As coordenadas
xeysão relativas à origem do ecrã actual, que pode ser alterada através desetOrigin.
// Draw a bmp file on the Brain's screen at coordinate 0, 0
Brain.Screen.drawImageFromFile("test_image.bmp", 0, 0);
render#
Activa o buffer duplo para o ecrã do Brain. Uma vez acionado, quaisquer funções de desenho (como texto, formas ou imagens) não aparecerão imediatamente durante o resto do projeto. Em vez disso, as actualizações só serão apresentadas quando o comando render for utilizado novamente. Isto permite atualizações de ecrã mais suaves e controladas, mas significa que nada será visível até que o comando render seja utilizado.
1 — Ativa o buffer duplo ou renderiza o buffer traseiro no ecrã.
bool render();
Parameters2 — Renderiza o buffer traseiro no ecrã com controlo sobre o comportamento de sincronização vertical e execução opcional do agendador.
bool render( bool bVsyncWait, bool bRunScheduler = true );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
|
|
|
Opcional.
|
Retorna um valor booleano indicando se os desenhos guardados no buffer foram renderizados com sucesso no ecrã:
true— Os desenhos foram renderizados com sucesso no ecrã.false— Os desenhos não puderam ser renderizados no ecrã.
Notes
A chamada do comando
renderexigirá que o comandorenderseja utilizado para o resto do projeto.
Brain.Screen.render();
// Draw text to the back buffer
Brain.Screen.print("Render later...");
// Wait for a screen press to render drawings
while (!Brain.Screen.pressing()) {
wait(20, msec);
}
Brain.Screen.render();
pressing#
Informa se o ecrã do V5 Brain está a ser pressionado no momento.
Available Functionsbool pressing();
Esta função não aceita qualquer parâmetro.
Return ValuesRetorna um valor booleano indicando o estado atual de pressão do ecrã:true — O ecrã está a ser pressionado. ou false — O ecrã não está a ser pressionado.
// Change the screen's color after it's pressed
while (Brain.Screen.pressing() == false) {
wait(5, msec);
}
Brain.Screen.setFillColor(green);
Brain.Screen.drawRectangle(0, 0, 479, 239);
// Display different messages after the screen is pressed
while (!Brain.Screen.pressing()) {
wait(5, msec);
}
Brain.Screen.print("First message!");
Brain.Screen.newLine();
// Lift finger to press the screen again
while (Brain.Screen.pressing()) {
wait(5, msec);
}
while (Brain.Screen.pressing() == false) {
wait(5, msec);
}
Brain.Screen.print("Second message!");
Brain.Screen.newLine();
xPosition#
Retorna a coordenada x da última tecla premida no ecrã do V5 Brain.
Available Functionsint32_t xPosition();
Esta função não aceita qualquer parâmetro.
Return ValuesRetorna um valor int32_t que representa a coordenada x, em pixéis de 0 a 479, da última vez que o ecrã foi pressionado.
// Display a circle where the screen is pressed
while (Brain.Screen.pressing() == false) {
wait(5, msec);
}
Brain.Screen.drawCircle(Brain.Screen.xPosition(), Brain.Screen.yPosition(), 20, white);
yPosition#
Retorna a coordenada y da última vez que o botão foi premido no ecrã do V5 Brain.
Available Functionsint32_t yPosition();
Esta função não aceita qualquer parâmetro.
Return ValuesRetorna um int32_t int32_t ecrã foi pressionado.
// Display a circle where the screen is pressed
while (Brain.Screen.pressing() == false) {
wait(5, msec);
}
Brain.Screen.drawCircle(Brain.Screen.xPosition(), Brain.Screen.yPosition(), 20, white);
pressed#
Regista uma função a ser chamada quando o ecrã do V5 Brain for pressionado.
Available Functions1 — Chama uma função quando o ecrã é pressionado.
void pressed( void (*callback)(void) );
Parameters2 — Chama uma função quando o ecrã é pressionado e passa um argumento definido pelo utilizador para a função de callback.
void pressed( void (*callback)(void*), void* arg );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
Uma função que é chamada quando o ecrã é pressionado. |
|
|
Uma função que é chamada quando o ecrã é pressionado e recebe um argumento definido pelo utilizador. |
|
|
Um valor definido pelo utilizador que é passado para a função de retorno de chamada quando o ecrã é pressionado. |
Esta função não devolve qualquer valor.
NotesA função de retorno de chamada é executada cada vez que o ecrã do cérebro é pressionado.
Apenas uma função de retorno de chamada pode ser registada de cada vez; chamar
pressedsubstitui a função de retorno de chamada anterior.A função de callback deve retornar
void.
Defina a função de callback (fora de
int main())// Tracks how many times the screen is pressed. void onScreenPressed(void* arg) { int* count = (int*)arg; (*count)++; Brain.Screen.clearScreen(); Brain.Screen.setCursor(1, 1); Brain.Screen.print("Pressed %d times", *count); }Registe o callback dentro de
int main()int main() { int pressCount = 0; // Register the callback and pass a value to update. Brain.Screen.pressed(onScreenPressed, &pressCount); while (true) { wait(20, msec); } }
released#
Regista uma função a ser chamada quando o ecrã do V5 Brain for libertado após ser pressionado.
Available Functions1 — Chama uma função quando o ecrã é libertado após ser pressionado.
void released( void (*callback)(void) );
Parameters2 — Chama uma função quando o ecrã é libertado após ser pressionado e passa um argumento definido pelo utilizador para a função de callback.
void released( void (*callback)(void*), void* arg );
Parâmetro |
Tipo |
Descrição |
|---|---|---|
|
|
Uma função que é chamada quando o ecrã é libertado após ter sido pressionado. |
|
|
Uma função que é chamada quando o ecrã é libertado após ter sido pressionado e recebe um argumento definido pelo utilizador. |
|
|
Um valor definido pelo utilizador que é passado para a função de retorno de chamada quando o ecrã é libertado após ser pressionado. |
Esta função não devolve qualquer valor.
NotesA função de retorno de chamada é executada sempre que o ecrã do Brain é libertado após ser pressionado.
Apenas uma função de retorno de chamada pode ser registada de cada vez; chamar
releasedsubstitui novamente a função de callback anterior.A função de callback deve retornar
void.
Defina a função de callback (fora de
int main())// Tracks how many times the screen is released. void onScreenReleased(void* arg) { int* count = (int*)arg; (*count)++; Brain.Screen.clearScreen(); Brain.Screen.setCursor(1, 1); Brain.Screen.print("Released %d times", *count); }Registe o callback dentro de
int main()int main() { int releaseCount = 0; // Register the callback and pass a value to update. Brain.Screen.released(onScreenReleased, &releaseCount); while (true) { wait(20, msec); } }










