Americká technologická společnost Apple uskuteční v USA další investice ve výši sta miliard dolarů (2,1 bilionu korun). Oznámil to ve středu šéf firmy Tim Cook při setkání v Bílém domě s americkým prezidentem Donaldem Trumpem. Trump zároveň oznámil záměr zavést stoprocentní clo na polovodiče z dovozu.
Zálohovací server Proxmox Backup Server byl vydán v nové stabilní verzi 4.0. Založen je na Debianu 13 Trixie.
Byla vydána nová verze 1.54.0 sady nástrojů pro správu síťových připojení NetworkManager. Novinkám se v příspěvku na blogu NetworkManageru věnuje Jan Václav.
Knižní edice správce české národní domény přináší novou knihu zkušeného programátora Pavla Tišnovského s názvem Programovací jazyk Go. Publikace nabízí srozumitelný a prakticky zaměřený pohled na programování v tomto moderním jazyce. Nejedná se však o klasickou učebnici, ale spíše o průvodce pro vývojáře, kteří s Go začínají, nebo pro ty, kdo hledají odpovědi na konkrétní otázky či inspiraci k dalšímu objevování. Tištěná i digitální verze knihy je již nyní k dispozici u většiny knihkupců.
OpenAI zpřístupnila (en) nové nenáročné otevřené jazykové modely gpt-oss (gpt-oss-120b a gpt-oss-20b). Přístupné jsou pod licencí Apache 2.0.
Byla vydána RC verze openSUSE Leap 16. S novým instalátorem Agama, Xfce nad Waylandem a SELinuxem.
Google Chrome 139 byl prohlášen za stabilní. Nejnovější stabilní verze 139.0.7258.66 přináší řadu novinek z hlediska uživatelů i vývojářů. Podrobný přehled v poznámkách k vydání. Opraveno bylo 12 bezpečnostních chyb. Vylepšeny byly také nástroje pro vývojáře. S verzí 139 přestal být podporován Android 8.0 (Oreo) a Android 9.0 (Pie).
Společnost JetBrains se stala platinovým sponzorem multiplatformního open source herního enginu Godot. K vývoji her lze používat Rider for Godot. Zdarma pro nekomerční účely.
Byla vydána verze 9.0 open source virtualizační platformy Proxmox VE (Proxmox Virtual Environment, Wikipedie) založené na Debianu. Verze 9.0 je založena na Debianu 13 Trixie. Přehled novinek v poznámkách k vydání a informačním videu.
Operátor O2 dává všem svým zákazníkům s mobilními službami poukaz v hodnotě 300 Kč na nákup telefonu nebo příslušenství jako omluvu za pondělní zhoršenou dostupnost služeb.
Jak uvedl kolega vyse, retezce typu string (v c++) lze scitat. Pro C-ckovske retezece (char *) musite alokovat pamet (nebo proste nejak pripravit zapisovatelny dostatecne velky cilovy buffer), viz nize.
AbcLinuxu.cz
ITBiz.cz
HDmag.cz
AbcPráce.cz
22.9.2008 06:29
char *mystrcat(char *str1, char *str2)
{
char *str;
if (!str1) str1 = "";
if (!str2) str2 = "";
str = malloc(strlen(str1) + strlen(str2) + 1);
if (str) sprintf(str, "%s%s", str1, str2);
return str;
}
...
char *a = "prvni";
char *b = "druhy";
char *c = mystrcat(a, b);
printf("cat: %s\n", c);
free(c);
...
22.9.2008 12:44
Luboš Doležel (Doli) | skóre: 98
| blog: Doliho blog
| Kladensko
while(1) {
buf[i] = getdata();
if (buf[i] == '\n') {
break;
}
i++;
}
buf[i+1] = 0;
buf == "napis", tak neporovnáváš obsah řetězce buf s druhým řetězcem, ale porovnáváš pointer buf (tedy adresu kam míří) s adresou umístění statického řetězce "napis", který je umístěn někde úplně jinde. Není to prostě "hluboké" porovnávání, jen porovnávání adres. Musíš použít něco jako strcmp.
Kdyby to bylo v C++ a buf by byl std::string, pak by to fungovalo, protože tam tento operátor přetížen je.
while (1) {
i=0;
while(1) {
buf[i] = getdata();
if (buf[i] == '1') {
break;
}
i++;
}
if (!strcmp(buf,"l1")) {
print("equal");
}
}
buf[i+1]='\0'. Protože pokud je jednou načteno "llll1" a podruhé "l1", funkce strcmp uvidí, že data se shodují ve společné části (tedy "l1"), ale uvidí nakonec taky, že za "l1" v buf nenásleduje '\0', tedy že řetězec v buf za "l1" pokračuje ("l1ll1...") - takže ty řetězce nejsou shodné. Proto to může hrát roli.
Stejně je ale kód nekorektní - nikde není prováděna kontrola toho, jestli se data nenačítají tak dlouho, že budou zapisovaná i mimo pamět pro buffer "buf". Takže pokud je buf zadeklarován něco jako char buf[BUFSIZE];, tak ještě je nutné přidat do prvního "if"u další kontrolu:
if (buf[i] == '1' || i >= BUFSIZE - 1)
O jedno méně proto, že na posledním znaku musí být '\0'.
vim ~/.emacs
if (!strcmp(buf,"s1on")) { print("zapinam zarizeni 1\n"); }
if (!strcmp(buf,"s1off")) { print("vypinam zarizeni 1\n"); }
if (!strcmp(buf,"s2on")) { print("zapinam zarizeni 2\n"); }
if (!strcmp(buf,"s2off")) { print("vypinam zarizeni 2\n"); }
Pokud dostane s2off, tak mi vypise jen "vypinam zarizeni". U ostatnich voleb to vypisuje vsechno.
print? Nemá to být printf? Pak to půjde.
void print (char *string){
while (*string) {
while (!(UCSRA & (1 << UDRE)));
UDR = *string;
string++;
}
string = 0;
return;
}
, a pak začít používat std::string
vim ~/.emacs
i = 1;
if (i) {
print("zapinam zarizeni 1\n");
print("zapinam zarizeni 2\n");
print("zapinam zarizeni 3\n");
print("zapinam zarizeni 4\n");
print("zapinam zarizeni 5\n");
print("zapinam zarizeni 6\n");
}
ale toto už nevypíše všechny printy:
print(buf)
i = 1;
if (i) {
print("zapinam zarizeni 1\n");
print("zapinam zarizeni 2\n");
print("zapinam zarizeni 3\n");
print("zapinam zarizeni 4\n");
print("zapinam zarizeni 5\n");
print("zapinam zarizeni 6\n");
}
Problém nastává, kdykoliv se snažím jakkoliv přečíst buf. Proč?
char buf[10]; - vypíše se potom toho víc než při char buf[20];Takže problém s pamětí. Jak to obejít?
i = ReceiveByte();
buf[0] = 'a';
buf[1] = 'n';
buf[2] = 'o';
buf[3] = 'n';
buf[4] = 'y';
buf[5] = 'm';
buf[6] = 0;
print(buf[0]);
print(buf[1]);
print(buf[2]);
print(buf[3]);
print(buf[4]);
print(buf[5]);
if (i) {
print("zapinam zarizeni 1\n");
print("zapinam zarizeni 2\n");
print("zapinam zarizeni 3\n");
print("zapinam zarizeni 4\n");
print("zapinam zarizeni 5\n");
print("zapinam zarizeni 6\n");
}
vrati:
apinam zarizeni 1
ni 1
i 1
ni 1
am zarizeni 2
eni 1
zapinam zarizeni 1
zapinam zarizeni 2
zapinam zarizeni 3
zapinam zarizeni 4
zapinam zarizeni 5
zapinam zarizeni 6
apinam zarizeni 1
ni 1
i 1
ni 1
am zarizeni 2
eni 1
zapinam zarizeni 1
zapinam zarizeni 2
zapinam zarizeni 3
zapinam zarizeni 4
zapinam zarizeni 5
zapinam zarizeni 6
print("zapinam zarizeni 1\n");
print("zapinam zarizeni 2\n");
print("zapinam zarizeni 3\n");
print("zapinam zarizeni 4\n");
print("zapinam zarizeni 5\n");
print("zapinam zarizeni 6\n");
funguje, ale
print("zapinam zarizeni 1\n");
print("zapinam zarizeni 2\n");
print("zapinam zarizeni 3\n");
print("zapinam zarizeni 4\n");
print("zapinam zarizeni 5\n");
print("zapinam zarizeni 6\n");
print("zapinam zarizeni 7\n");
už ne
void print (char string[20]){
while (string[20]) {
while (!(UCSRA & (1 << UDRE)));
UDR = string[20];
string++;
}
return;
free(string);
}
Jak mam fci print upravit?
Tak už vím, že problém dělá fce print.
void print (char string[20]){
while (string[20]) {
while (!(UCSRA & (1 << UDRE)));
UDR = string[20];
string++;
}
return;
free(string);
}
Jak mam fci print upravit?
AUUUU!
Vždyť jste sem posílal funkci print, která vypadala mnohem líp (taková ta s těma hvězdičkama bez těch hranatic). Doufám, že to celý nevzniklo jako produkt mechanického nahrazení "*string" za "string[20]", a jestli jo, tak to vraťte (aspoň v té funkci 
)
#include <avr/io.h>
#include <avr/interrupt.h>
#define F_CPU 9216000UL // 9.216 MHz
#include <util/delay.h>
#define sbi(var, mask) ((var) |= (1 << (mask)))
#define cbi(var, mask) ((var) &= ~(1 << (mask)))
/* Prototypes */
void InitUART (unsigned char baudrate);
unsigned char ReceiveByte (void);
void TransmitByte (unsigned char data);
void print (char *string);
unsigned char indata;
int strcmp(char*, char*);
int
main (void)
{
char buf[20]; // may be more if longer strings expected
int i, known, passed;
InitUART (59); /* Set the baudrate to 9600bps using a 9.216MHz crystal */
sbi(DDRD, 2);
sbi(DDRD, 3);
sbi(DDRD, 4);
sbi(DDRD, 5);
sbi(DDRD, 6);
sbi(DDRB, 3);
PORTD = 0;
while (1) {
i = ReceiveByte();
if (i) {
print("zapinam zarizeni 1\n");
print("zapinam zarizeni 2\n");
print("zapinam zarizeni 3\n");
print("zapinam zarizeni 4\n");
print("zapinam zarizeni 5\n");
print("zapinam zarizeni 6\n");
print("zapinam zarizeni 7\n");
}
}
}
/* Initialize UART */
void
InitUART (unsigned char baudrate)
{
/* Set the baud rate */
UBRRL = baudrate;
/* Enable UART receiver and transmitter */
UCSRB = (1 << RXEN) | (1 << TXEN);
/* 8 data bits, 1 stop bit */
UCSRC = (1 << UCSZ1) | (1 << UCSZ0);
}
/* Read and write functions */
unsigned char
ReceiveByte (void)
{
/* Wait for incomming data */
while (!(UCSRA & (1 << RXC)));
/* Return the data */
return UDR;
}
void
TransmitByte (unsigned char data)
{
/* Wait for empty transmit buffer */
while (!(UCSRA & (1 << UDRE)));
/* Start transmittion */
UDR = data;
}
void print (char *string){
while (*string) {
while (!(UCSRA & (1 << UDRE)));
UDR = *string;
string++;
}
string = 0;
return;
}
(některé proměnné jsou zbytečné pozůstatky z různých pokusů)
zarizeni 7 zapinam zarizeni 2 zapinam zarizeni 3 zapinam zarizeni 4 zapinam zarizeni 5 zapinam zarizeni 6 zapinaPokud přidám ještě jedno print, tak to nevrací nic a začne blikat dioda připojená k jednočipu, tudíš asi problém s pamětí či co. Pokud přidám dvě print, tak začne blikat víc diod a jednočip se "zasekne". Pomůže až přemazání a odpojení/připojení napájení.
Doporučil bych to, co jde, vyškubnout (nahradit interakci se sériovou linkou třeba putc()/getc()) a odladit to na PC kde máte debugger a valgrind.Myšlenka je to pěkná, ale hodně chyb se na PC neprojeví (ta, která je v programu níže, je krásný příklad)
print(PSTR("zapinam zarizeni 1\n"));
print(PSTR("zapinam zarizeni 2\n"));
print(PSTR("zapinam zarizeni 3\n"));
print(PSTR("zapinam zarizeni 4\n"));
print(PSTR("zapinam zarizeni 5\n"));
print(PSTR("zapinam zarizeni 6\n"));
print(PSTR("zapinam zarizeni 7\n"));
print(PSTR("zapinam zarizeni 8\n"));
print(PSTR("zapinam zarizeni 9\n"));
print(PSTR("zapinam zarizeni 10\n"));
print(PSTR("zapinam zarizeni 11\n"));
print(PSTR("zapinam zarizeni 12\n"));
....
void print (char *string){
char k;
while ((k=pgm_read_byte(string++))>0) {
while (!(UCSRA & (1 << UDRE)));
UDR = k;
}
return;
}
Funguje bezvadně.
print(PSTR("zapínám zarízení 1\n"));
Pokud se nepletu, tak už to tak bezvadně fungovat nebude.
char ** explode(char separator, char *string)
{
int start = 0, i, k = 1, count = 2;
char **strarr;
for (i = 0; string[i] != '\0'; i++)
/* how many rows do we need for our array? */
if (string[i] == separator)
count++;
/* count is at least 2 to make room for the entire string
* and the ending NULL */
strarr = malloc(count * sizeof(char*));
i = 0;
while (*string++ != '\0')
{
if (*string == separator)
{
strarr[i] = malloc(k - start + 2);
strncpy(strarr[i], string - k + start, k - start + 1);
strarr[i][k - start + 1] = '\0'; /* guarantee null termination */
start = k;
i++;
}
k++;
}
/* copy the last part of the string after the last separator */
strarr[i] = malloc(k - start);
strncpy(strarr[i], string - k + start, k - start - 1);
strarr[i][k - start - 1] = '\0'; /* guarantee null termination */
strarr[++i] = NULL;
return strarr;
}
Do flash?
malloc, jakmile ho někde použiješ, program se zvětší přibližně o 500B (o 600B, pokud nepoužíváš optimalizace). Na to hned navazuje nedostatek RAM paměti v tom procesoru všeobecně. Použití dynamické alokace paměti kus paměti sebere jenom na svou režii. Do toho přijdej, že char *string je taky uložen v paměti. No a nakonec ta rozdělená slova jsou taky uložena v paměti. Čiže: ten celý řetězec je tam v jednu chvíli uložen dvakrát, čímž se maximální délka rozdělitelného řetězce snižuje na nějakých 50B, možná ani to ne - každé slovo zabere 2B jenom tím, že na něj existuje ukazatel, volání funkcí potřebuje volnou paměť kvůli zásobníku (a ne málo) atd.
Kde by se dalo ušetřit, je změnit tu funkci tak, aby vracela ukazatele do toho původního řetězce. Tedy
char ** explode(char separator, char *string)
{
// Tenhle kus necháme
int start = 0, i, k = 1, count = 2;
char **strarr;
for (i = 0; string[i] != '\0'; i++)
/* how many rows do we need for our array? */
if (string[i] == separator)
count++;
/* count is at least 2 to make room for the entire string
* and the ending NULL */
strarr = malloc(count * sizeof(char*));
i = 0;
// Tenhle kus změníme
while (*string != '\0')
{
if (*string == separator)
{
strarr[i] = string;
i++;
}
string++;
}
return strarr
Kód je jen pro náhled, tak, jak je, možná nebude fungovat. Ale pozor! Tohle řešení používá pro původní řetězec i rozdělená slova stejnou paměť. Jinak řečeno když do funkce vrazíš string a změníš jedno z vrácených slov, pak se změní i string. A obráceně.
Mnohem rozumnější ale bude pořídit si jiný čip, protože Attiny2313 není zrovna nejvhodnější pro laborování s jazykem C. Jakmile se pustíš do něčeho složitějšího (a to používání malloc určitě je), tak rychle dojde paměť. Docela levně se dá pořídit ATmega8, ta má 1kB RAM a 8kB flash, tam se chvíli vejdeš.
24.9.2008 21:05
// Tenhle kus změníme
while (*string != '\0')
{
if (*string == separator)
{
*string = 0;
string++;
strarr[i] = string;
i++;
}
string++;
}
Pokud chceš komprimovanou verzi:
char *p = string;
i = 0;
while ((p = strchr(p, separator))) {
*p = 0;
strarr[i++] = ++p;
}
ps: netestoval jsem to
char ** explode(char *str, char separator)
{
char *p = str;
i = 1;
i_max = 16; // obvykly maximalni pocet casti
char ** buf = (char **) malloc(sizeof(char *), i_max);
buf[0] = str; // cast pred prvnim oddelovacem
while ((p = strchr(p, separator))) {
*p = 0;
buf[i++] = ++p;
// alokace dalsi pameti, pokud nestaci na dalsi iteraci
if (i == i_max) {
i_max *= 2;
buf = (char **) realloc(buf, i_max * sizeof(char *));
}
}
buf[i] = NULL; // zakonceni pole
return buf; // nezapomenout pak free(buf)
}
ps: ani nyni jsem to netestoval
Tohle nebude fungovat moc hezky, protože uložíš pointer na oddělovač a ne na začátek řetězce za oddělovačem.To je klidně možný, taky jsem říkal, že je to jenom pro náhled. Očekávám trochu invence ze strany tazatele, že si to překontroluje a opraví.
Pokud chceš komprimovanou verzi:Tahle komprimovaná verze je možná z hlediska jazyka C hezky napsaná, ale zabere 74B (ten strchr stojí 40B), kdežto ta původní jenom 50B.
(Nečetl jsem diskusi celou.) Ale možná by pomohla vlastní implementace strchr() 
malloc a realloc v té funkci explode zaberou čtvrtinu té flash a to ten program ještě nic nedělá. Takže bych řekl, že na rozdílu v desítkách bytů na první pohled záleží, ale na druhý to možná bude jedno, protože ten program se stejně nevejde.
S tím assemblerem souhlasím.
Tiskni
Sdílej:
