Mais

Como converter o tempo unix para o tipo de tempo qt?

Como converter o tempo unix para o tipo de tempo qt?


Como posso converter o carimbo de data / hora unix para o tipo de tempo qt usando a calculadora de campo qgis? Eu gostaria de evitar importar minha tabela para o excel e converter o timestamp para o tipo de tempo qt.


Isso é bastante fácil de fazer usando a calculadora de campo e uma função personalizada simples. O resultado é uma string, que você pode forçar para uma classe de data / hora adequada mais tarde (por exemplo, para alguns cálculos de data / hora adequados), ou estender o script para fazer isso por você.

AbrirCalculadora de campoe clique noEditor de funçõesaba. Você pode criar um novoNovo arquivoou estenda um existente com as seguintes linhas de código (Python):

"" "Defina novas funções usando @qgsfunction. Feature e parent devem ser sempre os últimos args. Use args = -1 para passar uma lista de valores como argumentos" "" de qgis.core import * from qgis.gui import * import time @qgsfunction (args = 'auto', group = "Custom") def fromSecToDate (value1, feature, parent): outtime = time.gmtime (value1) outtime = time.strftime ("% d-% m-% Y", outtime) retornar outtime

Deve ser assim em 2.18.3.

Assim que terminar, não se esqueça de acertar oCarregarbotão. Agora mude paraExpressãotab e encontrarfromSecToDatefunção sob oPersonalizadogrupo (conforme definido no script, sinta-se à vontade para modificar). Não se esqueça de nomear corretamente suas variáveis ​​e definir o tipo de campo de saída paraTexto (string).

Ser capaz de coagir a umdataformato, você precisará modificar o script acima, alterando a ordem das unidades: ano-mês-dia

time.strftime ("% d-% m-% Y", tempo de inatividade)

e então noAba Expressãocriar um novo campo de tipo de data usando

to_date (fromSecToDate ("sua variável"))

se não estiver disponível, você sempre pode criar sua própria função de conversão:

http://nathanw.net/2012/11/10/user-defined-expression-functions-for-qgis/

e deve ser bom compartilhar em algum lugar ou propor a inserção na biblioteca de expressões


A partir do QGIS 3.12 é possível usar o método integrado da Calculadora de Campodatetime_from_epoch ()que converte o carimbo de data / hora Unix para o valor de data e hora do QGIS.

https://www.qgis.org/en/site/forusers/visualchangelog312/index.html#feature-add-datetime-from-epoch-msec-from-epoch-expression-function


Como converter o tempo unix para o tipo de tempo qt? - Sistemas de Informação Geográfica

Obtenha a hora do calendário atual como um valor do tipo time_t.

A função retorna este valor e, se o argumento não for um Ponteiro nulo, ele também define esse valor para o objeto apontado por timer.

O valor retornado geralmente representa o número de segundos desde 00:00 horas, 1º de janeiro de 1970 UTC (ou seja, o atual carimbo de data / hora unix) Embora as bibliotecas possam usar uma representação diferente de tempo: programas portáteis não devem usar o valor retornado por esta função diretamente, mas sempre contam com chamadas para outros elementos da biblioteca padrão para traduzi-los para tipos portáteis (como localtime, gmtime ou difftime) .

Parâmetros

Valor de retorno

A hora do calendário atual como um objeto time_t.

Se o argumento não for um Ponteiro nulo, o valor de retorno é o mesmo que aquele armazenado no local apontado pelo argumento timer.

Se a função não puder recuperar a hora do calendário, ela retornará o valor -1.

time_t é um alias de um fundamental tipo aritmético capaz de representar tempos.


Internacionalização com Qt

O internacionalização e localização de um aplicativo são os processos de adaptação do aplicativo a diferentes idiomas, diferenças regionais e requisitos técnicos de um mercado-alvo. Internacionalização significa projetar um aplicativo de software de forma que possa ser adaptado a vários idiomas e regiões sem alterações de engenharia. Localização significa adaptar software internacionalizado para uma região ou idioma específico, adicionando componentes específicos de localidade (como formatos de data, hora e número) e tradução de texto.

Classes Qt e APIs relevantes

Essas classes suportam a internacionalização de aplicativos Qt.

Compara strings de acordo com um algoritmo de agrupamento localizado

Pode ser usado para acelerar o agrupamento de cordas

Converte entre números e suas representações de string em vários idiomas

Conversões entre codificações de texto

Suporte de internacionalização para saída de texto

Línguas e Sistemas de Escrita

Em alguns casos, a internacionalização é simples, por exemplo, tornar um aplicativo dos EUA acessível para usuários australianos ou britânicos pode exigir pouco mais do que algumas correções ortográficas. Mas para tornar um aplicativo dos EUA utilizável por usuários japoneses, ou um aplicativo coreano utilizável por usuários alemães, será necessário que o software opere não apenas em diferentes idiomas, mas use diferentes técnicas de entrada, codificação de caracteres e convenções de apresentação.

O Qt tenta tornar a internacionalização o menos dolorosa possível para os desenvolvedores. Todos os controles de entrada e métodos de desenho de texto no Qt oferecem suporte integrado para todos os idiomas suportados. O mecanismo de fonte embutido é capaz de renderizar de forma correta e atraente texto que contenha caracteres de uma variedade de sistemas de escrita diferentes ao mesmo tempo.

Qt suporta a maioria dos idiomas em uso hoje, em particular:

  • Todos os idiomas do Leste Asiático (chinês, japonês e coreano)
  • Todos os idiomas ocidentais (usando escrita latina)
  • árabe
  • Idiomas cirílicos (russo, ucraniano, etc.)
  • grego
  • hebraico
  • Tailandês e Lao
  • Todos os scripts em Unicode 6.2 que não requerem processamento especial
  • bengali
  • Birmanês (Mianmar)
  • Devanágari
  • Guzerate
  • Gurmukhi
  • Canarim
  • Khmer
  • Malaiala
  • tâmil
  • Telugu
  • Tibetano

A lista acima é compatível e funcionará em todas as plataformas, desde que o sistema tenha fontes para processar esses sistemas de escrita instalados.

No Windows, Linux e Unix com FontConfig (suporte de fonte do lado do cliente), os seguintes idiomas também são suportados:

No macOS, os seguintes idiomas também são compatíveis:

Muitos desses sistemas de escrita apresentam características especiais:

  • Comportamento especial de quebra de linha. Algumas das línguas asiáticas são escritas sem espaços entre as palavras. A quebra de linha pode ocorrer após cada caractere (com exceções) como em chinês, japonês e coreano, ou após limites lógicos de palavras como em tailandês.
  • Escrita bidirecional. Árabe e hebraico são escritos da direita para a esquerda, exceto para números e textos em inglês embutidos, que são escritos da esquerda para a direita. O comportamento exato é definido no Anexo Técnico Unicode # 9.
  • Sem espaçamento ou sinais diacríticos (acentos ou tremas nas línguas europeias). Alguns idiomas, como o vietnamita, fazem uso extensivo dessas marcas e alguns caracteres podem ter mais de uma marca ao mesmo tempo para esclarecer a pronúncia.
  • Ligaduras. Em contextos especiais, alguns pares de caracteres são substituídos por um glifo combinado formando uma ligadura. Exemplos comuns são os fl e fi ligatures usados ​​na composição de livros americanos e europeus.

O Qt tenta cuidar de todos os recursos especiais listados acima. Você geralmente não precisa se preocupar com esses recursos, desde que use os controles de entrada do Qt (por exemplo, QLineEdit, QTextEdit e classes derivadas ou o item Quick TextInput) e os controles de exibição do Qt (por exemplo, QLabel e item de texto rápido do Qt).

O suporte para esses sistemas de escrita é transparente para o programador e completamente encapsulado no mecanismo de texto do Qt. Isso significa que você geralmente não precisa ter nenhum conhecimento do sistema de escrita usado em um idioma específico, a menos que queira escrever seus próprios controles de entrada de texto. Em alguns idiomas, como árabe ou idiomas do subcontinente indiano, a largura e a forma de um glifo mudam dependendo dos caracteres ao redor. Para levar isso em consideração, use QTextLayout. Escrever controles de entrada também requer algum conhecimento dos scripts nos quais eles serão usados. Normalmente, a maneira mais fácil é criar uma subclasse de QLineEdit ou QTextEdit.

Produzindo Traduções

O Qt fornece um excelente suporte para traduzir os aplicativos Qt C ++ e Qt Quick para os idiomas locais. Gerentes de lançamento, tradutores e desenvolvedores podem usar as ferramentas de tradução Qt para realizar suas tarefas.

As ferramentas de tradução do Qt, Qt Linguist, lupdate e lrelease são instalados no subdiretório bin do diretório base em que o Qt está instalado. Para obter mais informações sobre como usá-los, consulte o Qt Linguist Manual.

O próprio Qt contém vários milhares de strings que também precisam ser traduzidas para os idiomas que você deseja. Você encontrará vários arquivos de tradução no repositório qttranslations. Antes de começar a traduzir o Qt, leia a página wiki Traduzindo o Qt para outros idiomas.

Habilitando a tradução

Normalmente, a função main () do seu aplicativo será semelhante a esta:

Para um aplicativo com reconhecimento de tradução, um objeto QTranslator é criado e, em seguida, uma tradução é carregada de acordo com o local de exibição preferido da IU do usuário no tempo de execução e, finalmente, o objeto tradutor é instalado no aplicativo.

Localizando Traduções Qt

Você também pode usar QLibraryInfo :: location () para localizar as traduções para os módulos Qt usados. Você pode solicitar o caminho para as traduções em tempo de execução, passando QLibraryInfo :: TranslationsPath para esta função.

Catálogos Disponíveis

Os catálogos de tradução do Qt estão localizados no repositório qttranslations.

Aviso: As traduções do Qt são fornecidas pela comunidade Qt e fornecidas sem qualquer garantia. As traduções podem estar ausentes, desatualizadas ou totalmente incorretas, a ponto de serem maliciosas. É recomendável que você audite todas as traduções enviadas.

O meta-catálogo qt_ contém as traduções Qt ainda existentes que foram incluídas no catálogo qt_ no Qt 4. Ele foi criado para tornar a portabilidade de aplicativos do Qt 4 para o Qt 5 mais fácil. O metatálogo depende de traduções que podem estar ausentes, porque pertencem a módulos desnecessários ou obsoletos, o que pode fazer com que o carregamento das traduções falhe. Se você usar módulos que são novos no Qt 5 em seu aplicativo, você deve especificar os nomes dos catálogos para esses módulos, mesmo se usar o meta-catálogo.

A tabela a seguir lista os catálogos de tradução disponíveis para os módulos e ferramentas Qt no Qt.

Módulo ou ferramenta QtCatálogo
Qt Assistant assistente_
Qt Bluetooth qtconnectivity_
Qt Simultâneo qtbase_
Qt Core qtbase_
Qt D-Bus qtbase_
Qt Designer designer_
Qt GUI qtbase_
Ajuda Qt qt_help_
Lingüista Qt linguista_
Localização Qt qtlocation_
Qt Multimedia qtmultimedia_
Qt Multimedia Widgets qtmultimedia_
Qt NFC qtconnectivity_
Rede Qt qtbase_
Posicionamento Qt qtlocation_
Suporte de impressão Qt qtbase_
Qt QML qtdeclarative_
Qt Quick qtdeclarative_
Qt Quick Controls qtquickcontrols2_
Qt Quick Widgets qtdeclarative_
Porta serial Qt qtserialport_
Qt SQL qtbase_
Qt WebEngine qtwebengine_
Qt WebSockets qtwebsockets_
Qt Widgets qtbase_
Exemplo: Módulos Qt Básicos

Por exemplo, para localizar traduções para módulos Qt básicos, como Qt Core, Qt GUI, Qt Network e Qt Widgets, adicione o seguinte código à função main ():

Suporte para codificações

A classe QTextCodec e os recursos em QTextStream facilitam o suporte a muitas codificações de entrada e saída legadas para os dados de seus usuários. Quando um aplicativo é iniciado, o local da máquina determinará a codificação de 8 bits usada ao lidar com dados externos de 8 bits. QTextCodec :: codecForLocale () retorna um codec que pode ser usado para converter entre esta codificação local e Unicode.

Ocasionalmente, o aplicativo pode exigir outras codificações além da codificação local padrão de 8 bits. Por exemplo, um aplicativo em uma localidade cirílico KOI8-R (a localidade padrão de fato na Rússia) pode precisar produzir cirílico na codificação ISO 8859-5. O código para isso seria:

Para converter Unicode em codificações locais de 8 bits, um atalho está disponível: a função QString :: toLocal8Bit () retorna esses dados de 8 bits. Outro atalho útil é QString :: toUtf8 (), que retorna texto na codificação UTF-8 de 8 bits: isso preserva perfeitamente as informações Unicode enquanto parece ASCII simples se o texto for totalmente ASCII.

Para converter de outra forma, existem as funções de conveniência QString :: fromUtf8 () e QString :: fromLocal8Bit (), ou o código geral, demonstrado por esta conversão de ISO 8859-5 cirílico para conversão Unicode:

I / O Unicode deve ser usado, pois isso maximiza a portabilidade de documentos entre usuários em todo o mundo. Em muitos casos, no entanto, ainda é necessário oferecer suporte a outras codificações, pois os usuários precisarão processar os documentos existentes. A codificação adicional mais importante para suportar é aquela retornada por QTextCodec :: codecForLocale (), já que esta é a que o usuário provavelmente precisará para se comunicar com outras pessoas e aplicativos (este é o codec usado por local8Bit ()).

Qt suporta nativamente a maioria das codificações usadas com mais freqüência. Para obter uma lista completa das codificações suportadas, consulte a documentação do QTextCodec.

Em alguns casos e para codificações usadas com menos frequência, pode ser necessário escrever sua própria subclasse QTextCodec. Dependendo da urgência, pode ser útil entrar em contato com a equipe de suporte técnico do Qt ou perguntar na lista de discussão de interesse do qt para ver se alguém já está trabalhando no suporte à codificação.

Localizando Números, Datas, Horários e Moeda

Localização é o processo de adaptação às convenções locais, por exemplo, apresentando datas e horas usando os formatos preferidos localmente. Para números localizados, datas, horas e strings de moeda, use a classe QLocale.

A localização de imagens não é recomendada. Escolha ícones claros apropriados para todas as localidades, em vez de usar trocadilhos locais ou metáforas esticadas. A exceção é para imagens de setas apontando para a esquerda e para a direita, que podem precisar ser invertidas para as localidades árabe e hebraica.

Tradução Dinâmica

Alguns aplicativos, como o Qt Linguist, devem ser capazes de suportar alterações nas configurações de idioma do usuário enquanto eles ainda estão em execução. Para tornar os widgets cientes das mudanças nos objetos QTranslator instalados, reimplemente a função changeEvent () do widget para verificar se o evento é um evento LanguageChange e atualize o texto exibido pelos widgets usando a função tr () da maneira usual. Por exemplo:

Todos os outros eventos de mudança devem ser transmitidos chamando a implementação padrão da função.

A lista de tradutores instalados pode mudar em reação a um evento LocaleChange, ou o aplicativo pode fornecer uma interface de usuário que permite ao usuário alterar o idioma do aplicativo atual.

O manipulador de eventos padrão para subclasses de QWidget responde ao evento QEvent :: LanguageChange e chama esta função quando necessário.

Os eventos LanguageChange são postados quando uma nova tradução é instalada usando a função QCoreApplication :: installTranslator (). Além disso, outros componentes do aplicativo também podem forçar os widgets a se atualizarem publicando eventos LanguageChange neles.

Suporte do Sistema

Alguns dos sistemas operacionais e sistemas de janelas em que o Qt é executado têm suporte limitado para Unicode. O nível de suporte disponível no sistema subjacente tem alguma influência no suporte que o Qt pode fornecer nessas plataformas, embora em geral os aplicativos Qt não precisem se preocupar muito com as limitações específicas da plataforma.

Unix / X11
  • Fontes e métodos de entrada orientados para a localidade. O Qt os oculta e fornece entrada e saída Unicode.
  • Convenções de sistema de arquivos, como UTF-8, são hoje usadas por padrão na maioria das variantes do Unix. Todas as funções de arquivo Qt permitem Unicode, mas convertem nomes de arquivos para a codificação local de 8 bits, pois esta é a convenção Unix (consulte QFile :: setEncodingFunction () para explorar codificações alternativas).
  • O padrão de E / S de arquivo é a codificação local de 8 bits, com opções Unicode em QTextStream.
  • Algumas distribuições Unix mais antigas contêm apenas suporte parcial para alguns locais. Por exemplo, se você tiver um diretório /usr/share/locale/ja_JP.EUC, isso não significa necessariamente que você pode exibir texto em japonês, você também precisa ter fontes japonesas instaladas e o /usr/share/locale/ja_JP.EUC o diretório precisa ser completo. Para obter melhores resultados, use localidades completas do fornecedor do sistema.
Linux
  • Qt fornece suporte Unicode completo, incluindo métodos de entrada, fontes, área de transferência, arrastar e soltar.
  • O sistema de arquivos geralmente é codificado em UTF-8 em todas as distribuições Linux modernas e não deve representar um problema. O padrão de E / S de arquivo é UTF-8.
Janelas
  • Qt fornece suporte Unicode completo, incluindo métodos de entrada, fontes, área de transferência, arrastar e soltar e nomes de arquivo.
  • O padrão de E / S de arquivo é Latin1, com opções Unicode em QTextStream. Observe que alguns programas do Windows não entendem arquivos de texto Unicode big-endian, embora essa seja a ordem prescrita pelo Padrão Unicode na ausência de protocolos de nível superior.
Mac OS

Para obter detalhes sobre a tradução específica do macOS, consulte o documento de problemas do Qt para macOS aqui.


Documentação de tipo de membro

Enum QTimeZone :: NameType

O tipo de nome de fuso horário.

ConstanteValorDescrição
QTimeZone :: DefaultName 0 A forma padrão do nome do fuso horário, por exemplo, LongName, ShortName ou OffsetName
QTimeZone :: LongName 1 A forma longa do nome do fuso horário, por exemplo, "Hora da Europa Central"
QTimeZone :: ShortName 2 A forma abreviada do nome do fuso horário, geralmente uma abreviatura, por ex. "CET"
QTimeZone :: OffsetName 3 A forma de deslocamento ISO padrão do nome do fuso horário, por exemplo, "UTC + 01: 00"

Typedef QTimeZone :: OffsetDataList

Enum QTimeZone :: TimeType

O tipo de fuso horário, por exemplo, ao solicitar o nome. Em fusos horários que não se aplicam ao horário de verão, todos os três valores podem retornar o mesmo resultado.

ConstanteValorDescrição
QTimeZone :: StandardTime 0 A hora padrão em um fuso horário, ou seja, quando o horário de verão não está em vigor. Por exemplo, ao formatar um nome de exibição, isso mostrará algo como "Horário padrão do Pacífico".
QTimeZone :: DaylightTime 1 Um horário em que o horário de verão está em vigor. Por exemplo, ao formatar um nome de exibição, isso mostrará algo como "Horário de verão do Pacífico".
QTimeZone :: GenericTime 2 Uma hora que não é especificamente padrão ou horário de verão, seja uma hora desconhecida ou uma forma neutra. Por exemplo, ao formatar um nome de exibição, isso mostrará algo como "Horário do Pacífico".

Enum QTimeZone :: anonymous

Os deslocamentos lógicos de UTC variam de -14 a +14 horas. Nenhuma zona conhecida & gt 12 horas a oeste de Greenwich (Baker Island, EUA). Nenhuma zona conhecida & gt 14 horas a leste de Greenwich (Kiritimati, Ilha Christmas, Kiribati).

ConstanteValorDescrição
QTimeZone :: MinUtcOffsetSecs -14 * 3600 -14 * 3600,
QTimeZone :: MaxUtcOffsetSecs +14 * 3600 +14 * 3600

Conteúdo

Duas camadas de codificação constituem o tempo Unix. A primeira camada codifica um ponto no tempo como um número real escalar que representa o número de segundos que se passaram desde 00:00:00 UTC de quinta-feira, 1 de janeiro de 1970. [5] A segunda camada codifica esse número como uma sequência de bits ou dígitos decimais.

Como é padrão com o UTC, este artigo rotula os dias usando o calendário gregoriano e conta as horas de cada dia em horas, minutos e segundos. Alguns dos exemplos também mostram o International Atomic Time (TAI), outro esquema de tempo que usa os mesmos segundos e é exibido no mesmo formato do UTC, mas em que cada dia tem exatamente 86.400 segundos de duração, perdendo gradativamente a sincronização com a rotação da Terra a uma taxa de aproximadamente um segundo por ano.

Tempo de codificação como um número Editar

A hora Unix é um único número assinado que aumenta a cada segundo, o que torna mais fácil para os computadores armazenar e manipular do que os sistemas de data convencionais. Os programas intérpretes podem então convertê-lo em um formato legível por humanos.

O Época Unix é a hora 00:00:00 UTC em 1 ° de janeiro de 1970. [2] Há um problema com essa definição, pois o UTC não existia em sua forma atual até 1972, essa questão é discutida abaixo. Para resumir, o restante desta seção usa o formato de data e hora ISO 8601, no qual a época Unix é 1970-01-01T00: 00: 00Z.

O número de tempo do Unix é zero na época do Unix e aumenta exatamente 86.400 por dia desde a época. Assim, 2004-09-16T00: 00: 00Z, 12 677 dias após a época, é representado pelo número de tempo Unix 12 677 × 86 400 = 1 095 292 800. Isso também pode ser estendido para trás a partir da época, usando números negativos, portanto, 1957-10-04T00: 00: 00Z, 4472 dias antes da época, é representado pelo número de tempo Unix −4472 × 86 400 = −386 380 800. Isso se aplica dentro de dias, bem como o número de tempo em qualquer hora do dia é o número de segundos que se passaram desde a meia-noite daquele dia adicionado ao número de tempo dessa meia-noite.

O tempo Unix é às vezes, erroneamente, referido como Tempo de época, porque a época Unix é baseada em uma época e por causa de um mal-entendido comum de que a época Unix é a única época (frequentemente chamada de "a época" [2] ). [6] [7] [8]

Segundos bissextos Editar

O esquema acima significa que em um dia UTC normal, que tem uma duração de 86.400 segundos, o número do horário Unix muda de maneira contínua até a meia-noite. Por exemplo, no final do dia usado nos exemplos acima, as representações de tempo progridem da seguinte forma:

Horário Unix da meia-noite até 17 de setembro de 2004 (sem segundo bissexto)
TAI (17 de setembro de 2004) UTC (16 a 17 de setembro de 2004) Hora Unix
17-09-2004T00: 00: 30,75 2004-09-16T23: 59: 58,75 1 095 379 198 .75
17-09-2004T00: 00: 31,00 2004-09-16T23: 59: 59,00 1 095 379 199 .00
17-09-2004T00: 00: 31,25 2004-09-16T23: 59: 59,25 1 095 379 199 .25
17-09-2004T00: 00: 31,50 2004-09-16T23: 59: 59,50 1 095 379 199 .50
17-09-2004T00: 00: 31,75 2004-09-16T23: 59: 59,75 1 095 379 199 .75
17-09-2004T00: 00: 32,00 17-09-2004T00: 00: 00.00 1 095 379 200 .00
17-09-2004T00: 00: 32,25 17-09-2004T00: 00: 00.25 1 095 379 200 .25
17-09-2004T00: 00: 32,50 17-09-2004T00: 00: 00.50 1 095 379 200 .50
2004-09-17T00: 00: 32,75 17-09-2004T00: 00: 00,75 1 095 379 200 .75
17-09-2004T00: 00: 33,00 17-09-2004T00: 00: 01.00 1 095 379 201 .00
17-09-2004T00: 00: 33,25 17-09-2004T00: 00: 01,25 1 095 379 201 .25

Quando ocorre um segundo bissexto, o dia UTC não tem exatamente 86.400 segundos de duração e o número de tempo Unix (que sempre aumenta exatamente em 86.400 a cada dia) experimenta uma descontinuidade. Os segundos bissextos podem ser positivos ou negativos. Nenhum segundo bissexto negativo jamais foi declarado, mas se um fosse, então no final de um dia com um segundo bissexto negativo, o número de tempo Unix aumentaria 1 para o início do dia seguinte. Durante um segundo bissexto positivo no final de um dia, que ocorre a cada ano e meio em média, o número de tempo Unix aumenta continuamente até o dia seguinte durante o segundo bissexto e, em seguida, no final do segundo salta para trás em 1 (voltando ao início do dia seguinte). Por exemplo, isso é o que aconteceu em sistemas POSIX.1 em conformidade estrita no final de 1998:

Horário Unix da meia-noite até 1º de janeiro de 1999 (segundo bissexto positivo)
TAI (1 de janeiro de 1999) UTC (31 de dezembro de 1998 a 1 de janeiro de 1999) Hora Unix
01-01-1999 T00: 00: 29,75 1998-12-31T23: 59: 58,75 915 148 798 .75
01-01-1999 T00: 00: 30.00 1998-12-31T23: 59: 59,00 915 148 799 .00
01/01/1999 T00: 00: 30,25 1998-12-31T23: 59: 59,25 915 148 799 .25
01/01/1999 T00: 00: 30,50 1998-12-31T23: 59: 59,50 915 148 799 .50
01-01-1999 T00: 00: 30,75 1998-12-31T23: 59: 59,75 915 148 799 .75
01/01/1999 T00: 00: 31,00 1998-12-31T23: 59: 60,00 915 148 800 .00
01/01/1999 T00: 00: 31,25 1998-12-31T23: 59: 60,25 915 148 800 .25
01-01-1999 T00: 00: 31,50 1998-12-31T23: 59: 60.50 915 148 800 .50
01/01/1999 T00: 00: 31,75 1998-12-31T23: 59: 60,75 915 148 800 .75
01-01-1999 T00: 00: 32,00 01-01-1999 T00: 00: 00.00 915 148 800 .00
01/01/1999 T00: 00: 32,25 01-01-1999 T00: 00: 00.25 915 148 800 .25
01/01/1999 T00: 00: 32,50 01-01-1999 T00: 00: 00.50 915 148 800 .50
01-01-1999 T00: 00: 32,75 01-01-1999 T00: 00: 00,75 915 148 800 .75
01/01/1999 T00: 00: 33,00 01/01/1999 T00: 00: 01,00 915 148 801 .00
01/01/1999 T00: 00: 33,25 01/01/1999 T00: 00: 01,25 915 148 801 .25

Os números de tempo Unix são repetidos no segundo imediatamente após um segundo bissexto positivo. O número de tempo Unix 1 483 142 400 é, portanto, ambíguo: pode referir-se ao início do segundo bissexto (2016-12-31 23:59:60) ou ao final dele, um segundo depois (2017-01-01 00 : 00: 00). No caso teórico, quando ocorre um segundo bissexto negativo, nenhuma ambigüidade é causada, mas em vez disso, há uma faixa de números de tempo Unix que não se referem a nenhum ponto no tempo UTC.

Um relógio Unix é frequentemente implementado com um tipo diferente de tratamento de segundos intercalados positivo associado ao Network Time Protocol (NTP). Isso resulta em um sistema que não está em conformidade com o padrão POSIX. Consulte a seção abaixo sobre NTP para obter detalhes.

Ao lidar com períodos que não abrangem um segundo bissexto UTC, a diferença entre dois números de tempo Unix é igual à duração em segundos do período entre os pontos correspondentes no tempo. Esta é uma técnica computacional comum. No entanto, onde os segundos bissextos ocorrem, esses cálculos dão a resposta errada. Em aplicações onde esse nível de precisão é necessário, é necessário consultar uma tabela de segundos bissextos ao lidar com tempos Unix, e muitas vezes é preferível usar uma codificação de tempo diferente que não tenha esse problema.

Um número de tempo Unix é facilmente convertido de volta em um tempo UTC tomando o quociente e o módulo do número de tempo Unix, módulo 86 400. O quociente é o número de dias desde a época e o módulo é o número de segundos desde a meia-noite UTC desse dia. Se for dado um número de tempo Unix ambíguo devido a um segundo bissexto positivo, este algoritmo o interpreta como o tempo logo após a meia-noite. Ele nunca gera um tempo durante um segundo bissexto. Se for fornecido um número de tempo Unix que é inválido devido a um segundo bissexto negativo, ele gera um tempo UTC igualmente inválido. Se essas condições forem significativas, é necessário consultar uma tabela de segundos intercalados para detectá-las.

Variante não síncrona baseada em protocolo de tempo de rede Editar

Normalmente, um relógio Unix no estilo Mills é implementado com manipulação de segundos bissextos não sincronizado com a mudança do número de tempo Unix. O número do tempo inicialmente diminui onde um salto deveria ter ocorrido e então salta para o tempo correto 1 segundo após o salto. Isso torna a implementação mais fácil e é descrito pelo artigo de Mills. [9] Isso é o que acontece em um segundo bissexto positivo:

Relógio Unix não síncrono no estilo Mills
da meia-noite até 1º de janeiro de 1999 (segundo bissexto positivo)
TAI (1 de janeiro de 1999) UTC (31 de dezembro de 1998 a 1 de janeiro de 1999) Estado Relógio Unix
01/01/1999 T00: 00: 29,75 1998-12-31T23: 59: 58,75 TIME_INS 915 148 798 .75
01-01-1999 T00: 00: 30.00 1998-12-31T23: 59: 59,00 TIME_INS 915 148 799 .00
01/01/1999 T00: 00: 30,25 1998-12-31T23: 59: 59,25 TIME_INS 915 148 799 .25
01/01/1999 T00: 00: 30,50 1998-12-31T23: 59: 59,50 TIME_INS 915 148 799 .50
01-01-1999 T00: 00: 30,75 1998-12-31T23: 59: 59,75 TIME_INS 915 148 799 .75
01/01/1999 T00: 00: 31,00 1998-12-31T23: 59: 60,00 TIME_INS 915 148 800 .00
01/01/1999 T00: 00: 31,25 1998-12-31T23: 59: 60,25 TIME_OOP 915 148 799 .25
01-01-1999 T00: 00: 31,50 1998-12-31T23: 59: 60.50 TIME_OOP 915 148 799 .50
01/01/1999 T00: 00: 31,75 1998-12-31T23: 59: 60,75 TIME_OOP 915 148 799 .75
01-01-1999 T00: 00: 32,00 01-01-1999 T00: 00: 00.00 TIME_OOP 915 148 800 .00
01/01/1999 T00: 00: 32,25 01-01-1999 T00: 00: 00.25 TEMPO DE ESPERA 915 148 800 .25
01/01/1999 T00: 00: 32,50 01-01-1999 T00: 00: 00.50 TEMPO DE ESPERA 915 148 800 .50
01-01-1999 T00: 00: 32,75 01-01-1999 T00: 00: 00,75 TEMPO DE ESPERA 915 148 800 .75
01/01/1999 T00: 00: 33,00 01/01/1999 T00: 00: 01,00 TEMPO DE ESPERA 915 148 801 .00
01/01/1999 T00: 00: 33,25 01/01/1999 T00: 00: 01,25 TEMPO DE ESPERA 915 148 801 .25

Isso pode ser decodificado apropriadamente prestando atenção à variável de estado do segundo salto, que indica inequivocamente se o salto já foi executado. A mudança da variável de estado é síncrona com o salto.

Uma situação semelhante surge com um segundo bissexto negativo, em que o segundo que é pulado é um pouco tarde demais. Muito brevemente, o sistema mostra um número de tempo nominalmente impossível, mas isso pode ser detectado pelo TIME_DEL estado e corrigido.

Neste tipo de sistema, o número de tempo Unix viola POSIX em ambos os tipos de segundos bissextos. Coletar a variável de estado do segundo intercalado junto com o número de tempo permite uma decodificação inequívoca, de modo que o número de tempo POSIX correto pode ser gerado se desejado, ou o tempo UTC completo pode ser armazenado em um formato mais adequado.

A lógica de decodificação necessária para lidar com esse estilo de relógio Unix também decodificaria corretamente um relógio hipotético em conformidade com POSIX usando a mesma interface. Isso seria alcançado indicando o TIME_INS estado durante a totalidade de um segundo bissexto inserido, em seguida, indicando TEMPO DE ESPERA durante todo o segundo seguinte, repetindo a contagem dos segundos. Isso requer tratamento de segundos intercalados síncronos. Esta é provavelmente a melhor maneira de expressar a hora UTC no formato de relógio Unix, por meio de uma interface Unix, quando o relógio subjacente não é perturbado por segundos bissextos.

Edição de variante baseada em TAI

Outra variante, muito mais rara e não conforme de manutenção de horário Unix, envolve a codificação TAI em vez de UTC, alguns sistemas Linux são configurados dessa maneira. [10] Como o TAI não tem segundos bissextos e todos os dias do TAI têm exatamente 86400 segundos de duração, essa codificação é, na verdade, uma contagem linear pura dos segundos decorridos desde 1970-01-01T00: 00: 00 TAI. Isso torna a aritmética de intervalo de tempo muito mais fácil. Os valores de tempo desses sistemas não sofrem a ambigüidade que os sistemas POSIX em conformidade estrita ou os sistemas acionados por NTP têm.

Nesses sistemas, é necessário consultar uma tabela de segundos bissextos para converter corretamente entre UTC e a representação de pseudo-tempo Unix. Isso se assemelha à maneira como as tabelas de fuso horário devem ser consultadas para converter de e para o horário civil. O banco de dados de fuso horário da IANA inclui informações de segundo bissexto, e o código de amostra disponível na mesma fonte usa essas informações para converter entre timestamps baseados em TAI e horário local. A conversão também enfrenta problemas de definição antes do início de 1972 da forma atual de UTC (consulte a seção Base UTC abaixo).

Este sistema baseado em TAI, apesar de sua semelhança superficial, não é hora do Unix. Ele codifica tempos com valores que diferem em vários segundos dos valores de tempo POSIX. Uma versão desse sistema foi proposta para inclusão no ISO C's time.h, mas apenas a parte UTC foi aceita em 2011. [11] Um tai_clock, entretanto, existe em C ++ 20.

Representando o número Editar

Um número de tempo Unix pode ser representado em qualquer forma capaz de representar números. Em algumas aplicações, o número é simplesmente representado textualmente como uma sequência de dígitos decimais, levantando apenas problemas adicionais triviais. No entanto, certas representações binárias dos tempos do Unix são particularmente significativas.

O tipo de dados Unix time_t que representa um ponto no tempo é, em muitas plataformas, um inteiro assinado, tradicionalmente de 32 bits (mas veja abaixo), codificando diretamente o número de tempo Unix conforme descrito na seção anterior. Ser de 32 bits significa que cobre um intervalo de cerca de 136 anos no total. A data representável mínima é sexta-feira, 13-12-1901, e a data representável máxima é terça-feira 19-01-2038. Um segundo após 03:14:07 UTC 2038-01-19 esta representação irá estourar. Esse marco é antecipado com uma mistura de diversão e pavor - veja o problema do ano 2038.

Em alguns sistemas operacionais mais recentes, time_t foi ampliado para 64 bits. Isso expande os tempos representáveis ​​em aproximadamente 293 bilhões de anos em ambas as direções, o que é mais de vinte vezes a idade atual do universo por direção.

Originalmente, havia alguma controvérsia sobre se o Unix time_t deveria ser assinado ou não. Se não tivesse sinal, seu alcance no futuro seria dobrado, adiando o estouro de 32 bits (em 68 anos). No entanto, ele seria incapaz de representar tempos anteriores à época. O consenso é que time_t seja assinado, e esta é a prática usual. A plataforma de desenvolvimento de software para a versão 6 do sistema operacional QNX tem um time_t não assinado de 32 bits, embora as versões mais antigas usassem um tipo assinado.

As especificações POSIX e Open Group Unix incluem a biblioteca padrão C, que inclui os tipos de tempo e funções definidas no arquivo de cabeçalho & lttime.h & gt. O padrão ISO C afirma que time_t deve ser um tipo aritmético, mas não exige nenhum tipo específico ou codificação para ele. POSIX requer que time_t seja um tipo inteiro, mas não obriga que seja assinado ou não assinado.

O Unix não tem tradição de representar diretamente números de tempo Unix não inteiros como frações binárias. Em vez disso, os tempos com precisão inferior a um segundo são representados usando tipos de dados compostos que consistem em dois inteiros, o primeiro sendo um time_t (a parte integral do tempo Unix), e o segundo sendo a parte fracionária do número do tempo em milionésimos (em struct timeval ) or billionths (in struct timespec ). [12] [13] These structures provide a decimal-based fixed-point data format, which is useful for some applications, and trivial to convert for others.

UTC basis Edit

The present form of UTC, with leap seconds, is defined only starting from 1 January 1972. Prior to that, since 1 January 1961 there was an older form of UTC in which not only were there occasional time steps, which were by non-integer numbers of seconds, but also the UTC second was slightly longer than the SI second, and periodically changed to continuously approximate the Earth's rotation. Prior to 1961 there was no UTC, and prior to 1958 there was no widespread atomic timekeeping in these eras, some approximation of GMT (based directly on the Earth's rotation) was used instead of an atomic timescale. [ citação necessária ]

The precise definition of Unix time as an encoding of UTC is only uncontroversial when applied to the present form of UTC. The Unix epoch predating the start of this form of UTC does not affect its use in this era: the number of days from 1 January 1970 (the Unix epoch) to 1 January 1972 (the start of UTC) is not in question, and the number of days is all that is significant to Unix time.

The meaning of Unix time values below +63 072 000 (i.e., prior to 1 January 1972) is not precisely defined. The basis of such Unix times is best understood to be an unspecified approximation of UTC. Computers of that era rarely had clocks set sufficiently accurately to provide meaningful sub-second timestamps in any case. Unix time is not a suitable way to represent times prior to 1972 in applications requiring sub-second precision such applications must, at least, define which form of UT or GMT they use.

As of 2009 [update] , the possibility of ending the use of leap seconds in civil time is being considered. [14] A likely means to execute this change is to define a new time scale, called International Time, that initially matches UTC but thereafter has no leap seconds, thus remaining at a constant offset from TAI. If this happens, it is likely that Unix time will be prospectively defined in terms of this new time scale, instead of UTC. Uncertainty about whether this will occur makes prospective Unix time no less predictable than it already is: if UTC were simply to have no further leap seconds the result would be the same.

The earliest versions of Unix time had a 32-bit integer incrementing at a rate of 60 Hz, which was the rate of the system clock on the hardware of the early Unix systems. The value 60 Hz still appears in some software interfaces as a result. The epoch also differed from the current value. The first edition Unix Programmer's Manual dated 3 November 1971 defines the Unix time as "the time since 00:00:00, 1 January 1971, measured in sixtieths of a second". [15]

The User Manual also commented that "the chronologically-minded user will note that 2**32 sixtieths of a second is only about 2.5 years". Because of this limited range, the epoch was redefined more than once, before the rate was changed to 1 Hz and the epoch was set to its present value of 1 January 1970 00:00:00 UTC. This yielded a range of about 136 years, half of it before 1970 and half of it afterwards.

As indicated by the definition quoted above, the Unix time scale was originally intended to be a simple linear representation of time elapsed since an epoch. However, there was no consideration of the details of time scales, and it was implicitly assumed that there was a simple linear time scale already available and agreed upon. The first edition manual's definition does not even specify which time zone is used. Several later problems, including the complexity of the present definition, result from Unix time having been defined gradually by usage rather than fully defined from the outset.

When POSIX.1 was written, the question arose of how to precisely define time_t in the face of leap seconds. The POSIX committee considered whether Unix time should remain, as intended, a linear count of seconds since the epoch, at the expense of complexity in conversions with civil time or a representation of civil time, at the expense of inconsistency around leap seconds. Computer clocks of the era were not sufficiently precisely set to form a precedent one way or the other.

The POSIX committee was swayed by arguments against complexity in the library functions, [ citação necessária ] and firmly defined the Unix time in a simple manner in terms of the elements of UTC time. This definition was so simple that it did not even encompass the entire leap year rule of the Gregorian calendar, and would make 2100 a leap year.

The 2001 edition of POSIX.1 rectified the faulty leap year rule in the definition of Unix time, but retained the essential definition of Unix time as an encoding of UTC rather than a linear time scale. Since the mid-1990s, computer clocks have been routinely set with sufficient precision for this to matter, and they have most commonly been set using the UTC-based definition of Unix time. This has resulted in considerable complexity in Unix implementations, and in the Network Time Protocol, to execute steps in the Unix time number whenever leap seconds occur. [ citação necessária ]

Unix enthusiasts have a history of holding "time_t parties" (pronounced "time tea parties") to celebrate significant values of the Unix time number. [16] [17] These are directly analogous to the new year celebrations that occur at the change of year in many calendars. As the use of Unix time has spread, so has the practice of celebrating its milestones. Usually it is time values that are round numbers in decimal that are celebrated, following the Unix convention of viewing time_t values in decimal. Among some groups round binary numbers are also celebrated, such as +2 30 which occurred at 13:37:04 UTC on Saturday, 10 January 2004. [ citação necessária ]

The events that these celebrate are typically described as "N seconds since the Unix epoch", but this is inaccurate as discussed above, due to the handling of leap seconds in Unix time the number of seconds elapsed since the Unix epoch is slightly greater than the Unix time number for times later than the epoch.

  • At 18:36:57 UTC on Wednesday, 17 October 1973, the first appearance of the date in ISO 8601 format [a] (1973-10-17) within the digits of Unix time (119731017) took place.
  • At 01:46:40 UTC on Sunday, 9 September 2001, the Unix billennium (Unix time number 1 000 000 000 ) was celebrated. [18] The name billennium is a portmanteau of bilhão e millennium. [19][20] Some programs which stored timestamps using a text representation encountered sorting errors, as in a text sort times after the turnover, starting with a 1 digit, erroneously sorted before earlier times starting with a 9 digit. Affected programs included the popular Usenet reader KNode and e-mail client KMail, part of the KDE desktop environment. Such bugs were generally cosmetic in nature and quickly fixed once problems became apparent. The problem also affected many Filtrix document-format filters provided with Linux versions of WordPerfect a patch was created by the user community to solve this problem, since Corel no longer sold or supported that version of the program. [21]
  • At 23:31:30 UTC on Friday, 13 February 2009, the decimal representation of Unix time reached 1 234 567 890 seconds. [22]Google celebrated this with a Google doodle. [23] Parties and other celebrations were held around the world, among various technical subcultures, to celebrate the 1 234 567 890 th second. [16][24]
  • At 03:33:20 UTC on Wednesday, 18 May 2033, the Unix time value will equal 2 000 000 000 seconds.
  • At 06:28:16 UTC on Thursday, 7 February 2036, Network Time Protocol will loop over to the next epoch, as the 32-bit time stamp value used in NTP (unsigned, but based on 1 January 1900) will overflow. This date is close to the following date because the 136-year range of a 32-bit integer number of seconds is close to twice the 70-year offset between the two epochs.
  • At 03:14:08 UTC on Tuesday, 19 January 2038, 32-bit versions of the Unix timestamp will cease to work, as it will overflow the largest value that can be held in a signed 32-bit number ( 7FFFFFFF 16 or 2 147 483 647 ). Before this moment, software using 32-bit time stamps will need to adopt a new convention for time stamps, [25] and file formats using 32-bit time stamps will need to be changed to support larger time stamps or a different epoch. If unchanged, the next second will be incorrectly interpreted as 20:45:52 Friday 13 December 1901 UTC . This is referred to as the Year 2038 problem.
  • At 05:20:00 UTC on Saturday, 24 January 2065, the Unix time value will equal 3 000 000 000 seconds.
  • At 06:28:15 UTC on Sunday, 7 February 2106, the Unix time will reach FFFFFFFF 16 or 4 294 967 295 seconds, which, for systems that hold the time on 32-bit unsigned integers, is the maximum attainable. For some of these systems, the next second will be incorrectly interpreted as 00:00:00 Thursday 1 January 1970 UTC . Other systems may experience an overflow error with unpredictable outcomes. [citação necessária]
  • At 15:30:08 UTC on Sunday, 4 December 292 277 026 596 , [26][27] 64-bit versions of the Unix time stamp cease to work, as it will overflow the largest value that can be held in a signed 64-bit number. This is nearly 22 times the estimated current age of the universe, which is 1.37 × 10 10 years (13.7 billion).

Vernor Vinge's novel A Deepness in the Sky describes a spacefaring trading civilization thousands of years in the future that still uses the Unix epoch. The "programmer-archaeologist" responsible for finding and maintaining usable code in mature computer systems first believes that the epoch refers to the time when man first walked on the Moon, but then realizes that it is "the 0-second of one of Humankind's first computer operating systems". [28]


Related Non-Members

QDataStream & operator<< ( QDataStream &out, const QDateTime &dateTime)

Writes dateTime to the out stream.

QDataStream & operator>> ( QDataStream &dentro, QDateTime &dateTime)

Reads a datetime from the stream dentro into dateTime.

© 2021 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.


How to convert unix time to qt time type? - Sistemas de Informação Geográfica

IMGKit: Python library of HTML to IMG wrapper

Python 2 and 3 wrapper for wkhtmltoimage utility to convert HTML to IMG using Webkit.

Warning! Version in debian/ubuntu repos have reduced functionality (because it compiled without the wkhtmltopdf QT patches), such as adding outlines, headers, footers, TOC etc. To use this options you should install static binary from wkhtmltopdf site or you can use this script.

Windows and other options:

Check wkhtmltopdf homepage for binary installers or wiki page.

Also you can pass an opened file:

If you wish to further process generated IMG, you can read it to a variable:

You can find all wkhtmltoimage options by type wkhtmltoimage command or visit this Manual. You can drop '--' in option name. If option without value, use None, False ou '' for dict value:. For repeatable options (incl. allow, cookie, custom-header, post, postfile, run-script, replace) you may use a list or a tuple. With option that need multiple values (e.g. --custom-header Authorization secret) we may use a 2-tuple (see example below).

At some headless servers, perhaps you need to install xvfb:

Então use IMGKit with option xvfb: <"xvfb": "">.

By default, IMGKit will show all wkhtmltoimage output. If you don't want it, you need to pass quiet option:

Due to wkhtmltoimage command syntax, TOC e Cover options must be specified separately. If you need cover before TOC, use cover_first option:

You can specify external CSS files when converting files or strings using css option.

You can also pass any options through meta tags in your HTML:

Each API call takes an optional config paramater. This should be an instance of imgkit.config() API call. It takes the config options as initial paramaters. The available options are:

  • wkhtmltoimage - the location of the wkhtmltoimage binary. By default imgkit will attempt to locate this using which (on UNIX type systems) or where (on Windows).
  • xvfb - the location of the xvfb-run binary. By default imgkit will attempt to locate this using which (on UNIX type systems) or where (on Windows).
  • meta_tag_prefix - the prefix for imgkit specific meta tags - by default this is imgkit-

Example - for when wkhtmltopdf or xvfb is not in $PATH :

IOError: 'No wkhtmltopdf executable found' :

Make sure that you have wkhtmltoimage in your $PATH or set via custom configuration (see preceding section). where wkhtmltoimage in Windows or which wkhtmltoimage on Linux should return actual path to binary.

IOError: 'No xvfb executable found' :

Make sure that you have xvfb-run in your $PATH or set via custom configuration (see preceding section). where xvfb in Windows or which xvfb-run ou which Xvfb on Linux should return actual path to binary.

This error means that IMGKit was unable to process an input. You can try to directly run a command from error message and see what error caused failure (on some wkhtmltoimage versions this can be cause by segmentation faults)


Exemplos

Let’s assume the program you want to execute is called “cal,” and you get a “Command not found” error message from Unix or Linux system. First, type the following command to see if you get a pathname:
$ whereis cal
Sample outputs:

If you do, you can invoke it using a full path name (e.g. /usr/bin/cal):
$ /usr/bin/cal
Sample outputs:

Or you can add the path to your PATH variable in your shell start-up file $HOME/.cshrc (csh/tcsh) or $HOME/.bashrc (bash) file, then “source” the file:
$ vi $HOME/.bashrc
Add the path as follows:

Save and close the file. Run the following source command:
$ source

/.bashrc
$ echo "$PATH"
$ cal
Finally, you can use the following find command to search for cal command get a hit about its location.
$ find / -name cal -print
Another faster option is to use the locate command:
$ locate cal
Then, invoke it using a full path name or add it to your PATH variable in your shell startup file.


Search permission is denied for one of the directories in the path prefix of path. (See also path_resolution(7).)

Too many symbolic links encountered while traversing the path. ENAMETOOLONG path is too long. ENOENT

A component of path does not exist, or path is an empty string.

Out of memory (i.e., kernel memory). ENOTDIR A component of the path prefix of path is not a directory. EOVERFLOW path ou fd refers to a file whose size, inode number, or number of blocks cannot be represented in, respectively, the types off_t, ino_t, ou blkcnt_t. This error can occur when, for example, an application compiled on a 32-bit platform without -D_FILE_OFFSET_BITS=64 calls stat() on a file whose size exceeds (1<<31)-1 bytes.


There are mainly two approaches to do that:

  • If you have to run a script, you don't convert it but rather run the script via a systemd service.

Therefore you need two files: the script and the .service file (unit configuration file).
Make sure your script is executable and the first line (the shebang) is #!/bin/sh . Then create the .service file in /etc/systemd/system (a plain text file, let's call it vgaoff.service ).
Por exemplo:

Now, edit the unit file. Its content depends on how your script works:

If vgaoff just powers off the gpu, e.g.:

then the content of vgaoff.service should be:

If vgaoff is used to power off the GPU and also to power it back on, e.g.:

then the content of vgaoff.service should be:

  • For the most trivial cases, you can do without the script and execute a certain command directly:

Once you're done with the files, enable the service:

It will start automatically on next boot. You could even enable and start the service in one go with