0byt3m1n1
Path:
/
home
/
mgatv524
/
public_html
/
sommatv
/
web
/
media
/
cache
/
0fea6a13c52b4d47
/
25368f24b045ca84
/
b8ac4316b44f99ee
/
f0cf6447439815bc
/
9d2b1ad5bbc16c44
/
d49116dc213c53f2
/
8a084cf70d891601
/
51bfe9722cb4c124
/
9c711df7a327a8d0
/
[
Home
]
File: 01c4c965842ae863.php
<?php /* Cachekey: cache/xibo/widget/ticker/b677ffb03c1611d6b0f21f4b4366713c/ */ /* Type: array */ /* Expiration: 2018-05-08T11:50:07-05:00 */ $loaded = true; $expiration = 1525798207; $data = array(); /* Child Type: array */ $data['return'] = unserialize(base64_decode('a:2:{s:8:"encoding";s:5:"UTF-8";s:3:"xml";s:141691:"<?xml version='1.0' encoding='UTF-8'?>
<rss xmlns:atom="http://www.w3.org/2005/Atom" xmlns:media="http://search.yahoo.com/mrss/" version="2.0">  <channel> <title>G1 &gt; Auto Esporte</title> <link>http://g1.globo.com/carros/index.html</link> <description>No G1 AutoEsporte você encontra as últimas notícias sobre carros e automóveis nacionais ou importados, além dos lançamentos, os preços médios na Tabela Fipe e informações sobre IPVA.</description> <language>pt-BR</language> <copyright>© Copyright Globo Comunicação e Participações S.A.</copyright> <atom:link href="http://pox.globo.com/rss/g1/carros/" rel="self" type="application/rss+xml"/> <image> <url>https://s2.glbimg.com/veNWQCjPmWVRAfzfLSJt35f_V58=/i.s3.glbimg.com/v1/AUTH_afd7a7aa13da4265ba6d93a18f8aa19e/pox/g1.png</url> <title>G1 &gt; Auto Esporte</title> <link>http://g1.globo.com/carros/index.html</link> <width>144</width> <height>144</height> </image>  <item> <title>Por mais de R$ 8 milhões, McLaren Senna tem 2 compradores no Brasil</title> <link>https://g1.globo.com/carros/noticia/por-mais-de-r-8-milhoes-mclaren-senna-tem-2-compradores-no-brasil.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/por-mais-de-r-8-milhoes-mclaren-senna-tem-2-compradores-no-brasil.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/dVOmxHP3zOGLxkILAh5RLQ88HIQ=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/2/o/DCxhZ9QE2aE4D1dZHeAw/img-6989.jpg" /><br /> ]]>  As duas únicas unidades do esportivo de 800 cv destinadas ao Brasil estão vendidas. McLaren Senna tem duas unidades vendidas no Brasil
Peter Fussy/G1
Se o seu sonho era ter uma McLaren Senna, será só de segunda mão. Isso porque as duas unidades destinadas ao Brasil já foram vendidas, por um preço que pode ultrapassar os R$ 8 milhões, segundo Henry Visconde, proprietário da Eurobike, que é importador e revendedor oficial da McLaren no Brasil.
 Os dois compradores vão para a Inglaterra nos próximos meses para configurar o esportivo, o que pode elevar o valor. Um acabamento em fibra de carbono na carroceria, por exemplo, acrescenta quase R$ 1 milhão.
Além disso, o câmbio ou uma mudança no regime automotivo podem afetar o preço. "Quando a gente fez o planejamento, a libra estava a R$ 4,20, agora está R$ 4,90. Se o governo mudar o regime, também muda tudo", afirmou Visconde.
Com produção limitada a 500 unidades, a McLaren Senna é empurrada por um V8 4.0 biturbo, que rende 800 cavalos de potência e faz o carro acelerar de 0 a 100 km/h em apenas 2,8 segundos. Atingir 200 km/h leva apenas 6,8 segundos.
Loja em São Paulo
McLaren Senna GTR é a versão mais apimentada, só para as pistas
Peter Fussy/G1
A McLaren abriu nesta terça-feira (8) sua primeira loja no Brasil, no bairro de Vila Olímpia, em São Paulo, onde foi mostrada a versão GTR da McLaren Senna, feita apenas para as pistas.
A linha de produtos disponíveis no Brasil vai desde a 570, que custa a partir de R$ 1,9 milhão, até a 720S, que ultrapassa os R$ 3 milhões - isso sem contar a Senna, que nem chegará ao showroom.
McLaren 720S na primeira loja da marca no Brasil
Peter Fussy/G1 </description>  <media:content url="https://s2.glbimg.com/dVOmxHP3zOGLxkILAh5RLQ88HIQ=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/2/o/DCxhZ9QE2aE4D1dZHeAw/img-6989.jpg" medium="image"/>  <category>G1</category> <pubDate>Tue, 08 May 2018 15:38:33 -0000</pubDate> </item>  <item> <title>Novo presidente da Volkswagen colabora com o FBI no 'dieselgate', diz jornal</title> <link>https://g1.globo.com/carros/noticia/novo-presidente-da-volkswagen-colabora-com-o-fbi-no-dieselgate-diz-jornal.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/novo-presidente-da-volkswagen-colabora-com-o-fbi-no-dieselgate-diz-jornal.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/pwVzisLohspZIJuXu6_XjkiZtQY=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/0/O/eleRV6RSWiz8gai9HBug/2018-05-08t091219z-103191591-rc1525c7cc60-rtrmadp-3-volkswagen-emissions.jpg" /><br /> ]]>  Herbert Diess, que assumiu o cargo em abril, teria dado depoimento incriminatório em troca de garantias pessoais. Herbert Diess durante conferência anual do Grupo Volkswagen na Alemanha
Axel Schmidt/Reuters
O novo presidente da Volkswagen, Herbert Diess, decidiu cooperar com a justiça americana na investigação sobre o escândalo dos motores a diesel em troca de garantias pessoais, informa a imprensa alemã.
De acordo com o jornal Bild, Herbert Diess, designado presidente da empresa em meados de abril, se reuniu nos Estados Unidos com os investigadores do FBI e do Departamento de Justiça americano.
O novo presidente deu depoimentos "que foram aparentemente incriminatórios" para Martin Winterkorn. ex-presidente do grupo, afirma o jornal, sem revelar os nomes das fontes.
Os investigadores americanos teriam prometido a Diess que ele seria avisado de modo antecipado sobre eventuais acusações ou uma eventual ordem de prisão.
Procurada pela AFP, a Volkswagen não comentou a notícia.
Indiciado em 3 de maio, Winterkorn é acusado de ter "cometido deliberadamente uma fraude", ao lado de outros executivos da Volkswagen, para burlar as normas de combate à poluição com o uso de um software nos motores dos automóveis que manipulava os resultados dos testes de emissões.
Entenda o escândalo da Volkswagen com motores a diesel
Winterkorn renunciou em setembro de 2015, após as revelações da fraude sobre as emissões de gases em veículos da companhia. 
A Volkswagen configurou até 11 milhões de veículos no mundo todo para emitir até 40 vezes acima dos níveis permitidos de óxido de nitrogênio danoso, mas ocultava isso durante as revisões.
O ex-chefão da Volkswagen é o 9º executivo processado nos EUA - dois deles se declararam culpados e cumprem pena na prisão, enquanto outros seis estão na Alemanha e se encontram na mesma situação de Winterkorn. </description>  <media:content url="https://s2.glbimg.com/pwVzisLohspZIJuXu6_XjkiZtQY=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/0/O/eleRV6RSWiz8gai9HBug/2018-05-08t091219z-103191591-rc1525c7cc60-rtrmadp-3-volkswagen-emissions.jpg" medium="image"/>  <category>G1</category> <pubDate>Tue, 08 May 2018 11:53:40 -0000</pubDate> </item>  <item> <title>CNH digital é grátis na maioria dos estados, mas é cobrada em Goiás e Piauí</title> <link>https://g1.globo.com/carros/noticia/cnh-digital-e-gratis-na-maioria-dos-estados-mas-e-cobrada-em-goias-e-piaui.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/cnh-digital-e-gratis-na-maioria-dos-estados-mas-e-cobrada-em-goias-e-piaui.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/niBsr3_9tLO1UxGcoemVmhuqxGk=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/v/N/akgwg3T7qWIvBFwCpk9Q/divulga-digital.jpg" /><br /> ]]>  Variação de preço é alta: ela custa R$ 10 em GO e mais de R$ 200 no PI. Nem todos os estados oferecem o documento: veja se o seu já tem, se há cobrança e se é aceito em blitze. CNH digital ainda não é emitida em todos os estados
Reprodução/TV Globo
Apesar de a empresa de processamento de dados do governo afirmar que a CNH digital está disponível em todo o país, nem todos os Detrans dizem estar emitindo o documento. 
Um levantamento do G1 nos estados e no DF, nas últimas duas semanas, apontou que o documento virtual ainda não é oferecido no Amapá, na Bahia, no Ceará e no Pará. Veja a situação de cada estado ao fim da reportagem.
Outra diferença está na cobrança pela versão eletrônica: a decisão cabe a cada estado. A maioria dos Detrans informou que a CNH digital é gratuita. 
Entre os que já estão emitindo, só Goiás e Piauí afirmaram que é preciso pagar. E os preços são muito diferentes: R$ 10 em GO e até R$ 222 no PI.
Esses valores são cobrados de quem já tem a CNH impressa no modelo atual, com QR-Code, que começou a ser adotado há 1 ano. Sem ela não é possível ter a versão digital.
Quem tem a CNH no modelo antigo e quiser ter a digital precisa renovar o documento físico ou pedir a segunda via (saiba mais como tirar a CNH digital).
Nesses casos, há cobrança em todos os estados pelos serviços, mas a maioria afirma que as taxas são por causa da CNH impressa. No entanto, Goiás e Piauí dizem cobrar pela CNH digital também em caso de renovação. E a Bahia informa que fará o mesmo.
Não é possível ter só a CNH digital: segundo os Detrans, o documento impresso é fundamental para a versão virtual, que usa o mesmo código.
É aceita nas blitze?
O G1 também consultou os Detrans para saber se a CNH digital está sendo aceita nas blitze e abordagens pelos agentes de trânsito. A maioria dos estados respondeu que sim, com exceção de Mato Grosso, que afirma que o "prazo para adequações" é até 1º de julho.
Foram emitidas 139 mil CNHs digitais no país até a última segunda-feira (7), de acordo com o Serviço Federal de Processamento de Dados (Serpro), que desenvolve o sistema. 
O estado que mais emitiu foi o Rio Grande do Sul, seguido por São Paulo. Mas o volume total equivale a apenas 0,23% das 58 milhões de habilitações válidas do Brasil, de acordo com dados do Departamento Nacional de Trânsito (Denatran).
O Detran-AP informou que deverá lançar a CNH digital ainda neste mês. O Ceará tem a mesma previsão. E os demais estados afirmam que estão em processo de implantação.
O prazo para que a CNH digital seja oferecida em todo o Brasil é 1º de julho, mas, no fim de abril, o Serpro disse que todos os estados já tinham aderido. Segundo a empresa, isso significa que todos estão capacitados para oferecer o documento.
Veja a situação da CNH em todos os estados e no DF:
Acre
Já está emitindo e não cobra a mais pela CNH digital; veja como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 802 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Alagoas
Já está emitindo e não cobra a mais pela CNH digital; veja como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 1.003 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Amazonas
Já está emitindo e não cobra a mais pela CNH digital; veja como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 1.341 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Amapá
Serviço será lançado ainda este mês durante a programação da campanha Maio Amarelo, porém o Detran ainda não informou a data e nem se haverá cobrança.
Apesar de o Detran-AP dizer que o serviço ainda não é oferecido, já foram emitidas 38 CNHs digitais no estado, de acordo com dados do Serpro.
Bahia
Ainda não está emitindo a CNH digital, mas já definiu que ela não será cobrada de quem já tem a CNH impressa no modelo atual (com QR code). Quem for tirar a primeira habilitação, terá de pagar R$ 95 para ter a versão digital, além do valor da impressa. A versão eletrônica também será cobrada na hora da renovação: R$ 80. 
Apesar de o Detran-BA dizer que o serviço ainda não é oferecido, já foram emitidas 368 CNHs digitais no estado, de acordo com dados do Serpro.
Ceará
Ainda não está emitindo, mas a previsão é de que comece ainda em maio, segundo o Detran. Não definiu se haverá cobrança.
Apesar de o Detran-CE dizer que o serviço ainda não é oferecido, já foram emitidas 597 CNHs digitais no estado, de acordo com dados do Serpro.
Distrito Federal
Já está emitindo e não cobra a mais pela CNH digital; veja como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 4.624 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Espírito Santo
Já está emitindo e não cobra a mais pela CNH digital; veja como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 2.199 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Goiás
Foi o primeiro estado a emitir a CNH digital, no ano passado, quando era gratuita. A partir de março, passou a cobrar R$ 10 pela versão; veja como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 19.694 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Maranhão
Já está emitindo e não cobra a mais pela CNH digital; veja como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 2.778 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Minas Gerais
Já está emitindo e não cobra a mais pela CNH digital; veja como obter. A Polícia Militar não respondeu se já aceita o documento em blitze.
Foram emitidas 7.712 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Mato Grosso
Já está emitindo e não cobra a mais pela CNH digital; veja como obter. Mas o Detran informou que os agentes de trânsito ainda não conseguem acessar o documento eletrônico e que "o prazo para adequações" é 1º de julho.
Foram emitidas 1.282 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Mato Grosso do Sul
Já está emitindo e não cobra a mais pela CNH digital; saiba como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 2.848 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Pará
O Detran-PA informou que ainda está em processo de implantação da CNH digital. Por isso, não pode adiantar informações sobre valores a serem cobrados dos usuários e como funcionará o serviço.
Apesar de o Detran-PA dizer que o serviço ainda não é oferecido, já foram emitidas 367 CNHs digitais no estado, de acordo com dados do Serpro.
Paraíba
Já está emitindo e não cobra a mais pela CNH digital; veja como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 844 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Paraná
Já está emitindo e não cobra a mais pela CNH digital; veja como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 6.939 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Pernambuco
Já está emitindo e não cobra a mais pela CNH digital; saiba como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 6.901 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Piauí
Quem quiser ter a CNH digital precisa pagar R$ 207,25, para a categoria A (motos), ou R$ 222,07, para as demais categorias. Também existe cobrança para renovar; veja como obter.
O estado tem o menor número de CNHs digitais emitidas entre os que dizem já oferecer o serviço: 100 até esta segunda (7), de acordo com o Serpro. O Detran-PI afirma que isso se deve a "inconsistência" no sistema, que foi será normalizado a partir desta terça (8).
O documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Rio de Janeiro
Já está emitindo e não cobra a mais pela CNH digital; veja como obter.
Segundo o Detran, a CNH Digital já está valendo tanto como o documento físico no Rio de Janeiro.           O Comando do Batalhão de Polícia Rodoviária (BPRv) informa que a CNH Digital será aceita "em conformidade com a legislação vigente", mas que a demanda ainda é pouca.
Foram emitidas 3.539 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Rio Grande do Norte
Já está emitindo e não cobra a mais pela CNH digital; veja como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 1.437 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Rio Grande do Sul
Já está emitindo e não cobra a mais pela CNH digital. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
O estado lidera as emissões do documento virtual no Brasil: foram 32.017 CNHs digitais até esta segunda (7), de acordo com o Serpro; veja como obter.
Rondônia
Já está emitindo e não cobra a mais pela CNH digital; saiba como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 2.919 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Roraima
Já está emitindo e não cobra a mais pela CNH digital; veja como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 398 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Santa Catarina
Já está emitindo e não cobra a mais pela CNH digital; saiba como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 9.269 CNHs digitais no estado até esta segunda (7), diz o Sepro.
Sergipe
Já está emitindo e não cobra a mais pela CNH digital; veja como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 2.658 CNHs digitais no estado até esta segunda (7), diz o Sepro.
São Paulo
Já está emitindo e não cobra a mais pela CNH digital; veja como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Dono da maior frota do país, o SP é o segundo estado que mais emitiu CNHs digitais até agora, atrás apenas do RS. Foram 25.362 até esta segunda (7), de acordo com dados do Serpro.
Tocantins
Já está emitindo e não cobra a mais pela CNH digital; saiba como obter. Documento é aceito pelos órgãos autuadores do estado, segundo o Detran.
Foram emitidas 1.063 CNHs digitais no estado até esta segunda (7), diz o Sepro. </description>  <media:content url="https://s2.glbimg.com/niBsr3_9tLO1UxGcoemVmhuqxGk=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/v/N/akgwg3T7qWIvBFwCpk9Q/divulga-digital.jpg" medium="image"/>  <category>G1</category> <pubDate>Tue, 08 May 2018 10:00:21 -0000</pubDate> </item>  <item> <title>Com mais de 32 mil pedidos, RS é o estado que mais emitiu CNHs digitais no país</title> <link>https://g1.globo.com/rs/rio-grande-do-sul/noticia/com-mais-de-32-mil-pedidos-rs-e-o-estado-que-mais-emitiu-cnhs-digitais-no-pais.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/rs/rio-grande-do-sul/noticia/com-mais-de-32-mil-pedidos-rs-e-o-estado-que-mais-emitiu-cnhs-digitais-no-pais.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/uleVZZ4OKb6eC40Myo0CV_zVM_U=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2017/i/C/ofdcsjRR2367aeeD4moA/upload-20171222121226chn-dez.jpg" /><br /> ]]>  Números foram informados pelo Serviço Federal de Processamento de Dados (Serpro), empresa pública que desenvolve o sistema. CNH digital funciona por meio de aplicativo gratuito para smartphones e tem adesão opcional. CNH digital tem o mesmo valor jurídico do documento impresso
Douglas Mafra/Detran-RS/Divulgação
O Rio Grande do Sul é o estado do Brasil em que mais Carteiras Nacionais de Habilitação (CNHs) digitais foram emitidas até a segunda-feira (7), conforme números divulgados pelo Serviço Federal de Processamento de Dados (Serpro), empresa pública que desenvolve o sistema. Foram mais de 32 mil pedidos no estado, de um total de aproximadamente 140 mil em todo o país.
De acordo com o Departamento Estadual de Trânsito (Detran-RS), o serviço de CNH digital está disponível desde o ano passado e as autoridades de trânsito aceitam o documento, desde que o aparelho no qual ela foi instalada esteja funcionando e carregado em caso de fiscalização.
A adesão é gratuita e opcional, e o aplicativo pode ser encontrado nas lojas digitais Google Play e App Store. Antes de baixar o app, o condutor deve ter um número de celular e um endereço de e-mail cadastrados na base do Departamento Nacional de Trânsito (Denatran).
Para isso, são indicadas duas opções: dirigir-se a qualquer Centro de Formação de Condutores (CFC) para atualizar os dados pessoais e fazer um cadastro no Portal de Serviços do Denatran ou, para quem possui certificação digital, comunicar todos os dados diretamente no portal do Denatran.
O Detran-RS ressalta que a habilitação digital armazena todas as informações da carteira impressa, garantindo a autenticidade do documento. Porém, o departamento salienta que a CNH digital só pode ser gerada para quem tem a última versão da CNH impressa, que conta com um QR Code – código escaneável em aparelhos eletrônicos – na parte interna. O código está disponível nos documentos de habilitação emitidos a partir de 2 de maio do ano passado.
A versão impressa continuará sendo emitida normalmente. Os valores para tirar a primeira habilitação na categoria B, que é para carros, está em R$ 2.186,66. O processo de renovação da carteira custa R$ 215,59 e para tirar segunda via é R$ 53,36.
Com a CNH digital, o condutor pode dirigir sem carregar a CNH impressa. Nesse caso, os órgãos de fiscalização salientam que os motoristas precisam ficar atentos ao funcionamento dos smartphones, porque se o aparelho estiver descarregado, por exemplo, será considerado que a CNH não está sendo portada, gerando uma infração leve, que prevê multa de R$ 88,38, três pontos na carteira e retenção do veículo até a apresentação do documento.
O Detran-RS salienta, ainda, que não é preciso ter acesso à internet no momento da fiscalização. Conforme o departamento, a CNH digital permanece disponível off-line. Basta acessar o aplicativo, digitar a senha e apresentá-la. 
A CNH digital é considerada mais segura que a impressa, porque é blindada contra falsificações e os dados do condutor são criptografados. Caso o celular tenha sido roubado, o condutor deverá entrar no site do Denatran para bloqueá-la. Se o número de telefone for alterado, o motorista deverá procurar um CFC para cadastrar o novo número. Se mantiver o mesmo número de celular, basta voltar ao site do Denatran e desbloquear.
CNH digital já está disponível no RS, saiba como usar </description>  <media:content url="https://s2.glbimg.com/uleVZZ4OKb6eC40Myo0CV_zVM_U=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2017/i/C/ofdcsjRR2367aeeD4moA/upload-20171222121226chn-dez.jpg" medium="image"/>  <category>G1</category> <pubDate>Tue, 08 May 2018 10:00:17 -0000</pubDate> </item>  <item> <title>Preço da gasolina termina a semana em leve queda, mas média segue acima de R$ 4,22, diz ANP </title> <link>https://g1.globo.com/economia/noticia/preco-da-gasolina-termina-a-semana-em-leve-queda-mas-media-segue-acima-de-r-422-diz-anp.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/economia/noticia/preco-da-gasolina-termina-a-semana-em-leve-queda-mas-media-segue-acima-de-r-422-diz-anp.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/duYj2Vh8Q0q6MtVe43a8KiHM03o=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/j/R/JvmeAQT422ZVS6ZetgGg/peticao-combuistiveis.mp4-snapshot-01.50-2018.01.18-12.37.04-.jpg" /><br /> ]]>  Já o diesel subiu pela 6ª semana seguida, enquanto o valor médio do etanol continua em queda. Após subir por duas semanas consecutivas, o preço médio da gasolina para o consumidor final teve leve queda na semana passada, mas seguiu acima do patamar de R$ 4,22. É o que apontam dados divulgados nesta segunda-feira (7) pela Agência Nacional do Petróleo, Gás Natural e Biocombustíveis (ANP). 
De acordo com o levantamento, o preço médio por litro caiu 0,02%, de R$ 4,226 para R$ 4,225. No ano, a alta acumulada do preço da gasolina para o consumidor final é de 3,07%. 
O valor representa uma média calculada pela ANP, que verifica os preços em 5.804 postos em diversos municípios. Eles, portanto, podem variar de acordo com a cidade.
Na mesma semana, a Petrobras aumentou em 0,66% os preços da gasolina nas refinarias. O reajuste faz parte da política de preços da empresa, que muda os valores quase diariamente com o objetivo de acompanhar as cotações internacionais. O repasse ou não para o consumidor final depende dos postos. 
Diesel sobe pela 6ª semana seguida
A ANP também divulga o valor médio por litro do diesel para o consumidor final, que fechou a semana em R$ 3,495. Isso representa um aumento de 0,69% em relação à semana anterior. A alta foi a sexta seguida registrada pela agência. Nesse período, o preço já subiu 3,46%. 
Na mesma semana, a Petrobras reajustou os valores do diesel nas refinarias para baixo em 0,29%. Da mesma maneira que ocorre com a gasolina, o repasse ou não para o consumidor final depende dos postos. 
No ano, o preço do diese já acumula alta de mais de 5%.
Preço gasolina combustíveis Uberaba
Reprodução/TV Integração
Etanol em queda
Enquanto isso, o etanol terminou a semana em baixa pela quarta semana seguida, passando para R$ 2,853 por litro. A baixa foi de 1,38%. 
Quatro semanas, o preço do etanol caiu mais de 6%. No ano, a queda acumulada é de mais de 2%. 
Já o preço do botijão de gás subiu 0,07% na semana, passando para R$ 66,97. No ano, porém, há baixa acumulada de 0,65%.  </description>  <media:content url="https://s2.glbimg.com/duYj2Vh8Q0q6MtVe43a8KiHM03o=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/j/R/JvmeAQT422ZVS6ZetgGg/peticao-combuistiveis.mp4-snapshot-01.50-2018.01.18-12.37.04-.jpg" medium="image"/>  <category>G1</category> <pubDate>Mon, 07 May 2018 22:28:15 -0000</pubDate> </item>  <item> <title>Para todos os terrenos, Amarok V6 une força e tecnologia</title> <link>https://g1.globo.com/carros/especial-publicitario/amarok-v6/noticia/para-todos-os-terrenos-amarok-v6-une-forca-e-tecnologia.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/especial-publicitario/amarok-v6/noticia/para-todos-os-terrenos-amarok-v6-une-forca-e-tecnologia.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/61K19owVSMTqbi_Z0FoJ9PRwWgY=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/i/6/SbAaDTRmeJorqzEKeaOw/foto-amarok.jpg" /><br /> ]]>  Pickup da Volkswagen ganha motor com mais torque e potência da categoria. Força, segurança e inovação são as marcas da Amarok V6
Divulgação
O que uma pickup deve ter para ser a melhor escolha do segmento? Força, segurança, inovação e conectividade provavelmente estarão no topo da lista. Todos esses itens estão presentes na Volkswagen Amarok e fizeram dela uma das principais no mercado brasileiro. Agora, junto deles, a versão V6 da camionete torna-se a mais potente e com maior torque, em uma combinação de força com inteligência para quem precisa dela para trabalhos pesados ou no dia a dia.
Pickups são feitas para superar desafios, enfrentar terrenos fora do comum e carregar peso. E para conseguir enfrentar o trabalho pesado é fundamental um motor que garante alta performance. E esse é um dos primeiros destaques da Amarok, da Volkswagen, que conta com o motor 3.0 V6 TDI. Com ele, o veículo atinge incríveis 225 cv e 550 Nm, que fazem dela a mais potente e com maior torque da categoria. 
Para se ter uma ideia, a Amarok V6 consegue números só comparáveis aos de carros esportivos, como a aceleração de 0 a 100 km/h em 8 segundos. Contribui para isso o sistema Overboost do motor Turbo TGV, que eleva a potência e aumenta a curva de torque. A pickup chega ainda com uma nova transmissão automática, exclusiva na categoria, com oito velocidades e três opções de condução, para trocas suaves e perfeito gerenciamento e escala de marchas. Isso tudo, aliado à tração 4x4 4Motion permanente, proporciona mais aderência ao solo e melhor arraste relativo entre os eixos, o que evita o escorregamento nas curvas.
Motor V6 faz da pickup a mais potente da categoria
Divulgação
Segurança em todos os terrenos
Passar por terrenos escorregadios, como de terra ou cascalho, faz parte do dia a dia de muitos donos de pickups e isso exige, além de força, segurança. Para isso a Amarok V6 Highline conta com sistema de frenagem ABS off-road, que garante tranquilidade nesse tipo de piso, utilizando o próprio acúmulo de terra à frente dos pneus para otimizar a distância de frenagem, evitando o comum deslizamento do ABS convencional em terrenos não pavimentados.
O motorista tem ainda disponíveis o Controle de Estabilidade (ESC), Controle Eletrônico do Diferencial (EDS), Controle de Tração (TCS), Assistente de Frenagem Hidráulico (BAS), Assistente de Partida em Rampas (HSA) e Assistente de Descidas (HDC). Além disso, há o freio pós-colisão (Post Collision Brake), que evita batidas secundárias em caso de acidente, combinados com quatro airbags dianteiros.
Pickup tem força para encarar diferentes pisos e desafios
Divulgação
Tecnologia para encarar desafios
A tecnologia é outra aliada da Amarok para enfrentar o trabalho pesado. O sistema de Infotainment Discover Media da Volkswagen, por exemplo, oferece o Display Off-Road para o condutor, que consegue acessar diversos indicadores úteis de forma digital, como informações de bússola, ângulo de direção das rodas e altímetro.
O sistema Discover Media touchscreen permite acessar o Park Pilot, um complemento da câmera de ré que torna mais fácil o estacionamento. A Amarok oferece ainda alta conectividade através do APP-Connect, tecnologia que permite fazer e receber chamadas por comando de voz, acessar apps como Spotify e agrega tecnologias como Mirror Link, para smartphones que utilizam Android 5.0 ou superior, além de dar acesso ao Apple CarPlay e Android Auto.
Design impõe respeito
Apesar de ser um veículo robusto, a Amarok V6 tem design ao mesmo tempo imponente, moderno e elegante. Seu conjunto frontal é formado pela grade cromada que leva o badge V6, que impõe respeito. Há ainda detalhes como os retrovisores em preto brilhante e acabamento parcialmente cromado.
Por dentro o destaque é a pegada refinada e o conforto para os ocupantes. Os bancos da Amarok estabelecem um novo patamar na categoria, com sistema que oferece muito conforto, com o exclusivo certificado ergoComfort, do instituto AGR, da Alemanha. O ajuste elétrico de 12 vias disponível nos bancos frontais garante precisão milimétrica. 
Gostou? Veja mais da Amarok V6 aqui. </description>  <media:content url="https://s2.glbimg.com/61K19owVSMTqbi_Z0FoJ9PRwWgY=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/i/6/SbAaDTRmeJorqzEKeaOw/foto-amarok.jpg" medium="image"/>  <category>G1</category> <pubDate>Mon, 07 May 2018 20:52:24 -0000</pubDate> </item>  <item> <title>Com motor V6 de 225 cavalos, Amarok é a pickup mais potente da categoria </title> <link>https://g1.globo.com/carros/especial-publicitario/amarok-v6/noticia/com-motor-v6-de-225-cavalos-amarok-e-a-pickup-mais-potente-da-categoria.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/especial-publicitario/amarok-v6/noticia/com-motor-v6-de-225-cavalos-amarok-e-a-pickup-mais-potente-da-categoria.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/4R3-T-iZsv9WXJNMfKZp3x1bD1A=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/E/Y/go7GKYSYS6MFoffap9xw/2614.jpg" /><br /> ]]>  Com números impressionantes, desempenho garante boa rodagem on e off-road. Novo motor V6 garante desempenho comparável ao de carros esportivos para a pickup
Divulgação
A Volkswagen Amarok já era a pickup mais segura e inovadora da categoria. Agora, na versão Highline V6, ela é também a mais forte, com um novo motor de 3 litros de cilindrada de última geração. Com um aumento significativo em torque e cavalos, a camionete ganha mais potência e desempenho.
Os números do motor V6 3.0 TDI da Amarok impressionam. Para começar, ela tem um desempenho próximo a de carros esportivos, fazendo de 0 a 100 km/h em 8 segundos. Isso é possível graças ao torque impressionante de 550 Nm (56,1 kgfm) a partir dos 1.500 rpm, que é ideal para situações on e off-road, e se mantém assim até os 3.000 rpm.
Outro número que chama atenção são os 225 cv, disponível no veículo numa faixa ampla de rpm, entre 3.000 e 4.500. Mesmo se comparado a outros motores eficientes, ele apresenta vantagens, com um ganho de 25% em potência e de 31% no torque, até em baixo regime de giro, o que garante excelente desempenho em qualquer terreno. Mesmo com isso tudo, a pickup apresenta ótima eficiência energética, graças aos circuitos independentes de refrigeração para o cabeçote e para o bloco do motor.
Turbo variável, 4x4 e transmissão de 8 velocidades melhoram o desempenho em asfalto e terrenos irregulares 
Divulgação
Turbo aumenta o desempenho do motor
Esse motorzão da pickup conta com um sistema Turbo TGV, de geometria variável, com a função Overboost. Graças a ele o motor entrega alto torque em baixas rotações e potência em altas rotações, sempre que o motorista precisa. O acionamento eletrônico garante um melhor gerenciamento da pressão da turbina, o que aumenta o desempenho.
Disponível entre 50 e 120 km/h, a função Overboost pode funcionar até os 140 km/h em situações especiais. Mas o que isso oferece de ganhos ao veículo? A função eleva a potência da Amarok em mais 20 cv e aumenta a curva de torque de 30 a 40 Nm (3,06 a 4,08 kgfm). Isso tudo é gradativo, o que evita flutuações repentinas.
4x4 o tempo todo
Um motor com tanto torque precisa de um sistema de transmissão que consiga lidar com ele. Para isso, a Amarok V6 ganhou a transmissão mais inteligente da categoria: a AL550 automática de 8 velocidades, com três opções de condução. O 4x4 conta com a avançada tecnologia 4Motion, que faz com que ela ofereça tração nas quatro rodas de forma permanente com o câmbio automático. Entre as vantagens disso estão maior aderência e segurança em estradas asfaltadas, e mais facilidade para enfrentar os terrenos irregulares, já que transfere ao solo o torque necessário para as tarefas mais pesadas.
A Amarok Highline V6 é a pickup mais forte da categoria e conta com visual imponente e moderno, conforto para motorista e passageiros e diversos itens de tecnologia. Ela recebeu o prêmio International Pickup Award 2018, sendo a única a levá-lo pela segunda vez. O júri a considerou a síntese do conceito work hard, play hard (trabalhe duro, jogue duro), com destaque para o design, acabamento, tamanho da cabine dupla e os bancos ergoComfort.
Gostou? Veja mais da Amarok V6 aqui. </description>  <media:content url="https://s2.glbimg.com/4R3-T-iZsv9WXJNMfKZp3x1bD1A=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/E/Y/go7GKYSYS6MFoffap9xw/2614.jpg" medium="image"/>  <category>G1</category> <pubDate>Mon, 07 May 2018 20:46:41 -0000</pubDate> </item>  <item> <title>Novo City une tudo o que você gosta em um sedã</title> <link>https://g1.globo.com/carros/especial-publicitario/novo-honda-city/noticia/novo-city-une-tudo-o-que-voce-gosta-em-um-seda.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/especial-publicitario/novo-honda-city/noticia/novo-city-une-tudo-o-que-voce-gosta-em-um-seda.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/4aKUkA7YaEdlZrK1zSA8bp3Ui8A=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/s/t/ARRBklQ8uamhsRmm1yAA/materia.jpg" /><br /> ]]>   Carro da Honda recebeu novos equipamentos, design e tecnologia para o dia a dia e viagens.  Novo City está mais versátil para quem gosta de pegar a estrada e para quem roda muito nas cidades
Divulgação
Dirigir até o trabalho durante a semana e pegar a estrada nas férias para curtir com a família, tudo no mesmo carro. Foi com o pensamento na versatilidade que a Honda repaginou o City. Na sua versão 2018, ele ganhou novidades e tornou-se um sedã com tudo o que você gosta.
No design, o modelo já mostra algumas das mudanças. O Novo City conta com faróis alto e baixo e luzes de rodagem diurna em LED – também presente nas lanternas traseiras e nos indicadores de direção –, que destacam o visual diferenciado e ainda reforçam a visibilidade e segurança. Na dianteira, eles são integrados com a nova grade frontal cromada e os para-choques mais robustos, com uma pegada de esportividade e sofisticação.
O acabamento refinado é um dos destaques do interior do sedã, feito para os motoristas mais exigentes. Detalhes cromados nas portas e no painel, revestimento em couro no apoio para os braços, nos bancos e no volante agregam sofisticação ao City. O multimídia adiciona modernidade, com tela de 7” multi-touchscreen com interfaces Android Auto™ e Apple Carplay® que permite espelhamento de smartphones Android e iOS. O motorista tem acesso a câmera de marcha a ré, GPS, Bluetooth® e ainda conta com comandos integrados no volante.
Conforto e segurança ao dirigir
O Novo City adiciona também uma série de itens para o conforto e a segurança. A direção elétrica progressiva, por exemplo, oferece uma condução mais macia e precisa. O sistema de transmissão automática do tipo CVT (continuamente variável) garante uma condução linear aliada a um menor consumo de combustível ou se você preferir utilize também as aletas no volante (Paddle Shifts) que simulam a troca de sete velocidades para uma condução mais esportiva. Já o piloto automático (Cruise Control, presente nos modelos anteriores) garante comodidade ao manter a aceleração até a velocidade ideal.
Para sua total proteção, o modelo possui ainda a câmera de marcha a ré multivisão: normal, angular ou de cima para baixo, com guias de referência; seis airbags (frontais, laterais e de cortina); freios ABS, com ajuste eletrônico de força para cada roda (EBD) e estrutura de deformação progressiva ACE™ (Advanced Compatibility Engineering). 
Escolhido o Melhor Sedã Pequeno na Eleição dos Melhores Carros do Best Cars, foi eleito também o sedã compacto com Maior Valor de Revenda pela Agência Autoinforme, em 2017. O modelo tem versões a partir de R$ 60.900.  Veja mais no infográfico abaixo.
Novo Honda City
Infográfico
Apple Carplay® é uma marca comercial da Apple Inc.
Android Auto™ é uma marca comercial da Google Inc. </description>  <media:content url="https://s2.glbimg.com/4aKUkA7YaEdlZrK1zSA8bp3Ui8A=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/s/t/ARRBklQ8uamhsRmm1yAA/materia.jpg" medium="image"/>  <category>G1</category> <pubDate>Mon, 07 May 2018 19:18:48 -0000</pubDate> </item>  <item> <title>Nova limusine presidencial da Rússia é mostrada na posse de Putin</title> <link>https://g1.globo.com/carros/noticia/nova-limusine-presidencial-da-russia-e-mostrada-na-posse-de-putin.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/nova-limusine-presidencial-da-russia-e-mostrada-na-posse-de-putin.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/bcmpDGZBHLYnwerzMYQ8mz1DILQ=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/c/K/kp4SF5TRuWBIxm5k19EA/2018-05-07t140857z-980392033-rc16f20a8fa0-rtrmadp-3-russia-putin-limousine.jpg" /><br /> ]]>  Modelo foi criado no país, e irá substituir o Classe S, da Mercedes-Benz. Desenvolvimento custou o equivalente a R$ 675 milhões.  Putin ganha nova limusine presidencial, criada na Rússia
Durante cerimônia de posse nesta segunda-feira (7), presidente russo circulou em uma nova limusine com design exclusivamente russo. Desenvolvimento do veículo custou nada menos que 12 bilhões de rublos (R$ 675 milhões).
O dia da posse é um grande momento para qualquer chefe de Estado, e, para o russo Vladimir Putin, que assumiu a presidência pela quarta vez nesta segunda-feira (7), não foi exceção. Além de realizar um discurso à nação e agradecer pelo apoio, Putin exibiu uma novidade – uma limusine presidencial criada especialmente para ele.
Novo carro oficial do presidente russo, Vladimir Putin
Sergei Guneev/Reuters
Ao sair do Edifício 1 do Kremlin, o presidente sentou-se no sedã preto que o acompanhou até o Grande Palácio do Kremlin, onde aconteceu a cerimonia de posse.
O novo carro presidencial, concebido como parte do projeto "Kortej" (Caravana), foi totalmente projetado e produzido na Rússia. 
Putin, que antes usava um Mercedes durante compromissos oficiais, decidiu desta vez mudar para carros nacionais – o Kortej está em desenvolvimento desde 2013 na empresa russa Nami. Segundo fontes do jornal “Kommersant”, o desenvolvimento do veículo custou 12 bilhões de rublos (R$ 675 milhões).
Novo carro oficial de Vladimir Putin, feito na Rússia, e seu antecessor, um Mercedes-Benz Classe S
Sergei Savostyanov/Reuters
“O veículo passou em todos os testes necessários e está provado que é seguro para o chefe de Estado”, declararam autoridades à agência de notícias Tass. Espera-se agora que os veículos desenvolvidos no projeto Kortej (sua marca exata ainda sem nome) substituam os automóveis estrangeiros na frota de veículos do Estado.
Em setembro de 2018, versões comerciais do carro também estarão à venda ao público, segundo as autoridades. A estimativa é que a versão comercial da limusine seja vendida por aproximadamente 10 milhões de rublos (R$ 563 mil).
Recentemente, a Nami anunciou que produzirá vários modelos de Aurus (Aurum + Russia, nome oficial da linha de veículos premium): limusine, sedã, SUV e minivan. </description>  <media:content url="https://s2.glbimg.com/bcmpDGZBHLYnwerzMYQ8mz1DILQ=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/c/K/kp4SF5TRuWBIxm5k19EA/2018-05-07t140857z-980392033-rc16f20a8fa0-rtrmadp-3-russia-putin-limousine.jpg" medium="image"/>  <category>G1</category> <pubDate>Mon, 07 May 2018 18:52:50 -0000</pubDate> </item>  <item> <title>CNH Digital é emitida de graça do ES; veja como obter </title> <link>https://g1.globo.com/es/espirito-santo/noticia/cnh-digital-e-emitida-de-graca-do-es-veja-como-obter.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/es/espirito-santo/noticia/cnh-digital-e-emitida-de-graca-do-es-veja-como-obter.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/xy6L0paE8Fu3v0pdu48XuOifZTk=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/A/F/AZ2clHTIaiyCBzkR5HhQ/img-0516.jpg" /><br /> ]]>  Carteira de habilitação eletrônica vai ter o mesmo valor jurídico da impressa, que continuará sendo emitida. Órgãos autuadores do Estado já aceitam versão digital em blitze e abordagens.  CNH Digital terá mesma validade jurídica da carteira de habilitação impressa
Adneison Severiano/G1 
Disponível para os condutores capixabas desde janeiro deste ano, a versão eletrônica da Carteira Nacional de Habilitação já é emitida gratuitamente no Espírito Santo. De 18 de janeiro a 31 de abril, 2002 documentos digitais foram registrados no estado, segundo o Departamento Estadual de Trânsito do Espírito Santo (Detran-ES).
Para solicitar a CNH Digital , o condutor precisa ter na habilitação impressa o QR Code, que consta nas carteiras emitidas pelo Detran-ES desde maio de 2017.
O Detran-ES explica que a versão digital do documento de habilitação é opcional. Caso o condutor ainda não tenha a CNH com o QR Code e queira ter o documento no formato digital, ele precisa antecipar a renovação ou solicitar uma segunda via.  Nestes casos, o usuário terá que pagar as taxas conforme valores abaixo:
Processo de renovação
Taxa para só CNH física – R$ 183,27 de taxa de serviço do Detran-ES, R$ 85,09 do exame médico e R$ 101,45 de exame psicológico (somente no caso de condutor profissional);
Taxa para só CNH digital – gratuito; 
Taxa CNH digital + física – mesmo valor do processo para obter a CNH física (R$ 268,35 ou R$ 369,80 para condutor profissional). 
Processo de segunda via
Taxa para só CNH física – R$ 179,99 em caso de perda ou dano (a solicitação pode ser feita de forma online no site www.detran.es.gov.br). Em caso de roubo ou furto, o usuário pode solicitar a segunda via do documento sem custos apresentando o Boletim de Ocorrência, documento pessoal e comprovante de endereço na unidade do órgão de seu município;
Taxa para só CNH digital – gratuito;
Taxa CNH digital + física – mesmo valor do processo para obter a CNH física (R$ 179,99 em caso de perda ou dano e gratuito em caso de roubo ou furto).
No caso da 1ª habilitação, os valores são os seguintes:
Taxa para só CNH física – R$ 353,44 de taxa do Detran-ES para somente uma categoria e R$ 441,80 para categoria AB, R$ 85,09 do exame médico e R$ 101,45 de exame psicológico;
Taxa para CNH digital – gratuito;
Taxa CNH digital + física – mesmo valor do processo para obter a permissão física (R$539,98 somente uma categoria e R$ 628,34 para categoria AB).
A versão impressa continua sendo emitida normalmente, mas agora o condutor poderá optar por dirigir apenas com a CNH digital.  Nesse caso, deverá atentar para o funcionamento de seu smartphone, já que, para efeitos de fiscalização, se o aparelho estiver descarregado, será considerado que a CNH não está sendo portada.
O motorista será autuado com base no artigo 232, que diz que conduzir veículo sem os documentos de porte obrigatório é uma infração leve, com multa de R$ 88,38, três pontos na CNH e retenção do veículo até a apresentação do documento.  
Órgãos autuadores 
A Polícia Rodoviária Federal (PRF) e a Polícia Militar já podem acessar a CNH Digital em abordagens e blitze. Para isso, é necessário que o condutor apresente o documento digitalizado na hora da abordagem. 
Como obter?
O serviço funciona por meio de um aplicativo gratuito, que pode ser baixado pela Google Play Store e pela App Store.
Antes de baixar o aplicativo, o condutor deve ter um número de celular e um endereço de e-mail cadastrados na base do Denatran. Para isso, é preciso realizar um cadastro no Portal de Serviços do Denatran www.portalservicos.denatran.serpro.gov.br.  
Caso as informações estejam incompletas, o usuário deverá enviar um e-mail para cnhdigitales@detran.es.gov.br, informando o número de telefone celular, com DDD 27 ou 28, um endereço de e-mail e uma cópia anexa da última CNH impressa. O Detran-ES atualizará os dados para que o cadastro seja finalizado.
A CNH-e é acessível offline, sem necessidade de conexão wi-fi ou dados móveis habilitados.
Passo a passo
Para quem tem a CNH com QR Code:
1- Se possuir um certificado digital (*), pode acessar o Portal de Serviços do Denatran e cadastrar os dados.
2- Se não possuir um certificado digital (*) e o e-mail e o telefone celular não estejam atualizados no cadastro da habilitação, o condutor deverá enviar um email para cnhdigitales@detran.es.gov.br, solicitar a inclusão ou atualização desses dados e depois acessar o Portal de Serviços do Denatran e cadastrar os dados.
3- Após o cadastro ser efetuado no Portal de Serviços do Denatran, ir ao Menu “CNH Digital” e clicar em “Ativação”, para receber um e-mail com o código de validação.
4- Baixar o aplicativo “CNH Digital”. O primeiro acesso será com o código de autenticação/validação, para gerar uma nova senha com quatro dígitos.
Para quem tem a CNH sem QR Code:
1- Caso a CNH tenha sido emitida antes de 02 de maio de 2017, o condutor deverá requerer uma nova via da CNH impressa, com custos, atualizando o número de celular e endereço de e-mail.
2- Acessar o Portal de Serviços do Denatran e cadastrar seus dados.
3- Após o cadastro ser efetuado no Portal de Serviços do Denatran, ir para o “Menu CNH Digital”, em seguida clicar em “Ativação” e irá receber o e-mail com o código de autenticação/validação.
(*) Certificado digital com validade jurídica, equivalente a assinatura de próprio punho. O certificado para assinatura digital de documentos pode ser adquirido através de uma Autoridade de Certificação (AC) vinculada ao ICP Brasil. Exemplos de ACs vinculadas habilitadas: Secretaria da Receita Federal, Serasa, Certisign, Caixa Econômica, Presidência da República. Não é obrigatório a aquisição </description>  <media:content url="https://s2.glbimg.com/xy6L0paE8Fu3v0pdu48XuOifZTk=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/A/F/AZ2clHTIaiyCBzkR5HhQ/img-0516.jpg" medium="image"/>  <category>G1</category> <pubDate>Mon, 07 May 2018 18:44:43 -0000</pubDate> </item>  <item> <title>Controles de estabilidade e tração garantem segurança no Fiat Cronos</title> <link>https://g1.globo.com/carros/especial-publicitario/fiat-cronos/noticia/controles-de-estabilidade-e-tracao-garantem-seguranca-no-fiat-cronos.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/especial-publicitario/fiat-cronos/noticia/controles-de-estabilidade-e-tracao-garantem-seguranca-no-fiat-cronos.ghtml</guid> <description>  Sedã conta com diversos itens para manter a tranquilidade durante a condução. Essencial para qualquer carro, a segurança é um dos pontos fortes do Fiat Cronos. Ele é equipado com uma série de recursos para que motorista e passageiros tenham uma viagem tranquila, seja no dia a dia ou em longos percursos.
Os controles de estabilidade e de tração são dois dos principais elementos nesse quesito. Eles garantem que ao fazer uma manobra mais brusca, seja para desviar de um outro veículo, um buraco ou algo que pode representar uma ameaça, seja mantida a estabilidade do carro, além de acionar os freios ou reduzir o torque do motor.
Os airbags também reforçam a segurança, com dois frontais e dois laterais. Para quem tem crianças, o sedã conta com dois itens muito importantes. Um é o sistema Isofix, que proporciona o encaixe rápido de cadeirinhas infantis no banco traseiro. O outro é o sensor de obstáculo dos vidros elétricos, que interrompe e inverte o movimento de fechamento, caso algo seja colocado sobre o vidro, como um braço, por exemplo.
Com design sensual e robusto, o Fiat Cronos é um sedã com pegada esportiva, inspirado nos italianos. O carro conta ainda com Central Multimídia, Hill Holder, sistema que auxilia em partidas em aclives, espelho retrovisor com efeito tilt down, amplo porta-malas, entre outros elementos.
Veja mais detalhes no vídeo:
Controles de estabilidade e tração garantem segurança no Fiat Cronos </description>  <category>G1</category> <pubDate>Mon, 07 May 2018 15:44:52 -0000</pubDate> </item>  <item> <title>Produção de veículos no Brasil sobe 40% em abril, diz Anfavea</title> <link>https://g1.globo.com/carros/noticia/producao-de-veiculos-no-brasil-sobe-40-em-abril-diz-anfavea.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/producao-de-veiculos-no-brasil-sobe-40-em-abril-diz-anfavea.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/lOuttyN2t9T7AUzT_XfBFyGPMK8=/s.glbimg.com/jo/g1/f/original/2016/06/14/jlr_itatiaia_4.jpg" /><br /> ]]>  Comparação é com o mesmo mês do ano passado. Em 4 meses, quase 1 milhão de unidades saíram das fábricas instaladas no país. Vendas e produção de veículos voltam a crescer em abril
A produção de veículos no Brasil subiu 40% em abril, na comparação com o mesmo período do ano passado, afirmou nesta segunda-feira (7) a associação das montadoras (Anfavea).
Foram 266.111 automóveis, comerciais leves, caminhões e ônibus feitos em abril, enquanto no mesmo mês de 2017 foram 189.487 unidades.
No acumulado de janeiro a abril, a indústria automotiva acelerou 20,7%, já chegando perto do primeiro milhão de unidades em quatro meses. 
Saíram das fábricas 965.865 unidades, contra 800 mil no mesmo período de 2017. O total ainda é levemente inferior à média dos últimos 10 anos para os quatro primeiros meses: 975 mil.
Exportações em alta
Um em cada quatro veículos feitos por aqui não ficou no país. Segundo a Anfavea, 253 mil unidades foram exportadas de janeiro a abril, o que representa alta de 7,5% sobre o resultado recorde do ano passado.
As vendas internas somaram 763 mil - um avanço de 21% em relação ao mesmo período de 2017. Mesmo com o salto, o volume de emplacamentos no país ainda está abaixo da média dos últimos 10 anos, de 951 mil unidades.
Fábrica de carros em Itatiaia, RJ
Divulgação
Com a recuperação ajudada pelas exportações, o nível de emprego no setor automotivo voltou a crescer. Em 1 ano, o número de empregados diretamente cresceu 4,1%, de 126,5 mil para 131,7 mil.
Expectativas mantidas
As montadoras esperam fechar 2018 com alta de 13,2% na produção, com pouco mais de 3 milhões de veículos. As vendas no Brasil devem crescer 11,7%, para 2,5 milhões, e as exportações baterão um novo recorde, com 800 mil unidades no total, de acordo com as projeções da Anfavea.
Produção de veículos sobe 40% em abril e tem efeito positivos sobre outras indústrias </description>  <media:content url="https://s2.glbimg.com/lOuttyN2t9T7AUzT_XfBFyGPMK8=/s.glbimg.com/jo/g1/f/original/2016/06/14/jlr_itatiaia_4.jpg" medium="image"/>  <category>G1</category> <pubDate>Mon, 07 May 2018 14:39:06 -0000</pubDate> </item>  <item> <title>Audi A4 tem recall no Brasil para troca do para-brisa</title> <link>https://g1.globo.com/carros/noticia/audi-a4-tem-recall-no-brasil-para-troca-do-para-brisa.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/audi-a4-tem-recall-no-brasil-para-troca-do-para-brisa.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/u0wVnotfMGZEkNH50QLxq4rca7E=/s.glbimg.com/jo/g1/f/original/2016/04/06/lgiox5vc.jpg" /><br /> ]]>  Baixa aderência da cola do para-brisa pode afetar a eficácia do airbag em caso de acidente. Novo Audi A4
Luciana de Oliveira / G1
A Audi do Brasil anunciou nesta segunda-feira (7) um recall de 12 unidades do A4, ano/modelo 2018, por causa de um problema na fixação do vidro para-brisa dianteiro.
CHASSIS ENVOLVIDOS
A4 Sedan 2.0 - WAU_F4_JA051576 a WAU_F4_JA051740
A4 Avant 2.0 - WAU_F4_JA051934
Segundo a fabricante, devido à baixa aderência da cola usada no para-brisa, ele pode apresentar pontos de descolamento.
Em caso de acidente, isso pode afetar até a eficácia do airbag dianteiro do passageiro.
A Audi substituirá gratuitamente o para-brisa, o que deve lecar cerca de 5 horas.
Os proprietários devem entrar em contato com um concessionária da marca. Mais informações podem ser obtidas por meio do telefone 0800-7772834. </description>  <media:content url="https://s2.glbimg.com/u0wVnotfMGZEkNH50QLxq4rca7E=/s.glbimg.com/jo/g1/f/original/2016/04/06/lgiox5vc.jpg" medium="image"/>  <category>G1</category> <pubDate>Mon, 07 May 2018 13:07:43 -0000</pubDate> </item>  <item> <title>Nissan diz que acabará gradualmente com o diesel na Europa</title> <link>https://g1.globo.com/carros/noticia/nissan-diz-que-acabara-gradualmente-com-o-diesel-na-europa.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/nissan-diz-que-acabara-gradualmente-com-o-diesel-na-europa.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/f2PbDXFQhI400J5kEpY6f3O2Vpo=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/H/n/lYAXqiSM2aVdPQ4PMygA/nissan-sylphy-reu.jpg" /><br /> ]]>  Modelos a diesel não devem ser renovados nas próximas gerações e darão lugar a versões elétricas ou híbridas. Nissan lança versão elétrica do Setra, chamado Sylphy no mercado chinês, no Salão de Pequim 2018
Jason Lee/Reuters
A Nissan Motor retirará "gradualmente" do mercado europeu os carros de passeio movidos a diesel como parte da estratégia de eletrificação de seus modelos, confirmou nesta segunda-feira (7) um porta-voz da companhia.
Na Europa, onde se concentram as vendas de diesel da Nissan, a estratégia de eletrificação adotada pela companhia lhe permitirá "suprimir gradualmente o diesel dos veículos de passageiros no momento da renovação de cada veículo", explicou a fabricante.
"Neste momento não temos prazos específicos para a retirada, nem um anúncio oficial, levando em conta o ciclo de vida de cerca de 7 a 8 anos dos produtos automobilísticos, isto significa que alguns projetos importantes para certos modelos serão apresentados durante os próximos anos", acrescentou a Nissan.
A fabricante japonesa afirmou também que "as normas e padrões são um aspecto-chave no planejamento de produtos" e, neste sentido, disse que se está levando em conta a entrada em vigor em 2021 da mais estrita norma de emissões Euro 6d.
Com sua retirada do mercado europeu do diesel, a Nissan se unirá a outros fabricantes japoneses que optaram por isso diante da cada vez mais restrita lei ambiental europeia e o aumento da demanda por modelos que respeitam o meio ambiente.
Entre eles está a Toyota, que confirmou que deixará de vender os seus motores diesel na Europa no final deste ano devido à "forte demanda por parte dos seus clientes das versões híbridas que deve pôr fim às vendas de automóveis diesel na Europa e na Austrália por volta de 2020.
A Nissan traçou como meta aumentar as vendas de carros elétricos nos próximos anos e chegar em 2022 a comercializar um milhão de unidades ao ano em nível mundial.  </description>  <media:content url="https://s2.glbimg.com/f2PbDXFQhI400J5kEpY6f3O2Vpo=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/H/n/lYAXqiSM2aVdPQ4PMygA/nissan-sylphy-reu.jpg" medium="image"/>  <category>G1</category> <pubDate>Mon, 07 May 2018 12:22:49 -0000</pubDate> </item>  <item> <title>Presidente da Tesla foge de perguntas de analistas e depois se arrepende: 'Foi tolice'</title> <link>https://g1.globo.com/carros/noticia/presidente-da-tesla-foge-de-perguntas-de-analistas-e-depois-se-arrepende-foi-tolice.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/presidente-da-tesla-foge-de-perguntas-de-analistas-e-depois-se-arrepende-foi-tolice.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/nAatS0Fz4uQo-qmctn3TedGdSUo=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/y/y/GTXt3aQomKev7TFJS3Dw/2018-05-03t000427z-1529633911-rc1ed05e9750-rtrmadp-3-tesla-results.jpg" /><br /> ]]>  A atitude irritou Wall Street e fez com que as ações da Tesla caíssem no dia seguinte.  Elon Musk em conferência de imprensa em fevereiro de 2018
Joe Skipper/Reuters
O presidente-executivo da Tesla, Elon Musk, disse que foi "insensato" de sua parte desprezar os analistas de Wall Street em uma teleconferência depois da divulgação dos resultados da empresa na semana passada.
Na teleconferência, realizada quarta-feira (2), Musk desprezou questionamentos sobre a operação da empresa feitos por Joseph Spak, da RBC Capital Markets, e Toni Sacconaghi, de Bernstein.
Ele foi questionado sobre as reservas relacionadas ao sedã Model 3 e se a empresa precisará de mais dinheiro para continuar operando.
"Eu deveria ter respondido suas perguntas ao vivo. Foi tolice da minha parte ignorá-las", escreveu Musk em um tuíte.
O executivo disse que "perguntas chatas e idiotas não são legais" e passou a responder um investidor pouco conhecido, que administra o canal de investimento do YouTube.
Initial plugin text
A atitude irritou Wall Street e fez com que as ações da Tesla caíssem 5% no dia seguinte. 
"As perguntas 'secas' não foram feitas por investidores, mas sim por dois analistas que estavam tentando justificar sua posição de venda para a Tesla. Eles estão realmente do lado oposto dos investidores", Musk tuíte na sexta-feira. 
No entanto, os dois analistas têm classificações neutras sobre as ações, não de venda, de acordo com dados da Thomson Reuters.
"A HyperChange representava os investidores reais, então eu mudei para eles", escrevei Musk escreveu em outro tuíte. Ele dedicou 23 minutos ao investidor de 25 anos Galileo Russell, que dirige a HyperChange TV.
Fábrica da Tesla na Califórnia, EUA
Noah Berger/Reuters
A estranha teleconferência rendeu comentários contundentes de analistas e pelo menos três corretoras cortaram os preços-alvo para as ações da empresas.
"Embora as consequências sejam inquantificáveis, acreditamos que o presidente-executivo da Tesla cometeu um erro ao se recusar a responder algumas das perguntas dos analistas sobre o Model 3", escreveu Adam Jonas, analista do Morgan Stanley, em nota na quinta-feira.
"Nos preocupamos com o fato de que tais teatralidades minem desnecessariamente a confiança do investidor na perspectiva da Tesla", escreveu Sacconaghi, um dos analistas rejeitados.
A Tesla tem "queimado" dinheiro enquanto se esforça para construir de forma eficiente e lucrativa seu primeiro veículo destinado a ser produzido em alto volume, o Model 3. 
Só no primeiro trimestre deste ano foram US$ 400 milhões para cobrir os gastos com a produção, vendas e operação, e outros US$ 656 milhões em equipamentos e outros projetos. </description>  <media:content url="https://s2.glbimg.com/nAatS0Fz4uQo-qmctn3TedGdSUo=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/y/y/GTXt3aQomKev7TFJS3Dw/2018-05-03t000427z-1529633911-rc1ed05e9750-rtrmadp-3-tesla-results.jpg" medium="image"/>  <category>G1</category> <pubDate>Mon, 07 May 2018 12:09:19 -0000</pubDate> </item>  <item> <title>Triumph Tiger 800; fotos</title> <link>https://g1.globo.com/carros/motos/noticia/triumph-tiger-800-fotos.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/motos/noticia/triumph-tiger-800-fotos.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/D62vz_R5gPoqwBOEoYZ40wmYsS4=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/4/i/SlI0yMT4K70WW45SZsVA/cw2l8954.jpg" /><br /> ]]>  Veja e amplie detalhes da aventureira inglesa que chega renovada ao Brasil em junho. Triumph Tiger 800 XCA
Triumph/Divulgação
Triumph Tiger 800 XCA
Triumph/Divulgação
Triumph Tiger 800 XCA
Triumph/Divulgação
Triumph Tiger 800 XCA
Triumph/Divulgação
Triumph Tiger 800 XCA
Triumph/Divulgação
Triumph Tiger 800 XCA
Triumph/Divulgação
Triumph Tiger 800 XCA no País de Gales
Rafael Miotto/G1
Triumph Tiger 800 XCA no País de Gales
Triumph/Divulgação
Triumph Tiger 800 XCA
Triumph/Divulgação
Triumph Tiger 800 XCA no País de Gales
Triumph/Divulgação
Triumph Tiger 800 XCA
Triumph/Divulgação
Centro de treinamento de pilotagem da Triumph no País de Gales, no Reino Unido
Triumph/DIvulgação
Triumph Tiger 800 XCA
Triumph/Divulgação
Triumph Tiger 800 XCA
Triumph/Divulgação
Tiger 800 no centro de treinamento de pilotagem da Triumph no País de Gales
Triumph/Divulgação
Triumph Tiger XRT e XCA
Triumph/Divulgação
Triumph Tiger 800
Triumph/Divulgação
Triumph Tiger 800 XCA
Triumph/Divulgação
Triumph Tiger 800 XCA
Triumph/Divulgação
Triumph Tiger 800 XC
Triumph/Divulgação
Triumph Tiger 800 XCA
Triumph/Divulgação
Triumph Tiger 800 XCA
Triumph/Divulgação
Triumph Tiger 800 XCA
Triumph/Divulgação
Triumph Tiger 800 XCA
Triumph/Divulgação
Triumph Tiger 800 XRX
Triumph/Divulgação </description>  <media:content url="https://s2.glbimg.com/D62vz_R5gPoqwBOEoYZ40wmYsS4=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/4/i/SlI0yMT4K70WW45SZsVA/cw2l8954.jpg" medium="image"/>  <category>G1</category> <pubDate>Mon, 07 May 2018 09:00:21 -0000</pubDate> </item>  <item> <title>Primeiras impressões: nova Tiger 800 é avaliada em mina desativada</title> <link>https://g1.globo.com/carros/motos/noticia/primeiras-impressoes-nova-tiger-800-e-avaliada-em-mina-desativada.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/motos/noticia/primeiras-impressoes-nova-tiger-800-e-avaliada-em-mina-desativada.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/dNJKMoHNOt1MsH6bA_JmKsZKWhA=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/A/r/lRVzXXRNuJwbQiFtfaIQ/cw2l8943.jpg" /><br /> ]]>  G1 rodou com moto no País de Gales, antes de ela chegar ao Brasil. Aventureira da Triumph se renova para combater nova BMW, mas preço irá subir 8%. Primeiras impressões: Tiger 800 é avaliada em mina desativada antes de chegar ao Brasil
O Brasil é o país que mais vende Tiger 800 no mundo, ficando à frente até mesmo da Inglaterra, país de origem da Triumph.
FOTOS: veja como ficou a nova Tiger 800
Pela importância do mercado brasileiro para a motocicleta, a opinião do consumidor local foi levada em conta para a renovação da moto que, em seu modelo 2018, chega às lojas em junho.
Ainda sem o preço revelado, a nova Tiger 800 ficará em média 8% mais cara que a atual. O modelo varia de R$ 39.990 a R$ 52.990, ou seja, a linha 2018 deve ficar em uma faixa de preços entre R$ 43 mil e R$ 56 mil. 
Apesar de não ter uma nova geração, já que manteve a base mecânica, a motocicleta passou por 200 modificações. 
A Tiger é dividida entre as versões XR, mais voltada ao asfalto com roda de 19 polegadas na dianteira, e a XC, que é uma opção mais aventureira e com roda de 21 polegadas na dianteira. 
A sopa de letrinhas continua com as divisões de pacotes em cada uma das versões: a XR tem as opções XR, XRx e XRt, enquanto a XC é formada por XC, XCx e XCa, sempre da ordem mais básica para a mais equipada. 
Para o modelo 2018, a novidade é a chegada da XRt ao Brasil, que é a topo de linha da versão XR. 
Veja as principais novidades da Tiger 800:
1ª marcha mais curta
Motor revisto
Modo de condução "Off-road Pro" (versão XCa)
Novo escapamento
Painel digital em TFT (exceto a versão de entrada XR)
Luzes de LED (exceto a versão de entrada XR)
Carenagens redesenhadas
Guidão recuado em 10 mm
Triumph Tiger 800 XCA
Triumph/Divulgação
Conheça a principal concorrente da Triumph Tiger 800
 G1
Os esforços em manter a Tiger 800 competitiva não são por acaso: a sua principal concorrente da BMW, a linha GS, acabou de ganhar uma nova geração no exterior e que deve chegar em breve ao Brasil.
F 700 GS e F 800 GS viraram F 750 GS e F 850 GS, para brigar, respectivamente, com Tiger 800 XR e Tiger 800 XC. Será uma concorrência mais dura para a Tiger, já que além de totalmente repaginada, a GS passa contar com suspensões eletrônicas, algo que a Triumph não tem. 
Novo painel é uma das grandes atrações da nova Triumph Tiger 800
Triumph/Divulgação
Encarando a pedreira
O local onde o G1 avaliou a nova Tiger 800, em sua opção top de linha XCa, foi a mina de Nant Helen no País de Gales. Mas por que nesse lugar? A resposta é que a Triumph inaugurou por lá o seu novo centro de treinamento de pilotagem, chamado de Triumph Adventure Experience.
Assim, além de andar nas estradinhas sinuosas nos arredores do parque nacional de Brecon Breacons, a moto foi levada a situações extremas na, literalmente, pedreira. A primeira modificação notada foi a da primeira marcha mais curta.
Apesar de o motor manter a mesma potência, de 95 cavalos, a primeira marcha foi reduzida, o que melhorou o controle da moto em baixas velocidades e consequentemente na terra.
Triumph Tiger 800 XCA
Triumph/Divulgação
Utilizando motor de 3 cilindros, a Tiger perdia um pouco em baixas rotações do motor, por exemplo, comparada à F 800 GS, mas com a alteração isso foi compensado.
Rodando no piso pedregoso e enlamaçado de Nant Helen, foi uma boa oportunidade para utilizar o novo modo de pilotagem "Off-Road Pro", exclusivo da XCa. Nele, controle de tração e ABS são desligados, e as acelerações mais contidas, para rodar com mais precisão na terra.
O efeito é realmente sentido e fica mais divertido para andar na terra, mas é válido apenas em situações mais extremas de off-road e para pilotas mais experientes. Caso queira apenas curtir um rolê na terra, é melhor deixar no modo Off-road, apenas, onde o controle de tração e ABS estão parcialmente ativados. 
Equipada com suspensões reguláveis da WP, a XCa está bem preparada para rodar tanto em terrenos esburacados como no asfalto. 
A moto avaliada estava com pneus mais off-road, o que ajudou a rodagem na terra e piora um pouco a maneabilidade no asfalto. No Brasil, a XCa virá de séria com pneus mais voltados ao asfalto mesmo. 
Mudou o bastante?
Líder do seu segmento no Brasil, das aventureiros de 800 cc, a Tiger 800 mudou em alguns pontos importantes, mas que não terão o impacto de uma nova geração. Seu motor foi refinado, porém, continua com a mesma potência.
Triumph Tiger 800 XCA
Triumph/Divulgação
Mas a investida da BMW com a nova geração das F 750 e 850 GS será forte, ainda mais com o motor de 2 cilindros totalmente reformulado que chega também aos 95 cavalos, porém, com maior toque que a Tiger.
Resta aguardar a chegada das nova BMW e, dependendo de como ela render, a Triumph pode pensar em uma nova geração completa da Tiger 800 em breve. 
Como andar de moto no País de Gales?
A montadora britânica acabou de inaugurar no País de Gales o "Adventure Riding Experience", um programa de pilotagem de suas motocicletas, passando pela mina de Nant Helen. Com pacotes que começam em 299 libras, o equivalente a R$ 1,5 mil, o curso dá direito a rodar com a Tiger 800 XC, Tiger 1200 XC e Bonneville Street Scrambler - não incluso estadia, translado e passagens. 
Tiger 800 no centro de treinamento de pilotagem da Triumph no País de Gales
Triumph/Divulgação
Roteiro de moto pelo País de Gales
 G1
Além da Triumph, outras montadoras, como a BMW, também oferecem cursos na região. O "Off-Road Skills" da montadora alemã tem pacotes de terinamento começando em 519 libras, valor equivalente a R$ 2,5 mil.
Acaba sendo uma boa ideia para melhorar a pilotagem e, de quebra, conhecer os modelos das marcas, no entanto, o alto valor de Libra em relação ao Real acaba fazendo os preços ficarem exorbitantes.
Treinamento de pilotagem da Triumph no País de Gales
Triumph/Divulgação </description>  <media:content url="https://s2.glbimg.com/dNJKMoHNOt1MsH6bA_JmKsZKWhA=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/A/r/lRVzXXRNuJwbQiFtfaIQ/cw2l8943.jpg" medium="image"/>  <category>G1</category> <pubDate>Mon, 07 May 2018 09:00:20 -0000</pubDate> </item>  <item> <title>CNH digital some automaticamente quando o condutor atinge 20 pontos? Não é verdade!</title> <link>https://g1.globo.com/e-ou-nao-e/noticia/cnh-digital-some-automaticamente-quando-o-condutor-atinge-20-pontos-nao-e-verdade.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/e-ou-nao-e/noticia/cnh-digital-some-automaticamente-quando-o-condutor-atinge-20-pontos-nao-e-verdade.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/QlfZgsDXCklnPsv-H65T3Dv7HAk=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2017/B/N/rxNXYsRRKH7q9wBWbBZA/eh-ou-nao-eh-final-quadrado-rodape-maior.jpg" /><br /> ]]>  Gravação viralizada recomenda ainda que motorista não baixe versão eletrônica da Carteira Nacional de Habilitação (CNH). Ministério das Cidades diz que documentos digital e impresso dão "ampla defesa" ao condutor. Um áudio compartilhado em aplicativos de mensagens afirma que a CNH eletrônica (CNH-e), ou CNH digital, some automaticamente quando o condutor atinge 20 pontos. Assim, o motorista perde o documento mais rapidamente. Não é verdade.
Em nota enviada ao G1, a assessoria de imprensa do Ministério das Cidades diz que a CNH eletrônica e a versão impressa do documento adotam o mesmo procedimento administrativo e permitem "ampla defesa do condutor antes de haver a suspensão do direito". 
"O referido áudio é falso, podendo ser considerado pelas terminologias atuais como "Fake News", pois é revestido de factoides que podem levar o cidadão de bem a acreditar que a solução tecnológica CNH Eletrônica (CNH-e) possa trazer problemas, em vez de solução", diz trecho da nota.
CNH digital não some automaticamente quando o condutor atinge 20 pontos
G1 
O aplicativo da CNH Digital está disponível para Android e iOS e foi lançado pelo Departamento Nacional de Trânsito (Denatran), que é ligado ao Ministério das Cidades. Desde abril deste ano, a versão digital está disponível em todo o país. 
A nota da assessoria de imprensa lembra ainda que "a CNH-e é a forma digital da Carteira Nacional de Habilitação e possui a mesma validade e o mesmo valor jurídico do modelo impresso". 
Initial plugin text
Citado no áudio, o Detran do RJ enviou uma nota na qual reforça que não há distinção entre a CNH Digital e a CNH tradicional. O procedimento é o mesmo para ambos documentos, conforme diz o texto:
Primeiro, o motorista é notificado da multa pelos Correios ou pelo Diário Oficial (se não for localizado em sua residência) e terá três oportunidades para se defender. 
Se todos os recursos forem indeferidos, aquela infração se transforma em penalidade definitivamente e os respectivos pontos serão incluídos no prontuário do condutor. 
Depois, se num prazo de 12 meses o motorista somar 20 pontos, ele responderá a um processo de suspensão, como estabelece o artigo 261 do Código de Trânsito Brasileiro, pelo qual será notificado e terá três oportunidades para recorrer. 
Se todos os recursos forem rejeitados, aí sim o motorista terá a CNH suspensa.
Como obter a CNH digital?
é preciso ter a CNH impressa no formato atual, com QR code;
quando ela estiver valendo no seu estado, o primeiro passo é cadastrar-se no Portal de Serviços do Denatran;
ir ao Detran onde foi emitida a CNH impressa para confirmar seus dados (quem optar por usar um certificado digital, que é pago, pode fazer todo o processo online);
caberá a cada Detran cobrar ou não pela via digital, e determinar um valor;
baixar o aplicativo gratuito da CNH digital, que estará nas lojas oficiais da Apple e do Google (para aparelhos Android);
acessar o aplicativo por meio de um código de ativação que o Denatran enviará por e-mail aos usuários inscritos, quando o estado disponibilizar a CNH digital;
criar uma senha de 4 dígitos para acessar o documento no celular.
Quanto custará? Quem já tem a CNH impressa terá de pagar para ter a digital?
O Denatran diz que a cobrança de possíveis taxas para emissão da CNH digital ficará a cargo dos Departamentos Estaduais de Trânsito (Detrans). São eles que determinam atualmente os valores das taxas da CNH impressa, que variam de estado para estado. Em São Paulo, por exemplo, a CNH-e foi lançada gratuitamente.
Qualquer motorista poderá tirar?
A CNH digital só poderá ser emitida para quem tem a nova CNH, com QR Code, um código específico para ser lido por aparelhos eletrônicos. Ele existe na parte interna das carteiras de habilitação emitidas desde maio do ano passado. Quem tem a versão antiga precisará pedir uma segunda via ou renovar a impressa para, então, solicitar a digital. Não é necessário esperar a CNH vencer para renová-la.
É ou não é?’, seção de fact-checking (checagem de fatos) do G1, tem como objetivo conferir os discursos de políticos e outras personalidades públicas e atestar a veracidade de notícias e informações espalhadas pelas redes sociais e pela web. Sugestões podem ser enviadas pelo VC no G1, pelo Fale Conosco ou pelo Whatsapp/Viber, no telefone (11) 94200-4444, com a hashtag #eounaoe. </description>  <media:content url="https://s2.glbimg.com/QlfZgsDXCklnPsv-H65T3Dv7HAk=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2017/B/N/rxNXYsRRKH7q9wBWbBZA/eh-ou-nao-eh-final-quadrado-rodape-maior.jpg" medium="image"/>  <category>G1</category> <pubDate>Sat, 05 May 2018 21:23:32 -0000</pubDate> </item>  <item> <title>Volta da Honda Monkey, os mais vendidos e sujeira que virou arte: veja destaques da semana em carros e motos</title> <link>https://g1.globo.com/carros/noticia/volta-da-honda-monkey-os-mais-vendidos-e-sujeira-que-virou-arte-veja-destaques-da-semana-em-carros-e-motos.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/volta-da-honda-monkey-os-mais-vendidos-e-sujeira-que-virou-arte-veja-destaques-da-semana-em-carros-e-motos.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/4lVB-zt2-M0Qjoqhz1Ho2pmbYec=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/T/f/Yhrp82Qgu5Umgu5IF5qg/arteportemplate-abrvale.png" /><br /> ]]>  Toyota abriu 870 vagas para criar o terceiro turno nas duas fábricas no Brasil. Confira as notícias que marcaram a semana de 28 de abril a 4 de maio:
Alta nas vendas
As vendas de veículos novos subiram 38,5% em abril na comparação com 1 ano atrás, informou a federação dos concessionários, a Fenabrave, na última quarta-feira (2).
No ranking dos mais vendidos, o Hyundai HB20 retomou a vice-liderança, que tinha sido do Ford Ka até o mês anterior. "Vendo" a briga de longe, o Chevrolet Onix segue no topo.
Veja os carros e motos mais vendidos em abril de 2018
 G1
Volta da Monkey
Honda Monkey 2018
Honda/Divulgação
Criada em 1961 para ser um brinquedo para crianças, a Honda Monkey acaba de ser relançada na Europa em uma versão moderna. A minimoto foi muito popular nos anos 70 e virou um ícone, graças ao seu diminuto tamanho e rodas de apenas 8 polegadas.
Vagas na Toyota
Vista aérea da fábrica em Sorocaba
Divulgação
A Toyota anunciou na última quarta-feira (2) a criação do terceiro turno nas fábricas de Sorocaba e Porto Feliz (SP). É a primeira vez que montadora vai operar 24 horas. Foram abertas 870 vagas diretas e outras 700 junto a fornecedores de peças.
Sujeira vira arte
Artista russo Nikita Golubev desenha em carros imundos nas ruas
Reprodução/Facebook/Nikita Golubev
Um artista russo foi além do "lave-me": Nikita Golubev cria obras de arte na densa camada de poeira que encobre alguns veículos. Tem tigre, tubarão, coruja... assista ao vídeo
Quero ser Tesla
Conceito da HKG no Salão de Pequim 2018
Peter Fussy/G1
No Salão de Pequim, o G1 conheceu 4 startups que sonham em ser a "nova Tesla". O sonho é alimentado pela meta do governo chinês de que os modelos "verdes" (elétricos e híbridos) sejam pelo menos 20% das vendas de automóveis no país até 2025.
Curtas e rápidas
O ex-presidente da Volkswagen, Martin Winterkorn, foi acusado formalmente nos Estados Unidos pelo escândalo do "dieselgate";
A Ford Ranger ganhou novas versões na linha 2019; veja preços;
A Nissan fez o "recall do recall", para trocar os airbags que substituíram os "airbags mortais" no Brasil;
A primeira picape da Mercedes-Benz, Classe X, poderá ter versão básica no Brasil; o modelo chega em 2019 </description>  <media:content url="https://s2.glbimg.com/4lVB-zt2-M0Qjoqhz1Ho2pmbYec=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/T/f/Yhrp82Qgu5Umgu5IF5qg/arteportemplate-abrvale.png" medium="image"/>  <category>G1</category> <pubDate>Sat, 05 May 2018 14:00:20 -0000</pubDate> </item>  <item> <title>Carro autônomo do Google é atingido por outro veículo nos Estados Unidos</title> <link>https://g1.globo.com/carros/noticia/carro-autonomo-do-google-e-atingido-por-outro-veiculo-nos-estados-unidos.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/carro-autonomo-do-google-e-atingido-por-outro-veiculo-nos-estados-unidos.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/H29R-pFTwlnFulIzLG_AsFW9aRA=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/6/i/PeSXPsRz2BJdz1zeo4Kg/dcyhipyvqaaswak.jpg" /><br /> ]]>  Chefe da polícia local disse que veículo não teve culpa. 'Estava no lugar errado, na hora errada', afirmou. Acidente com carro autônomo do Google nos Estados Unidos
Reprodução/Twitter
Um carro autônomo da Waymo, empresa que pertence ao Google, foi atingido por outro veículo nesta sexta-feira (4) na cidade americana de Chandler, no estado do Arizona. 
A Chrysler Pacifica da Waymo estava rodando em modo autônomo, com um operador no banco do motorista. Ele teve ferimentos leves. Segundo a polícia local, o veículo não teve culpa no acidente. Ele teria sido atingido por outro carro, que tentava desviar de outro automóvel que ia no sentido contrário. 
"O carro da Waymo não é o veículo infrator. Aconteceu de estar no lugar errado, na hora errada", disse o investigador da polícia de Chandler ao jornal local Phoenix New Times. 
Pelas imagens, é possível ver que a dianteira do veículo ficou danificada, principalmente do lado esquerdo. Por outro lado, os danos foram maiores no veículo que colidiu com a Pacifica, um cupê prata da Honda. 
Waymo encomendou mais 500 unidades da Chrysler Pacifica para sua frota de autônomos
Divulgação
A Waymo é a divisão de mobilidade autônoma do Google, da Alphabet. Ela concorre na "corrida do carro autônomo" com outras empresas, como a Uber e a General Motors. 
Em novembro do ano passado, a Waymo afirmou que iria dispensar o uso de motoristas nos testes no Arizona. Os veículos autônomos já rodavam em 25 cidades do Arizona, utilizando cerca de 600 unidades da Pacifica. 
Recentemente, a empresa também anunciou que iria adquirir unidades do Jaguar I-Pace, o mais recente lançamento da empresa britânica, que é totalmente elétrico. 
Segundo caso
Apesar de não ter sido causado pelo autônomo, o caso é o segundo acidente com este tipo de veículo em pouco mais de um mês. 
No final de março, também no Arizona, mas na cidade de Tempe, um Volvo XC90 autônomo da Uber atropelou e matou uma mulher. 
Carro autônomo da Uber que atropelou e matou uma pedestre nos EUA é analisado pelo departamento de segurança no transporte dos EUA
National Transportation Safety Board/Reuters 
Neste acidente, o veículo também estava em modo autônomo, com uma operadora no banco do motorista. 
Era noite, e estava escuro. Pelas imagens divulgadas depois do acidente, só é possível ver a vítima quando ela está no meio da pista. Antes disso, o trecho estava com pouca iluminação. 
Initial plugin text </description>  <media:content url="https://s2.glbimg.com/H29R-pFTwlnFulIzLG_AsFW9aRA=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/6/i/PeSXPsRz2BJdz1zeo4Kg/dcyhipyvqaaswak.jpg" medium="image"/>  <category>G1</category> <pubDate>Sat, 05 May 2018 00:19:31 -0000</pubDate> </item>  <item> <title>Veja as principais acusações contra a Volkswagen no 'dieselgate'</title> <link>https://g1.globo.com/carros/noticia/veja-as-principais-acusacoes-contra-a-volkswagen-no-dieselgate.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/veja-as-principais-acusacoes-contra-a-volkswagen-no-dieselgate.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/lvs7XQQIV2K5mopevxEZpFF-gFs=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/N/e/u4LiD3QYWNz9tILeK31w/2018-03-29t110416z-528455727-rc1f2d3a6ef0-rtrmadp-3-volkswagen-emissions-storage.jpg" /><br /> ]]>  Ex-presidente foi acusado formalmente nos EUA nesta semana; há investigação na Alemanha e outros países. Escândalo veio à tona em 2015. Carros Volkswagen são armazenados em deserto próximo a Victorville, na Califórnia. Veículos foram recomprados devido ao escândalo "Dieselgate"
Lucy Nicholson/Reuters
A acusação formal contra o ex-presidente da Volkswagen Martin Winterkorn, anunciada na última quinta-feira (3), é o episódio mais recente do "dieselgate", o escândalo dos motores adulterados para dissimular o nível real de emissão de gases poluentes dos veículos do grupo.
Essas são as principais acusações em curso contra a empresa:
Nos Estados Unidos
O caso estourou em setembro de 2015, quando a Agência de Proteção Ambiental (EPA) denunciou a Volkswagen por ter instalado em 11 milhões de seus veículos a diesel - 600 mil deles vendidos nos Estados Unidos - um software capaz de manipular os resultados de testes de poluição e de ocultar as verdadeiras emissões até 40 vezes maiores que o permitido. 
A Volkswagen se declarou culpada às autoridades americanas por fraude e obstrução da Justiça. 
Em maio de 2017, a Justiça americana aprovou um plano de indenização para os cerca de 600 mil clientes. A marca precisou pagar mais de US$ 22 bilhões em acordos para compensar autoridades, clientes e concessionárias. 
Embora a Volkswagen não seja judicialmente acusada como empresa, seus funcionários são. Até agora 8 líderes e ex-líderes foram indiciados nos EUA.
Entre eles, está Winterkorn, acusado de "fraude" e "conspiração", e um dirigente da Audi, marca que pertence ao grupo.
Dessas 9 pessoas, 2 engenheiros foram condenados. Em agosto de 2017, um ex-dirigente da Volkswagen, James Liang, também foi condenado a 40 meses de prisão.
Sua colaboração permitiu acusar outros diretores do grupo, entre eles Oliver Schmidt, diretor do serviço de conformidade da regulamentação nos EUA entre 2014 e março de 2015, que se declarou culpado e foi condenado a 7 anos de prisão.
Na Alemanha
Vários promotores estão investigando a Volkswagen e algumas de suas marcas, como Audi e Porsche  por fraude, manipulação na bolsa e propaganda enganosa. Mas também estão na mira a Daimler, dona da Mercedes-Benz e Bosch.
Winterkorn e seu sucessor, Matthias Müller, bem como o atual presidente da Volkswagen, Herbert Diess, estão sendo investigados.
As autoridades também fizeram operações de busca e apreensão nas instalações da montadora, da Audi e da Porsche, bem como nos apartamentos particulares de funcionários ou ex-funcionários. 
A investigação do escritório do promotor de Brunswick, autoridade na região onde a Volkswagen tem sua sede, Wolfsburg, envolve 49 pessoas.
A nível privado, a queixa mais importante é a de um grupo de milhares de investidores ante a corte de Brunswick, pedindo cerca de 9 bilhões de euros em indenização.
Os investidores, que perderam bilhões de euros quando as ações caíram 40% em 2 dias, acusaram a administração da Volkswagen de não ter informado os mercados financeiros no momento da crise. 
Por outro lado, há uma queixa em grupo de consumidores e há outra sendo preparada para solicitar o reembolso de carros a diesel. 
Os proprietários alemães têm até o final de 2018 para apresentar reclamações, antes que o caso prescreva.
Outros países da Europa
O Ministério Público de Paris abriu uma investigação em fevereiro de 2016 contra a Volkswagen por "engano agravado". 
Na Itália, as autoridades de concorrência condenaram a Volkswagen em agosto de 2016 a uma multa de 5 milhões de euros por "práticas comerciais incorretas". 
No início de 2017, houve uma queixa coletiva no Reino Unido e também há casos em tribunais na Polônia. </description>  <media:content url="https://s2.glbimg.com/lvs7XQQIV2K5mopevxEZpFF-gFs=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/N/e/u4LiD3QYWNz9tILeK31w/2018-03-29t110416z-528455727-rc1f2d3a6ef0-rtrmadp-3-volkswagen-emissions-storage.jpg" medium="image"/>  <category>G1</category> <pubDate>Fri, 04 May 2018 20:50:17 -0000</pubDate> </item>  <item> <title>Suzuki lança nova GSX-R 1000 de 202 cv no Brasil; veja preço</title> <link>https://g1.globo.com/carros/motos/noticia/suzuki-lanca-nova-gsx-r-1000-de-202-cv-no-brasil-veja-preco.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/motos/noticia/suzuki-lanca-nova-gsx-r-1000-de-202-cv-no-brasil-veja-preco.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/i6tp-uvchxGWoGxj_vdaL1YsWlg=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/R/M/dTBDubRYCGbgSiDJ2Ljg/gsx-r1000-a-rl7-action-28.jpg" /><br /> ]]>  Sexta geração da moto esportiva chega ao Brasil com novidades da MotoGP. Suzuki lança a nova GSX-R 1000 no Brasil
Divulgação/Suzuki
A Suzuki anunciou nesta sexta-feira (4) que a nova geração da GSX-R 1000 já está nas concessionárias brasileiras, inclusive na versão GSX-R 1000R.
Preços sugeridos (sem frete)
GSX-R 1000 - R$ 73.280 (promocional à vista R$ 68.000)
GSX-R 1000R - R$ 84.487 (promocional à vista R$ 78.400)
A sexta geração da moto esportiva foi lançada em 2016 na Europa e traz motor de 4 cilindros de 998,8 cc e 202 cavalos.
Suzuki GSX-R 1000R
Divulgação/Suzuki
A Suzuki afirmou ter utilizado tecnologia da MotoGP, onde vem obtendo bons resultados desde seu retorno, para a nova geração da GSX-R 1000.
Além de ajudar no desenvolvimento do motor, as experiências das pistas serviram para a criação do pacote eletrônico da moto, com controle de tração de 10 modos e freios ABS.
Suzuki GSX-R 1000R
Divulgação/Suzuki
Na remodelação, o chassi ficou mais compacto e estreito, mas a posição de guiar permaneceu a mesma, segundo a fabricante.
A versão mais esportiva GSX-R 1000R inclui troca rápida de marchas sem uso da embreagem, controle de largada, suspensão desenvolvida para competições e freio com sensor de movimento.
Suzuki GSX-R 1000R
Divulgação/Suzuki </description>  <media:content url="https://s2.glbimg.com/i6tp-uvchxGWoGxj_vdaL1YsWlg=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/R/M/dTBDubRYCGbgSiDJ2Ljg/gsx-r1000-a-rl7-action-28.jpg" medium="image"/>  <category>G1</category> <pubDate>Fri, 04 May 2018 17:56:15 -0000</pubDate> </item>  <item> <title>Ladrões invadem fábrica da Fiat Chrysler nos EUA para roubar picapes</title> <link>https://g1.globo.com/carros/noticia/ladroes-invadem-fabrica-da-fiat-chrysler-nos-eua-para-roubar-picapes.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/ladroes-invadem-fabrica-da-fiat-chrysler-nos-eua-para-roubar-picapes.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/RXhwftwYPQbXUOIewiWpx9cOdog=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/k/s/nyi90BS8WCMnboNr3oxg/chrysler-front-05.jpg" /><br /> ]]>  Ao menos 10 unidades da Ram foram levadas em comboio. Modelo é o terceiro veículo mais vendido do país.  Fábrica da Fiat Chrysler em Warren, na região de Detroit
Divulgação
Um grupo de ladrões realizou um roubo ousado nesta quinta-feira (3), ao invadir uma unidade da Fiat Chrysler no estado de Michigan para levar - em comboio - ao menos dez pickups Dodge Ram recém-fabricadas.
O roubo, cometido no final da madrugada, ocorreu na fábrica da Fiat Chrysler em Warren, um subúrbio de Detroit.
"Fizeram um buraco na cerca, entraram na fábrica e saíram guiando de 10 a 11 caminhonetes Dodge", revelou o chefe de polícia William Dwyer ao canal de televisão WXYZ de Detroit.
Ram 1500 Rebel no Salão de Detroit 2018
Brendan McDermid/Reuters
Na fuga, os ladrões utilizaram um caminhão para romper uma barreira de segurança da fábrica, por onde saíram as pickups em comboio.
A Ram é a terceira pickup mais vendida nos Estados Unidos, com cerca de 103 mil unidades comercializadas desde março deste ano. Seu preço vai de US$ 27 mil (R$ 97,7 mil) a US$ 53 mil (R$ 186 mil).  </description>  <media:content url="https://s2.glbimg.com/RXhwftwYPQbXUOIewiWpx9cOdog=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/k/s/nyi90BS8WCMnboNr3oxg/chrysler-front-05.jpg" medium="image"/>  <category>G1</category> <pubDate>Fri, 04 May 2018 17:39:04 -0000</pubDate> </item>  <item> <title>Russo vai além do 'lave-me' e cria obras de arte em carros imundos</title> <link>https://g1.globo.com/carros/noticia/russo-vai-alem-do-lave-me-e-cria-obras-de-arte-em-carros-imundos.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/russo-vai-alem-do-lave-me-e-cria-obras-de-arte-em-carros-imundos.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/fszJcwEyeNtXlSbChe77YpqED-4=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/s/t/tYwyDBSwSrxtEsSp2iLA/olhaquelegal-selo-horizontal.jpg" /><br /> ]]>  Nikita Golubev faz desenhos incríveis em carros e caminhões cobertos de sujeira. Artista de rua russo faz desenhos em carros empoeirados
No Brasil, carros sujos nas ruas ganham no máximo um "lave-me" ou então algum desenho obsceno, mas na Rússia um artista chamado Nikita Golubev cria obras de arte na densa camada de poeira que encobre alguns veículos.
Nascido em 1981 e formado em Medicina, ele desenvolveu uma técnica usando apenas pincel e o dedo para desenhar nos veículos. 
Initial plugin text
O artista assina as obras efêmeras como ProBoyNick e às vezes pede permissão para o trabalho, em outras ocasiões faz tudo de surpresa para o proprietário.
Você teria coragem de lavar o carro se tivesse um desenho desses?
Artista russo Nikita Golubev desenha em carros imundos nas ruas
Reprodução/Facebook/Nikita Golubev
Golubev usa apenas pincel e o dedo para desenhar
Reprodução/Facebook/Nikita Golubev
Golubev assina as obras como ProBoyNick
Reprodução/Facebook/Nikita Golubev
Às vezes os proprietários são avisados
Reprodução/Facebook/Nikita Golubev
Outras vezes, os proprietários são surpreendidos
Reprodução/Facebook/Nikita Golubev
Golubev faz os desenhos nas ruas mesmo, e os carros vão embora com a arte
Reprodução/Facebook/Nikita Golubev </description>  <media:content url="https://s2.glbimg.com/fszJcwEyeNtXlSbChe77YpqED-4=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/s/t/tYwyDBSwSrxtEsSp2iLA/olhaquelegal-selo-horizontal.jpg" medium="image"/>  <category>G1</category> <pubDate>Fri, 04 May 2018 16:12:23 -0000</pubDate> </item>  <item> <title>Mercedes-Benz Classe X deve ter versão 'básica' no Brasil</title> <link>https://g1.globo.com/carros/noticia/mercedes-benz-classe-x-deve-ter-versao-basica-no-brasil.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/mercedes-benz-classe-x-deve-ter-versao-basica-no-brasil.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/7D5ca3Bfs3ZBxkbUWArK_VifJ6E=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2017/Y/P/QKoSZBTxuoT3Z1DriO7A/17c418-02.jpg" /><br /> ]]>  Versão Pure da picape tem para-choque frontal preto e rodas sem calota. Mercedes-Benz Classe X Pure
Divulgação
A picape Classe X da Mercedes-Benz está prevista para chegar às lojas brasileiras só em 2019, mas a marca alemã já está anunciando o modelo em suas plataformas digitais com uma novidade: a versão "pé de boi" deve estará disponível por aqui.
Em outubro do ano passado, a fabricante acreditava que o Brasil teria espaço apenas para os modelos com acabamento "premium". Não é o caso da versão Pure, que tem para-choque frontal em plástico preto, rodas de aço sem calota e bancos de tecido.
Initial plugin text
O modelo é voltado para quem quer colocar a picape na terra com uso comercial. Na época, executivos da Mercedes-Benz afirmaram que a versão X 220, com motor 2.3 a diesel de 163 cv seria homologada para o Brasil, mas só entraria no portfólio se houvesse demanda por versões menos caras.
Parece que a empresa já identificou essa demanda por aqui. Além da Pure, a picape terá outras duas opções de acabamento: Progressive, que apresenta mais conforto para quem busca um veículo para trabalho e também para lazer, e Power, que será a topo de linha mais luxuosa.
Entre as motorizações, além do 2.3 diesel de 163 cv, devem estar disponíveis também os propulsores 2.3 a diesel com dupla sobrealimentação (X 250), que rende 190 cv, e o V6 de 258 cv (X 350). 
Interior da Mercedes-Benz Classe X Pure
Divulgação
A novidade será construída em parceria com a Renault-Nissan em Córdoba, na Argentina, tendo como base a dupla Frontier (já à venda no Brasil) e Alaskan (que chega neste ano). 
A Mercedes-Benz busca um novo nicho de clientes e vai concorrer com modelos já consagrados no segmento, como Chevrolet S10, Ford Ranger, Toyota Hilux e Mitsubishi L200.
IMPRESSÕES: Classe X é uma picape de luxo?
G1 andou na primeira picape da Mercedes-Benz </description>  <media:content url="https://s2.glbimg.com/7D5ca3Bfs3ZBxkbUWArK_VifJ6E=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2017/Y/P/QKoSZBTxuoT3Z1DriO7A/17c418-02.jpg" medium="image"/>  <category>G1</category> <pubDate>Fri, 04 May 2018 13:27:29 -0000</pubDate> </item>  <item> <title>Ex-presidente da Volkswagen e outros 5 executivos são acusados nos EUA por 'dieselgate'</title> <link>https://g1.globo.com/carros/noticia/ex-presidente-da-volkswagen-e-outros-5-executivos-sao-acusados-nos-eua-por-dieselgate.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/ex-presidente-da-volkswagen-e-outros-5-executivos-sao-acusados-nos-eua-por-dieselgate.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/WBswul9ANxeTQxSt3rP3BUCCo3g=/s.glbimg.com/jo/g1/f/original/2017/01/19/martin-winterkorn-afp.jpg" /><br /> ]]>  Martin Winterkorn renunciou ao cargo quando o escândalo estourou, no fim de 2015. Martin Winterkorn, ex-presidente da Volkswagen, após prestar depoimento a comissão que investiga o escândalo do diesel na Alemanha, em 2017
Odd Andersen/AFP
O ex-presidente mundial da Volkswagen, Martin Winterkorn, foi acusado de fraude e conspiração no escândalo "dieselgate" pela Promotoria de Justiça dos Estados Unidos.
O processo afirma que ele e outros 5 executivos todos estavam cientes sobre o programa instalado em veículos para falsificar os resultados das emissões poluentes pelo menos desde maio de 2014, mas que decidiram seguir em frente com a fraude.
Winterkorn enfrentará penas de até 20 anos de prisão e multas de US$ 250 mil, mas ele dificilmente cumprirá alguma delas porque a Alemanha proíbe extradição de cidadãos para fora da União Europeia.
"A acusação formal apresentada hoje alega que o plano da Volkswagen para enganar os requerimentos legais chegou ao topo da companhia", disse o procurador-geral dos Estados Unidos, Jeff Sessions, citado na nota.
Segundo o Departamento de Justiça, em meados de 2015, meses antes de o escândalo vir à tona, Winterkorn presidiu uma "reunião executiva de danos" na sede da Volkswagen em Wolfsburg, na Alemanha, na qual a equipe de desenvolvimento de motores fez uma apresentação da forma como a companhia estava enganando os reguladores dos Estados Unidos e as consequências que a empresa enfrentaria se isso fosse constatado.
Segundo os procuradores, depois dessa reunião, Winterkorn autorizou a companhia nos EUA a continuar mentindo para os reguladores americanos.
Winterkorn renunciou em setembro de 2015, após as revelações da fraude sobre as emissões de gases em veículos da companhia. A Volkswagen configurou até 11 milhões de veículos no mundo todo para emitir até 40 vezes acima dos níveis permitidos de óxido de nitrogênio danoso, mas ocultava isso durante as revisões.
O chefão da Volkswagen é o 9º executivo processado nos EUA - dois deles se declararam culpados e cumprem pena na prisão, enquanto outros seis estão na Alemanha e se encontram na mesma situação de Winterkorn.
Protesto
Ativistas protestam em encontro de acionistas da Volkswagen
Axel Schmidt/Reuters
Nesta quinta-feira (3), a Volkswagen realizou uma conferência anual com os acionistas. No evento, o novo presidente do grupo, Herbert Diess, afirmou que "a Volkswagen tem que se tornar mais honesta, mais aberta e mais verdadeira". 
Antes do encontro, um grupo de uma associação pelos direitos dos animais fez um protesto. A Volkswagen, além de outras fabricantes alemãs, foi acusada de realizar testes dos efeitos do diesel em macacos.  </description>  <media:content url="https://s2.glbimg.com/WBswul9ANxeTQxSt3rP3BUCCo3g=/s.glbimg.com/jo/g1/f/original/2017/01/19/martin-winterkorn-afp.jpg" medium="image"/>  <category>G1</category> <pubDate>Thu, 03 May 2018 23:06:07 -0000</pubDate> </item>  <item> <title>Toyota terá pista de testes para carros autônomos que reproduz cenários de 'caso extremo'</title> <link>https://g1.globo.com/carros/noticia/toyota-tera-pista-de-testes-para-carros-autonomos-que-reproduz-cenarios-de-caso-extremo.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/toyota-tera-pista-de-testes-para-carros-autonomos-que-reproduz-cenarios-de-caso-extremo.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/W36GwFQfRJTbzpF4GgOdsN3s8uI=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/f/9/fcMDXcSO6vA7PSHBB6vQ/20180504-02-01.jpg" /><br /> ]]>  Local será aberto em outubro, nas proximidades de Detroit. Marca japonesa suspendeu testes com autônomos em vias públicas após acidente com veículo da Uber, em março. Toyota vai criar pista de testes para veículos autônomos
Divulgação
A Toyota anunciou nesta quinta-feira (3) que está montando uma pista de testes em Michigan para sua tecnologia de veículos de direção autônoma que irá replicar "casos extremos" de cenários que são muito perigosos para condução em vias públicas.
A instalação em Ottawa Lake, que está sendo construída pelo Instituto Toyota de Pesquisa, entrará em operação em outubro.
"Este novo local nos dará a flexibilidade de personalizar os cenários de direção que ampliarão os limites de nossa tecnologia e nos aproximará da concepção de um veículo conduzido por seres humanos incapaz de causar um acidente", disse Ryan Eustice, vice-presidente sênior do Instituto Toyota de pesquisa de condução automatizada.
Fabricantes de automóveis como General Motors e companhias como o Google têm corrido para desenvolver carros de direção autônoma e ser o primeiro a comercializar com um produto viável.
Mas questões sobre a segurança da tecnologia de direção autônoma e a supervisão dos desenvolvedores cresceram após uma veículo autônomo do Uber atropelar e matar uma pedestre no Arizona, em março.
Após esse acidente, a Toyota suspendeu todos os testes de direção autônoma nas estradas públicas dos Estados Unidos. A Toyota continuou testes em cursos fechados.
Uma porta-voz do Instituto de Pesquisas da Toyota disse que testes de parada nas vias públicas permitiram que a montadora refinasse e atualizasse sua frota de veículos de teste.
"Vamos retomar os testes nas vias públicas daqui a algumas semanas, uma vez que esses três sistemas estejam mais alinhados", disse a porta-voz.     </description>  <media:content url="https://s2.glbimg.com/W36GwFQfRJTbzpF4GgOdsN3s8uI=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/f/9/fcMDXcSO6vA7PSHBB6vQ/20180504-02-01.jpg" medium="image"/>  <category>G1</category> <pubDate>Thu, 03 May 2018 20:31:47 -0000</pubDate> </item>  <item> <title>Nissan faz recall para trocar 'airbags mortais' que já haviam sido substituídos</title> <link>https://g1.globo.com/carros/noticia/nissan-faz-recall-para-trocar-airbags-mortais-que-ha-haviam-sido-substituidos.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/nissan-faz-recall-para-trocar-airbags-mortais-que-ha-haviam-sido-substituidos.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/s8D0S7eLJ5Er_V10QuGBzvG-DuE=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/o/v/ImGAlKQQydwPTzB6olfg/dsc-1990.jpg" /><br /> ]]>  São 138 unidades dos modelos Frontier e X-Trail, produzidos entre 2001 e 2007. Marca já havia substituído bolsas frontais da fabricante Takata. Nissan X-Trail
Divulgação
A Nissan anunciou um recall de 138 unidades da Frontier e do X-Trail para uma nova substituição do gerador dos gases do airbag do passageiro. Trata-se de um segundo recall para estes modelos. O reparo é gratuito.
A marca afirma que a Takata, fabricante dos "airbags mortais", enviou novos componentes, que são mais eficientes do que os já substituídos anteriormente, em chamadas de 2013 e 2015.
Veja os chassis das unidades envolvidas:
Frontier (2 unidades) - produzidas em novembro de 2001
JN1CGUD222X020719 e JN1CGUD222X020743
X-Trail (136 unidades) - produzidas entre novembro de 2004 e julho de 2007
de JN1TBNT305W600021 a JN1TBNT308W610753
O defeito
Inflador de airbag da takata (no detalhe) já causou recall de milhões de carros no mundo inteiro e pelo menos 22 mortes
REUTERS/Joe Skipper
De acordo com a Nissan, em caso de colisão frontal em que o airbag é acionado, pode haver a explosão do gerador, projetando fragmentos metálicos e ferindo os ocupantes. A falha ficou conhecida como "airbags mortais", e veio à tona 5 anos atrás. 
Em todo o mundo, cerca de 30 milhões de veículos tiveram que passar por recall, e ao menos 22 pessoas morreram, além de 180 feridas.  </description>  <media:content url="https://s2.glbimg.com/s8D0S7eLJ5Er_V10QuGBzvG-DuE=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/o/v/ImGAlKQQydwPTzB6olfg/dsc-1990.jpg" medium="image"/>  <category>G1</category> <pubDate>Thu, 03 May 2018 19:18:49 -0000</pubDate> </item>  <item> <title>Ford Ranger ganha novas versões na linha 2019; veja preços</title> <link>https://g1.globo.com/carros/noticia/ford-ranger-ganha-novas-versoes-na-linha-2019-veja-precos.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/ford-ranger-ganha-novas-versoes-na-linha-2019-veja-precos.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/hw-M-uCPfpCtzwXT_rOsCZix6M4=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/l/F/MGPYlaTimYBTkUMLBxGQ/fordranger2019-xl-cabinesimples.jpg" /><br /> ]]>  Picape volta a ser oferecida com opção de cabine simples ou chassi. Ford Ranger XL Cabine Simples custará a partir de R$ 129.300
Divulgação
A Ford anunciou nesta quinta-feira (3) a chegada da linha 2019 da picape Ranger, que ganha novas versões a diesel com o retorno da versão XL, que não era oferecida desde a última reestilização em 2016. Com isso, a picape volta a ter opção de cabine simples ou apenas chassi.
Preços da Ranger 2019
XLS 4x2 manual (2.5 Flex) - R$ 110.790
XLT 4x2 manual (2.5 Flex) - R$ 121.490
Limited 4x2 manual (2.5 Flex) - R$ 129.650
XL Chassi 4x4 manual (2.2 Diesel) - R$ 124.200 (novidade)
XL Cabine Simples 4x4 manual (2.2 Diesel) - R$ 129.300 (novidade)
XL Cabine Dupla 4x4 manual (2.2 Diesel) - R$ 139.590 (novidade)
XLS 4x2 automática (2.2 Diesel) - R$151.890 (novidade)
XLS 4x4 manual (2.2 Diesel) - R$ 157.460
XLS 4x4 automática (2.2 Diesel) - R$ 164.650
XLT 4x4 automática (3.2 Diesel) - R$ 183.490
Limited 4x4 automática (3.2 Diesel) - R$ 193.490
Ford Ranger XL Chassi pode ser usada para carregar outros implementos
Divulgação
Produzida para o trabalho pesado, a versão XL cabine simples pode carregar até 1.234 kg e já vem com controle de estabilidade e tração, direção elétrica, assistente de partida em rampa, piloto automático, rádio com comandos no volante, sistema anticapotamento e diferencial traseiro blocante eletrônico.
Outra novidade é a versão XLS 2.2 a diesel com tração 4x2 e câmbio automático, que é voltada para aqueles que não precisam de força nas quatro rodas, mas fazem questão do motor a diesel e do câmbio automático.
Ford Ranger 4x2 agora tem opção de câmbio automático e motor a diesel
Divulgação </description>  <media:content url="https://s2.glbimg.com/hw-M-uCPfpCtzwXT_rOsCZix6M4=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/l/F/MGPYlaTimYBTkUMLBxGQ/fordranger2019-xl-cabinesimples.jpg" medium="image"/>  <category>G1</category> <pubDate>Thu, 03 May 2018 14:49:24 -0000</pubDate> </item>  <item> <title>Lendária equipe de F1, Brabham produzirá supercarro de R$ 5 milhões</title> <link>https://g1.globo.com/carros/noticia/lendaria-equipe-de-f1-brabham-produzira-supercarro-de-r-5-milhoes.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/lendaria-equipe-de-f1-brabham-produzira-supercarro-de-r-5-milhoes.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/hNghaEEwvFLdeMkS7_xWFkKYr6Q=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/k/b/V6tDOnSSamgsU4pYnU0w/brabhambt62-2129.jpg" /><br /> ]]>  Com motor V8 de 710 cv, esportivo terá a responsabilidade de continuar o legado do tricampeão de Fórmula 1 Jack Brabham. Brabham BT62 custará mais de R$ 5 milhões
Divulgação
Primeiro foi Senna, que deu nome a um modelo da McLaren. Agora é Brabham, outro tricampeão da Fórmula 1 que dará nome a um superesportivo ao seu alcance. Quer dizer, ao alcance de poucas pessoas no mundo.
Lançado na noite da quarta-feira (2) em Londres, o Brabham BT62 segue a mesma nomenclatura dos carros da equipe F1, criada por Jack Brabham e Ron Tauranac nos anos 1960.
Além do nome, o superesportivo compartilha a paixão pelo limite com a F1. Serão 710 cavalos de potência, saindo de um motor V8 de 5.4 litros naturalmente aspirado, e apenas 972 kg - mais leve que um Chevrolet Onix.
Cada unidade custará a partir de £ 1 milhão (R$ 4,9 milhões), sem contar os impostos e os opcionais, e poderá ser usada apenas nas pistas.
Com 710 cv, Brabham BT62 poderá ser usado paenas nas pistas de corrida
Divulgação
Todos os compradores entrarão para um programa especial de pilotagem. Segundo David Brabham, o projeto de lançar a marca de esportivos começou há 12 anos.  
"É com muito orgulho que estou honrando e continuando o legado de meu pai ao mostrar o novo capítulo da história da Brabham", afirmou.
O BT62 terá uma edição limitada a 70 unidades para celebrar os 70 anos da primeira corrida de Jack Brabham, em 1948. 
Visão do piloto no Brabham BT62
Divulgação
As 35 primeiras unidades terão pintura especial lembrando as 35 vitórias em GPs de Fórmula 1 do tricampeão.
O objetivo da Brabham é retornar às competições, já mirando a tradicional corrida das 24 horas de Le Mans.
Brabham BT62 pesa menos que um Chevrolet Onix
Divulgação </description>  <media:content url="https://s2.glbimg.com/hNghaEEwvFLdeMkS7_xWFkKYr6Q=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/k/b/V6tDOnSSamgsU4pYnU0w/brabhambt62-2129.jpg" medium="image"/>  <category>G1</category> <pubDate>Thu, 03 May 2018 14:00:21 -0000</pubDate> </item>  <item> <title>Veja os 10 carros e 10 motos mais vendidos em abril de 2018</title> <link>https://g1.globo.com/carros/noticia/veja-os-10-carros-e-10-motos-mais-vendidos-em-abril-de-2018.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/veja-os-10-carros-e-10-motos-mais-vendidos-em-abril-de-2018.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/4lVB-zt2-M0Qjoqhz1Ho2pmbYec=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/T/f/Yhrp82Qgu5Umgu5IF5qg/arteportemplate-abrvale.png" /><br /> ]]>  Hyundai HB20 retoma a vice-liderança, que tinha sido perdida para o Ford Ka. O Hyundai HB20 retomou a vice-liderança entre os carros zero mais vendidos no Brasil em abril, informou a federação dos concessionários, a Fenabrave. 
O posto tinha sido ocupado pelo Ford Ka no mês anterior. "Vendo" a briga de longe, o Chevrolet Onix segue no topo do ranking.
O mesmo acontece entre as motos, com o domínio da Honda CG 160 - o modelo mais vendido do país é alvo de um recente recall de 160 mil unidades por falha na suspensão dianteira.
Veja os carros e motos mais vendidos em abril de 2018
 G1
No geral, as vendas de veículos - automóveis, comerciais leves (picapes e furgões), caminhões e ônibus - subiram 38,5% em abril frente ao mesmo período do ano anterior. </description>  <media:content url="https://s2.glbimg.com/4lVB-zt2-M0Qjoqhz1Ho2pmbYec=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/T/f/Yhrp82Qgu5Umgu5IF5qg/arteportemplate-abrvale.png" medium="image"/>  <category>G1</category> <pubDate>Thu, 03 May 2018 09:00:21 -0000</pubDate> </item>  <item> <title>Vendas de veículos crescem 38,5% em abril, diz Fenabrave</title> <link>https://g1.globo.com/carros/noticia/vendas-de-veiculos-crescem-385-em-abril-diz-fenabrave.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/vendas-de-veiculos-crescem-385-em-abril-diz-fenabrave.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/4lVB-zt2-M0Qjoqhz1Ho2pmbYec=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/T/f/Yhrp82Qgu5Umgu5IF5qg/arteportemplate-abrvale.png" /><br /> ]]>  Resultado é na comparação com 1 ano atrás; no acumulado, alta é de 21% sobre 2017. Veja a lista do 10 carros mais vendidos no mês. Venda de veículos cresce 34,8% em abril
As vendas de veículos novos subiram 38,53% em abril, na comparação com 1 ano atrás. Foram emplacados 217.359 automóveis, comerciais leves (picapes e furgões), caminhões e ônibus, segundo informou a federação dos concessionários, a Fenabrave, nesta quarta-feira (2).
No acumulado do ano, a alta é de 21,3% sobre janeiro a abril de 2017, com 762.849 veículos vendidos.
Por segmentos
O segmento que mais cresceu nas vendas foi o de caminhões, com 6.223 unidades emplacadas em abril, volume 78,4% maior do que o do mesmo período de 2017. 
O segundo foi o de comerciais leves: as vendas de picapes e furgões subiram 50% no mês, também na comparação com 1 ano antes., somando 31.296 unidades.
Motos
Contadas à parte, as vendas de motos aumentaram 26,5% em abril, com 82.152 unidades. No ano, a alta é de 9,2%, totalizando 301.542 emplacamentos.
Mais vendidos
Veja os carros e motos mais vendidos em abril de 2018
 G1
No acumulado do ano, o Onix continua sozinho na liderança, com 58.390 emplacamentos. Na briga pelo segundo lugar, o Hyundai HB20 retomou o posto, com 33.618 unidades vendidas contra 32.790 do Ford Ka, que era o vice até março.
Nenhum SUV aparece no ranking dos 10 mais vendidos. O mais bem colocado é o Jeep Compass, com 17.584 emplacamentos no ano, em 11º lugar. Ele também foi o mais vendido no mês (4.606 unidades).
O Nissan Kicks (3.701), que tinha liderado o segmento em março e ficado em 9º no geral, perdeu também de Jeep Renegade (4.462) e Hyundai Creta (3.785), foi o 20º carro mais vendido em abril. </description>  <media:content url="https://s2.glbimg.com/4lVB-zt2-M0Qjoqhz1Ho2pmbYec=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/T/f/Yhrp82Qgu5Umgu5IF5qg/arteportemplate-abrvale.png" medium="image"/>  <category>G1</category> <pubDate>Wed, 02 May 2018 20:49:55 -0000</pubDate> </item>  <item> <title>Design italiano é inspiração para o Fiat Cronos</title> <link>https://g1.globo.com/carros/especial-publicitario/fiat-cronos/noticia/design-italiano-e-inspiracao-para-o-fiat-cronos.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/especial-publicitario/fiat-cronos/noticia/design-italiano-e-inspiracao-para-o-fiat-cronos.ghtml</guid> <description>  Sedã chega com pegada esportiva, linhas dinâmicas e conforto para os ocupantes.  O design italiano, conhecido pelas linhas atraentes e musculosas, foi a inspiração para o visual do Fiat Cronos. O sedã chega ao mercado com linhas que unem todos os elementos da carroceria, pegada esportiva e interior espaçoso, confortável e funcional.
A dianteira do Fiat Cronos chama atenção pelo capô alongado e muscular, os para-choques dinâmicos que se aliam às asas laterais, guias de LED e centro cromado. A percepção de volume é reforçada pela traseira elevada e larga. Todos esses elementos são interligados, dando ao carro um perfil alongado.
Por dentro, o que chama atenção é o conforto do Cronos, que tem bancos que dão a sensação de abraçar os ocupantes. O acabamento de qualidade superior é um diferencial na categoria e conta com detalhes como o apoio para os braços entre os bancos dianteiros, que ainda garante mais comodidade para o motorista.
O Fiat Cronos, novo sedã da marca, conta ainda com amplo porta-malas, um dos maiores da categoria. Ele vem ainda com itens de segurança como o Isofix para fixar cadeirinhas de criança, tecnologia superior na Central Multimídia, entre outros.
Veja mais detalhes no vídeo:
Design italiano é inspiração para o Fiat Cronos </description>  <category>G1</category> <pubDate>Wed, 02 May 2018 20:05:38 -0000</pubDate> </item>  <item> <title>Toyota abre mais de 800 vagas com criação do terceiro turno em Sorocaba e Porto Feliz</title> <link>https://g1.globo.com/sp/sorocaba-jundiai/concursos-e-emprego/noticia/toyota-abre-mais-de-800-vagas-com-criacao-do-terceiro-turno-em-sorocaba-e-porto-feliz.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/sp/sorocaba-jundiai/concursos-e-emprego/noticia/toyota-abre-mais-de-800-vagas-com-criacao-do-terceiro-turno-em-sorocaba-e-porto-feliz.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/VxSzmZ53EPgXj_78zHa_NibQrPc=/s.glbimg.com/jo/g1/f/original/2012/08/09/fabricatoyota.jpg" /><br /> ]]>  Novidade foi anunciada oficialmente nesta quarta-feira (2). Novo turno é inédito em fábricas da Toyota no Brasil e deve começar em novembro deste ano. Capacidade produtiva passará de 108 mil para 160 mil anualmente. Mais de 800 pessoas devem ser contratadas para as plantas da Toyota em Sorocaba e Porto Feliz
Divulgação
A montadora Toyota anunciou nesta quarta-feira (2) a criação do terceiro turno nas fábricas de Sorocaba e Porto Feliz (SP). Segundo a empresa, o novo turno é inédito no Brasil.
A produção deve começar em novembro deste ano, gerando 740 empregos direitos em Sorocaba, 130 em Porto Feliz e cerca de 700 vagas em contratações em fornecedores de peças (vagas indiretas).
Toyota Yaris será produzido na fábrica de Sorocaba (SP)
Divulgação/Toyota
A demanda é para atender a produção do Etios e também do novo compacto Yaris, previsto para ser comercializado no segundo semestre deste ano. Segundo a empresa, as fábricas estão se adaptando para o início da produção no compacto.
Com a abertura das novas vagas, a capacidade produtiva da Toyota passará dos atuais 108 mil unidades para 160 mil veículos anualmente.
Etios já é produzido nas fábricas de Sorocaba e Porto Feliz
Divulgação/Toyota
De acordo com o sindicato da categoria, a montadora afirmou que haverá aumento de 37% no número de trabalhadores na unidade de Sorocaba e 30% na planta de Porto Feliz. 
Conforme divulgado pela Toyota durante o anúncio do terceiro turno, 320 funcionários que estavam contratados por tempo determinado foram efetivados nos cargos.
O sindicato afirma que as negociações com a empresa para a criação do novo turno de produção foram aprovadas com os trabalhadores na assembleia realizada em fevereiro. 
Currículos
Interessados em trabalhar na empresa podem cadastrar o currículo no site da Toyota na opção "trabalhe conosco", localizada no menu inferior. 
Representantes da Toyota e do Sindicato dos Metalúrgicos se reuniram em Sorocaba
Divulgação/SMetal
O presidente da montadora Toyota do Brasil, Rafael Chang, esteve com o presidente Michel Temer nesta tarde no Palácio do Planalto para falar sobre a implantação do terceiro turno e contratação de mais de 800 vagas diretas e outras 700 indiretas.
Além de Chang, o ministro da Indústria, Comércio exterior e Serviços, Marcos Jorge, e o vice-presidente da Toyoya do Brasil, Celso Simomura, participaram do encontro.
"Este é um sinal do compromisso que a Toyota tem com o Brasil, com o desenvolvimento do Brasil, geração de emprego e trazendo as tecnologias", disse Chang.
Marcos Jorge afirmou que o governo recebeu com "muita alegria" a implementação do terceiro turno. "Isso é sinal de que não apenas a economia, mas o setor automotivo, especificamente, tem reagido muito bem", comemorou Marcos Jorge.
Questionado sobre a data de lançamento do novo regime automotivo, o Rota 2030, o ministro disse que as conversas entre governo e setor continuam e que Temer deve anunciá-lo nos próximos dias.
"Estamos trabalhando nossa equipe junto com a Fazenda nesta semana, em conjunto com as entidades que representam a cadeia produtiva e também os importadores porque a regra será a mesma para importação  e para a produção nacional. Então, estamos trabalhando nesta semana para que nos próximos dias o presidente já tenha condição de fazer o anúncio", explicou o ministro.
Sobre o Rota 2030, Rafael Chang afirmou que o novo regime vai tornar o Brasil mais competitivo. "A Rota 2030 vai dar muitos componentes de competitividade para o Brasil: segurança, eficiência enérgica e, sobretudo, novas tecnologias, como híbridos e elétricos", finaliza Chang. 
O Rota 2030 deverá trazer novidades como incentivos à produção de veículos elétricos e híbridos e ao aumento da segurança dos veículos.
Veja mais notícias na página de Concursos e Emprego </description>  <media:content url="https://s2.glbimg.com/VxSzmZ53EPgXj_78zHa_NibQrPc=/s.glbimg.com/jo/g1/f/original/2012/08/09/fabricatoyota.jpg" medium="image"/>  <category>G1</category> <pubDate>Wed, 02 May 2018 19:51:42 -0000</pubDate> </item>  <item> <title>GM põe 2,6 mil trabalhadores em férias coletivas por 14 dias em São José, SP</title> <link>https://g1.globo.com/sp/vale-do-paraiba-regiao/noticia/gm-poe-26-mil-trabalhadores-em-ferias-coletivas-por-14-dias-em-sao-jose-sp.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/sp/vale-do-paraiba-regiao/noticia/gm-poe-26-mil-trabalhadores-em-ferias-coletivas-por-14-dias-em-sao-jose-sp.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/FaSih-Ps1dSw-NKW-75qgnvuL-I=/s.glbimg.com/jo/g1/f/original/2017/02/13/general_motors.jpg" /><br /> ]]>  Empregados retornam ao trabalho no dia 16 de maio. Parada é para manutenção de máquinas da linha da caminhonete S10, diz o Sindicato dos Metalúrgicos. GM põe 2,2 mil funcionários em férias coletivas em São José dos Campos
Reprodução/TV Vanguarda
A General Motors deu férias coletivas, por 14 dias, a 2,6 mil trabalhadores a partir desta quarta-feira (2) . A informação é do Sindicato dos Metalúrgicos.
As atividades foram interrompidas para os funcionários da linha da caminhonete S10. De acordo com o sindicato, a medida foi adotada para manutenção do maquinário. O retorno dos empregados está previsto para 16 de maio.
A montadora em São José emprega cerca de 5 mil trabalhadores e produz os modelos S10 e Trailblazer. 
O G1 procurou a GM e aguardava o retorno até a publicação desta reportagem.  </description>  <media:content url="https://s2.glbimg.com/FaSih-Ps1dSw-NKW-75qgnvuL-I=/s.glbimg.com/jo/g1/f/original/2017/02/13/general_motors.jpg" medium="image"/>  <category>G1</category> <pubDate>Wed, 02 May 2018 12:00:18 -0000</pubDate> </item>  <item> <title>Honda relança a Monkey, minimoto popular nos anos 70</title> <link>https://g1.globo.com/carros/motos/noticia/honda-relanca-a-monkey-minimoto-popular-nos-anos-70.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/motos/noticia/honda-relanca-a-monkey-minimoto-popular-nos-anos-70.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/5yt02Chyrn2RWl2gTCx7-EfCCiI=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/u/A/HbRItZTIaFfilIBCU5Mw/129342-honda-monkey-2018.jpg" /><br /> ]]>  Modelo começou como moto de brinquedo para crianças em 1961, mas virou ícone. Veja a evolução da Monkey até os dias de hoje.  Honda Monkey 2018
Honda/Divulgação
Criada em 1961 para ser um brinquedo para crianças, a Honda Monkey acaba de ser relançada na Europa em uma versão moderna. A minimoto foi muito popular nos anos 70 e virou um ícone, graças ao seu diminuto tamanho e rodas de apenas 8 polegadas. 
A nova Monkey utiliza como base a sua "irmã moderna", a MSX, da qual herdou o motor de 125 cc e 9,5 cavalos de potência máxima. O câmbio é de 4 marchas. De acordo com a marca, o consumo pode chegar a 67 km/l.
Honda Monkey 2018
Honda/Divulgação
Mantendo o visual clássico, o modelo agora tem injeção eletrônica, luzes de LED e ganhou até painel de LCD. Com rodas maiores, de 12 polegadas, a Monkey 125 recebeu até freios a disco e com sistema ABS.
Para se ter uma ideia, a Monkey 2018 tem apenas 1.700 mm de comprimento, 755 mm de largura e 1.029 m de altura. Além disso, seu entre-eixos é de 1.155 mm.  
Uma CG 160, por exemplo, tem 1.996 mm de comprimento, 739 mm de largura, 1.087 mm de altura e 1.314 mm de entre-eixos.
Monkey 2018 tem até painel digital
Honda/Divulgação
Veja evolução da Honda Monkey:
1961
Primeira Monkeytinha rodas de 5 polegadas e motor de 49 cc
Honda/Divulgação
1963
Primeira versão de rua, de 1963, foi vendida nos EUA e na Europa
Honda/Divulgação
1967
Primeiro modelo vendido no Japão, em 1967
Honda/Divulgação
1970
Modelo fica articulado para poder ser levado em porta-malas, em 1970
Honda/Divulgação
1978
É criada a primeira versão com tanque em forma de "lágrima"
Honda/Divulgação
1984
É lançada versão limitada Golden
Honda/Divulgação
1987
Monkey ganha versão mais esportiva com chassi diferenciado 
Honda/Divulgação
1991
Em 1991, até uma opção de rali foi lançada
Honda/Divulgação
2004
Baseada nas cores da CB 750F de Freddie Spencer, é lançada uma versão limitada da Monkey em 2004
Honda/Divulgação
2009
Em 2009, é lançada a primeira Monkey com Injeção eletrônica
Honda/Divulgação
2017
Versão do aniversário de 50 anos é lançada no Japão
Honda/Divulgação
2018
Monkey é renovada e ganha motor de 125 cc
Honda/Divulgação </description>  <media:content url="https://s2.glbimg.com/5yt02Chyrn2RWl2gTCx7-EfCCiI=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/u/A/HbRItZTIaFfilIBCU5Mw/129342-honda-monkey-2018.jpg" medium="image"/>  <category>G1</category> <pubDate>Mon, 30 Apr 2018 20:57:30 -0000</pubDate> </item>  <item> <title>Volkswagen negocia parceria com rival chinesa do Uber</title> <link>https://g1.globo.com/carros/noticia/volkswagen-negocia-parceria-com-rival-chinesa-do-uber.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/volkswagen-negocia-parceria-com-rival-chinesa-do-uber.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/-s02SWETIQbIUIYPB2obc28dAVI=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/V/0/NrBG2CR26xN8mEuKXchQ/ap18115472578957.jpg" /><br /> ]]>  Fabricante alemã quer se associar com a Didi Chuxing, que comprou o controle da brasileira 99 recentemente. Elevador de carros na sede da Volkswagen em Wolfsburg, na Alemanha
Michael Sohn/AP
A Volkswagen, maior montadora do mundo, está negociando uma joint venture com a chinesa Didi Chuxing para gerenciar parte da frota de carros da empresa de transportes urbanos e ajudar a desenvolver veículos voltados para os serviços de transporte por aplicativo.
A Didi comprou as operações do Uber na China em 2016, mas trava uma batalha com a rival também em outros mercados. Em janeiro deste ano, a empresa chinesa adquiriu o controle da brasileira 99.
Como parte do acordo, que deve ser assinado no início do próximo mês, a montadora alemã vai inicialmente gerenciar uma frota de cerca de 100 mil veículos para a Didi, da qual dois terços será de carros do grupo Volkswagen, disse um executivo da montadora.
A Volkswagen também vai comprar alguns carros novos com a Didi para permitir que a chinesa aumente sua frota. As duas planejam, eventualmente, colaborar para criar e desenvolver veículos, disse ele, falando na condição de anonimato uma vez que os detalhes ainda são privados.
O executivo não deu detalhes financeiros do acordo, mas disse que a Volkswagen terá uma fatia da receita quando a parceria se desenvolver.
A crescente popularidade dos serviços de transporte por aplicativo em cidades congestionadas como Pequim e Xangai está mostrando sinais iniciais de diminuição de carros privados. 
Isso poderia ter sérias consequências para as montadoras existentes e está forçando empresas como a Volkswagen a reinventarem seus negócios e buscarem futuras fontes de receita.
"Para ser bem-sucedido como uma empresa de carros nesse novo ecossistema, nós precisamos saber quem é nosso consumidor, qual seu destino e qual deveria ser nossa estratégia", disse o executivo.
Ele acrescentou que esse acordo vai eventualmente dar à Volkswagen acesso a alguns dos volumosos dados de comportamento do consumidor coletados por meio de 3 milhões de viagens que a Didi realiza na China a cada dia.
O objetivo final é a redução e o uso de carros autônomos, disse o executivo da Volkswagen.
Imagem de arquivo do logo da empresa Didi Chuxing em sua sede em Pequim, China
Reuters/Kim Kyung-Hoon/Arquivo
A parceria da Volkswagen com a Didi é o primeiro projeto conhecido que a Didi começou a buscar como parte de aliança ampla que a empresa chinesa formou recentemente com 31 montadoras e fornecedoras de peças.
A Didi disse que formou a aliança para colaborar, entre outras coisas, em eventualmente desenvolver carros especialmetne para seus serviços. 
Por exemplo, até 80% dos clientes da Didi realizam viagens sozinhos e não precisam de um carro grande de quatro lugares, disse o executivo da Volkswagen.
Os veículos atuais têm motores e outras tecnologias que permitem que eles andem em velocidades mais rápidas, enquanto carros especialmente produzidos para o transporte permitiriam velocidades mais lentas e, portanto, não precisariam ser aerodinâmicos ou ter motores poderosos. Isso permitiria carros com menos assentos e mais espaço para bagagem.
Três funcionários da Didi disseram que o formato final para um mercado de transporte urbano por aplicativo ainda é incerto e ninguém sabe o papel que as montadoras e a própria Didi terão. Eles não quiseram ser identificados porque não têm autorização para falar com repórteres.
Questões abertas para a Didi agora são como consertar, manter e direcionar uma frota de veículos autônomos, disse uma das fontes.
"Nosso entendimento agora é que provavelmente as montadoras não sabem 100% sobre como fazer tudo isso. A Didi também não sabe", disse o funcionário.
Um porta-voz da Didi disse que os dois lados ainda estavam trabalhando nos detalhes de como seria a parceria.
"Potencialmente, ambos irão voltar as atenções em construir juntos um negócio de operação de frota e avançar em outras áreas potenciais como criação de novos modelos de carros para transporte urbano", disse o porta-voz. </description>  <media:content url="https://s2.glbimg.com/-s02SWETIQbIUIYPB2obc28dAVI=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/V/0/NrBG2CR26xN8mEuKXchQ/ap18115472578957.jpg" medium="image"/>  <category>G1</category> <pubDate>Mon, 30 Apr 2018 16:13:54 -0000</pubDate> </item>  <item> <title>Elegância e potência são marcas do SUV New Tucson</title> <link>https://g1.globo.com/carros/especial-publicitario/caoa/noticia/elegancia-e-potencia-sao-marcas-do-suv-new-tucson.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/especial-publicitario/caoa/noticia/elegancia-e-potencia-sao-marcas-do-suv-new-tucson.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/kQRLRmiecWdGK-xWXlUoayuVAFg=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/D/R/taZvqsRjiQvUuSs1NTXQ/infografico-hyundaitucsonv4-ajustado.png" /><br /> ]]>  Mais recente versão do carro da Hyundai possui motor Turbo, teto solar panorâmico e mudanças no design Hyundai Tucson fica mais econômico
Quem procura um SUV está em busca de um carro que consiga unir robustez, força, conforto e elegância. E é justamente essa a pegada do Hyundai New Tucson Turbo GDi. Com motorização turbo, design moderno, interior amplo e acabamento superior (Premium), o carro conquista muitos clientes dentro do universo de SUV no mercado brasileiro.
A potência é um dos elementos mais importantes em um carro como o New Tucson e para isso ele está equipado com um motor Turbo GDi 1.6. Com 177 CV e torque de 27 kgfm, a nova motorização, movida a gasolina, tem injeção direta e é eficiente e econômica. O SUV é equipado com transmissão Dual-Clutch de 7 velocidades, com design leve e com recursos tecnológicos avançados que ajudam na economia de combustível e contribuem para baixas emissões de CO².
O design é outro ponto forte do New Tucson. Imagine pegar a estrada em um dia de céu limpo e poder aproveitar toda a vista. No New Tucson é possível graças ao seu teto solar panorâmico, que oferece uma experiência única para os ocupantes. A frente do carro possui elementos como a grade frontal cromada e faróis em LED. Aliás, o LED está também nas lanternas traseiras e no pisca dos retrovisores. O carro conta também com rodas de liga leve de 17” ou 18”, de acordo com o modelo, estepe de alumínio e na traseira ainda chamam atenção o aerofólio e a antena shark.
Segurança para motorista e passageiros
A segurança é outro elemento importante no New Tucson, que possui seis airbags: dois dianteiros, dois laterais e dois de cortina. Elementos como os controles de estabilidade e de tração também estão presentes para ajudar o motorista quando ocorrerem situações adversas, e o assistente de aclive e declive facilita arrancadas em terrenos íngremes.
Sabe os pontos cegos que tanto incomodam quem dirige? Isso foi solucionado no New Tucson. O SUV da Hyundai está equipado com o detector de ponto cego, que através de áreas de monitoramento nas laterais e na traseira alertam o motorista caso haja outro veículo ou objeto fora da vista. Os faróis dianteiros possuem feixe direcional para curvas durante a noite, o que melhora a visibilidade. A câmera de ré ajuda nas manobras, assim como o Assistente de Estacionamento (PAS), localizado nos para-choques dianteiro e traseiro.
Interior requintado e tecnológico
Para entrar no New Tucson ou guardar objetos no porta-malas basta estar com a chave no bolso e se aproximar do carro, que têm abertura automática. Por dentro, o SUV tem amplo e confortável espaço interno e grande bagageiro, com capacidade para 513 litros. A elegância é marcante e pode ser vista no acabamento dos bancos, do volante multifuncional e da manopla de câmbio, revestidos de couro.
O carro é equipado com uma Central Multimídia de 7” e tela touch, onde pode-se conectar o Android Auto e o Apple CarPlay, acessar o GPS, a câmera de ré, música, entre outros. 
Ficou curioso? Veja mais detalhes sobre carro no infográfico abaixo:

Divulgação </description>  <media:content url="https://s2.glbimg.com/kQRLRmiecWdGK-xWXlUoayuVAFg=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/D/R/taZvqsRjiQvUuSs1NTXQ/infografico-hyundaitucsonv4-ajustado.png" medium="image"/>  <category>G1</category> <pubDate>Mon, 30 Apr 2018 13:37:59 -0000</pubDate> </item>  <item> <title>PRF flagra mais de 2 motoristas por minuto em excesso de velocidade no DF</title> <link>https://g1.globo.com/df/distrito-federal/noticia/prf-flagra-mais-de-2-motoristas-por-minuto-em-excesso-de-velocidade-no-df.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/df/distrito-federal/noticia/prf-flagra-mais-de-2-motoristas-por-minuto-em-excesso-de-velocidade-no-df.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/4CBdYbdswy6IAeuDOSG4CdPtq-8=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/b/0/1Eb3nhTwuDDbYUxmBBFQ/prf-velocidade-1.gif" /><br /> ]]>  Operação Dia do Trabalhador começou na sexta (27). Em menos de 3 horas, 325 motoristas foram multados na BR 060 que liga Brasília a Goiânia. Radar da PRF flagra motorista a 134 Km/h durante Operação Dia do Trabalhador, no DF
PRF/Divulgação
Nas primeiras duas horas e meia da Operação Dia do Trabalhador, que começou nesta sexta-feira (27), a Polícia Rodoviária Federal (PRF) flagrou, em um único ponto da BR 060 – que liga Brasília a Goiânia (GO) – 325 motoristas dirigindo em velocidade acima do permitido. Em média, foram 2,16 infrações por minuto.
A operação, que vai até o feriado de 1º de maio em todo o país, reforçou a fiscalização para tentar reduzir infrações como o excesso de velocidade que, de acordo com a PRF,  têm "alto potencial de causar acidentes graves".
Radar da PRF registra veículo a 132 km/h em rodovia onde a velocidade máxima é de 80 km/h
PRF/Divulgação
No local da fiscalização no DF, a velocidade máxima permitida é de 80 Km/h, mas a cada 60 segundos os policiais registraram motoristas a mais de 100 km/h. De acordo com o Código de Trânsito Brasileiro, o excesso de velocidade gera multas que vão de R$ 130 até R$ 880 reais (veja abaixo).
O motorista flagrado leva de 5 até 7 pontos na carteira de habilitação e, em alguns casos, pode até perder o direito de dirigir.
Policial Rodoviário Federal com radar em rodovia do DF
PRF/Divulgação
Código de Trânsito Brasileiro (art. 218)
- Infração média: excesso de velocidade em até 20%, o motorista perde 4 pontos na carteira e paga multa no valor de R$ 130,16
- Infração grave: excesso de velocidade entre 20 e 50%, o motorista perde 5 pontos na carteira e paga multa no valor de R$ 195,23
- Infração gravíssima: excesso de velocidade acima de 50%, o motorista perde 7 pontos na carteira e paga multa no valor de R$ 880,41 e suspensão do direito de dirigir.
Leia mais notícias sobre a região no G1 DF. </description>  <media:content url="https://s2.glbimg.com/4CBdYbdswy6IAeuDOSG4CdPtq-8=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/b/0/1Eb3nhTwuDDbYUxmBBFQ/prf-velocidade-1.gif" medium="image"/>  <category>G1</category> <pubDate>Sat, 28 Apr 2018 16:35:29 -0000</pubDate> </item>  <item> <title>Diesel ainda 'respira': Bosch promete sistema que reduz poluente e Volkswagen lança novo motor</title> <link>https://g1.globo.com/carros/noticia/diesel-ainda-respira-bosch-promete-sistema-que-reduz-poluente-e-volkswagen-lanca-novo-motor.ghtml</link> <guid isPermaLink="true">https://g1.globo.com/carros/noticia/diesel-ainda-respira-bosch-promete-sistema-que-reduz-poluente-e-volkswagen-lanca-novo-motor.ghtml</guid> <description>  <![CDATA[ <img src="https://s2.glbimg.com/PT0-hr1jFtdWTMPdjdns7ejqmPU=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/c/t/30g0LDSqSDFoVckwzQsw/bosch.jpg" /><br /> ]]>  Escândalo dos motores da Volkswagen colocou o combustível em xeque, mas ele continua sendo alvo de investimentos da indústria automotiva.  Volkswagen Golf é testado com novo sistema de exaustão da Bosch que promete reduzir emissão de poluentes
Michael Dalder/Reuters
Pouco mais de 2 anos após o escândalo do motores da Volkswagen vir à tona, o diesel continua em xeque, mas não foi abandonado. Nesta semana, Bosch e a própria Volks anunciaram novidades relacionadas ao combustível.
A Bosch, também envolvida no "dieselgate", diz ter conseguido criar um sistema que reduz as emissões de poluentes nesses motores.
A fornecedora afirma ter criado um sistema de exaustão que permite reduzir as emissões de nitrato de amônio (NOx), principal poluente do diesel, a um décimo do limite legal. E, segundo a Bosch, não é necessária a instalação de nenhum equipamento para isso.
Fornecedora das principais montadoras do mundo, a empresa diz ter uma "oportunidade de levar o debate acalorado sobre o diesel a um outro território".
Novo motor
Apesar de agora investir maciçamente em carros elétricos, na última quinta-feira (26), a Volkswagen apresentou um novo motor turbo a diesel (TDI), chamado EA288 Evo, de 2.0 litros. Ele seria a evolução do propulsor de mesmo nome.
Segundo a montadora, o motor vai atender aos padrões atuais de emissão e também ao futuro, que será mais rígido. Associado com uma espécie de gerador, que ajuda em situações como a partida, formando o chamado sistema híbrido leve, ele também poderá ter menor consumo de combustível.
A potência do EA288 Evo vai variar de 137 cv a 207 cv, diz a montadora, e o motor vai estrear em carros da Audi e, posteriormemte, equipará modelos da Volkswagen feitos sobre a plataforma MQB, a mesma do Golf.
Banimento ao diesel
As vendas de carrros movidos a diesel caíram na Europa e, mais drasticamente, nos Estados Unidos. Além do mais, cidades como Paris, Madri, Atenas e Cidade do México têm planos de banir veículos a diesel até 2025.
A conta do escândalo para a Volkswagen já chegou a US$ 30 bilhões. O grupo, por outro lado, é o que mais vende carros no mundo há 2 anos.
A Bosch, recentemente, anunciou que pagará US$ 327,5 milhões de indenização nos EUA a proprietários de carros que tinham o programa de computador que burlava os resultados de testes de emissão.
A empresa é acusada de ter fornecido equipamento e ajudado a Volkswagen a dissimular a existência do software. Com ele, carros só atendiam os níveis permitidos de emissão quando estava em condições de teste. </description>  <media:content url="https://s2.glbimg.com/PT0-hr1jFtdWTMPdjdns7ejqmPU=/i.s3.glbimg.com/v1/AUTH_59edd422c0c84a879bd37670ae4f538a/internal_photos/bs/2018/c/t/30g0LDSqSDFoVckwzQsw/bosch.jpg" medium="image"/>  <category>G1</category> <pubDate>Sat, 28 Apr 2018 15:00:17 -0000</pubDate> </item>  </channel>  </rss>";}')); /* Child Type: integer */ $data['createdOn'] = 1525795140;